Add git-style diff view for CloudFormation change sets

- Replace property-by-property arrow notation with unified diff format
- Use BeforeContext/AfterContext to show complete resource diffs
- Display changes with +/- prefixes in diff code blocks
- Add inline recreation warnings on properties that require replacement
- Fix Tags display by using full context instead of individual Details
- Consistent formatting across Add, Modify, and Remove actions

Author: kddejong

__tests__/changeset-formatter.test.ts

@@ -426,6 +426,16 @@ describe('Change Set Formatter', () => {
             ResourceType: 'AWS::DynamoDB::Table',
             Replacement: 'True',
             Scope: ['Properties'],
+            BeforeContext: JSON.stringify({
+              Properties: {
+                BillingMode: 'PROVISIONED'
+              }
+            }),
+            AfterContext: JSON.stringify({
+              Properties: {
+                BillingMode: 'PAY_PER_REQUEST'
+              }
+            }),
             Details: [
               {
                 Target: {
@@ -458,9 +468,189 @@ describe('Change Set Formatter', () => {
     )
     expect(markdown).toContain('**Physical ID:** `my-table-123`')
     expect(markdown).toContain('⚠️ **This resource will be replaced**')
-    expect(markdown).toContain(
-      '**BillingMode:** `PROVISIONED` → `PAY_PER_REQUEST`'
+    expect(markdown).toContain('```diff')
+    expect(markdown).toContain('⚠️ Requires recreation: Always')
+  })
+
+  test('displays AfterContext for Add actions in console output', () => {
+    const changesSummary = JSON.stringify({
+      changes: [
+        {
+          Type: 'Resource',
+          ResourceChange: {
+            Action: 'Add',
+            LogicalResourceId: 'NewBucket',
+            ResourceType: 'AWS::S3::Bucket',
+            AfterContext:
+              '{"BucketName":"my-bucket","Versioning":{"Status":"Enabled"}}'
+          }
+        }
+      ],
+      totalChanges: 1,
+      truncated: false
+    })
+
+    displayChangeSet(changesSummary, 1, true)
+
+    expect(core.info).toHaveBeenCalledWith(
+      expect.stringContaining('Properties:')
+    )
+    expect(core.info).toHaveBeenCalledWith(
+      expect.stringContaining('BucketName')
     )
+  })
+
+  test('displays BeforeContext for Remove actions in console output', () => {
+    const changesSummary = JSON.stringify({
+      changes: [
+        {
+          Type: 'Resource',
+          ResourceChange: {
+            Action: 'Remove',
+            LogicalResourceId: 'OldBucket',
+            ResourceType: 'AWS::S3::Bucket',
+            BeforeContext: '{"BucketName":"old-bucket"}'
+          }
+        }
+      ],
+      totalChanges: 1,
+      truncated: false
+    })
+
+    displayChangeSet(changesSummary, 1, true)
+
+    expect(core.info).toHaveBeenCalledWith(
+      expect.stringContaining('Properties:')
+    )
+    expect(core.info).toHaveBeenCalledWith(
+      expect.stringContaining('BucketName')
+    )
+  })
+
+  test('handles invalid JSON in AfterContext gracefully', () => {
+    const changesSummary = JSON.stringify({
+      changes: [
+        {
+          Type: 'Resource',
+          ResourceChange: {
+            Action: 'Add',
+            LogicalResourceId: 'NewResource',
+            ResourceType: 'AWS::Custom::Resource',
+            AfterContext: 'invalid-json{'
+          }
+        }
+      ],
+      totalChanges: 1,
+      truncated: false
+    })
+
+    displayChangeSet(changesSummary, 1, true)
+
+    expect(core.info).toHaveBeenCalledWith(
+      expect.stringContaining('invalid-json{')
+    )
+  })
+
+  test('handles invalid JSON in BeforeContext gracefully', () => {
+    const changesSummary = JSON.stringify({
+      changes: [
+        {
+          Type: 'Resource',
+          ResourceChange: {
+            Action: 'Remove',
+            LogicalResourceId: 'OldResource',
+            ResourceType: 'AWS::Custom::Resource',
+            BeforeContext: 'invalid-json{'
+          }
+        }
+      ],
+      totalChanges: 1,
+      truncated: false
+    })
+
+    displayChangeSet(changesSummary, 1, true)
+
+    expect(core.info).toHaveBeenCalledWith(
+      expect.stringContaining('invalid-json{')
+    )
+  })
+
+  test('generates diff view for resources with BeforeContext/AfterContext', () => {
+    const changesSummary = JSON.stringify({
+      changes: [
+        {
+          Type: 'Resource',
+          ResourceChange: {
+            Action: 'Modify',
+            LogicalResourceId: 'MyTopic',
+            ResourceType: 'AWS::SNS::Topic',
+            Replacement: 'False',
+            BeforeContext: JSON.stringify({
+              Properties: {
+                DisplayName: 'old-name',
+                Tags: [{ Key: 'Env', Value: 'dev' }]
+              }
+            }),
+            AfterContext: JSON.stringify({
+              Properties: {
+                DisplayName: 'new-name',
+                Tags: [{ Key: 'Env', Value: 'prod' }]
+              }
+            })
+          }
+        }
+      ],
+      totalChanges: 1,
+      truncated: false
+    })
+
+    const markdown = generateChangeSetMarkdown(changesSummary)
+
+    expect(markdown).toContain('```diff')
+    expect(markdown).toContain('-')
+    expect(markdown).toContain('+')
+  })
+
+  test('shows recreation warnings in diff view', () => {
+    const changesSummary = JSON.stringify({
+      changes: [
+        {
+          Type: 'Resource',
+          ResourceChange: {
+            Action: 'Modify',
+            LogicalResourceId: 'MyParam',
+            ResourceType: 'AWS::SSM::Parameter',
+            Replacement: 'True',
+            BeforeContext: JSON.stringify({
+              Properties: {
+                Name: '/old/path',
+                Value: 'old'
+              }
+            }),
+            AfterContext: JSON.stringify({
+              Properties: {
+                Name: '/new/path',
+                Value: 'new'
+              }
+            }),
+            Details: [
+              {
+                Target: {
+                  Name: 'Name',
+                  RequiresRecreation: 'Always'
+                }
+              }
+            ]
+          }
+        }
+      ],
+      totalChanges: 1,
+      truncated: false
+    })
+
+    const markdown = generateChangeSetMarkdown(changesSummary)
+
+    expect(markdown).toContain('```diff')
     expect(markdown).toContain('⚠️ Requires recreation: Always')
   })
 })

dist/index.js

@@ -59733,6 +59733,62 @@ Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.displayChangeSet = displayChangeSet;
 exports.generateChangeSetMarkdown = generateChangeSetMarkdown;
 const core = __importStar(__nccwpck_require__(7484));
+/**
+ * Generate a git-style diff view of JSON objects with recreation warnings
+ */
+function generateJsonDiff(before, after, details) {
+    const beforeJson = before ? JSON.stringify(before, null, 2) : '{}';
+    const afterJson = after ? JSON.stringify(after, null, 2) : '{}';
+    if (beforeJson === afterJson) {
+        return '```json\n' + beforeJson + '\n```\n';
+    }
+    // Build map of properties that require recreation
+    const recreationMap = new Map();
+    if (details) {
+        for (const detail of details) {
+            const target = detail.Target;
+            if ((target === null || target === void 0 ? void 0 : target.Name) &&
+                target.RequiresRecreation &&
+                target.RequiresRecreation !== 'Never') {
+                recreationMap.set(target.Name, target.RequiresRecreation);
+            }
+        }
+    }
+    const beforeLines = beforeJson.split('\n');
+    const afterLines = afterJson.split('\n');
+    const diff = [];
+    let i = 0;
+    let j = 0;
+    while (i < beforeLines.length || j < afterLines.length) {
+        const beforeLine = beforeLines[i];
+        const afterLine = afterLines[j];
+        if (beforeLine === afterLine) {
+            diff.push(' ' + beforeLine);
+            i++;
+            j++;
+        }
+        else if (i < beforeLines.length && !afterLines.includes(beforeLines[i])) {
+            diff.push('-' + beforeLine);
+            i++;
+        }
+        else if (j < afterLines.length) {
+            let line = '+' + afterLine;
+            // Check if this line contains a property that requires recreation
+            for (const [propName, recreationType] of recreationMap) {
+                if (afterLine.includes(`"${propName}"`)) {
+                    line += ` ⚠️ Requires recreation: ${recreationType}`;
+                    break;
+                }
+            }
+            diff.push(line);
+            j++;
+        }
+        else {
+            i++;
+        }
+    }
+    return '```diff\n' + diff.join('\n') + '\n```\n';
+}
 /**
  * ANSI color codes
  */
@@ -60044,52 +60100,29 @@ function generateChangeSetMarkdown(changesSummary) {
             else if (rc.Action === 'Modify' && rc.Replacement === 'Conditional') {
                 markdown += `⚠️ **May require replacement**\n\n`;
             }
-            // Property changes
-            if (rc.Details && rc.Details.length > 0) {
-                markdown += '**Property Changes:**\n\n';
-                for (const detail of rc.Details) {
-                    const target = detail.Target;
-                    if (!target)
-                        continue;
-                    const propName = target.Name || target.Attribute || 'Unknown';
-                    if (target.BeforeValue && target.AfterValue) {
-                        markdown += `- **${propName}:** \`${target.BeforeValue}\` → \`${target.AfterValue}\`\n`;
-                    }
-                    else if (target.AfterValue) {
-                        markdown += `- **${propName}:** (added) → \`${target.AfterValue}\`\n`;
-                    }
-                    else if (target.BeforeValue) {
-                        markdown += `- **${propName}:** \`${target.BeforeValue}\` → (removed)\n`;
-                    }
-                    if (target.RequiresRecreation &&
-                        target.RequiresRecreation !== 'Never') {
-                        markdown += `  - ⚠️ Requires recreation: ${target.RequiresRecreation}\n`;
-                    }
-                }
-                markdown += '\n';
-            }
-            // AfterContext for Add actions
-            if (rc.Action === 'Add' && rc.AfterContext) {
+            // Show diff view using BeforeContext/AfterContext when available
+            if (rc.BeforeContext || rc.AfterContext) {
                 try {
-                    const afterProps = JSON.parse(rc.AfterContext);
-                    markdown += '\n**Properties:**\n```json\n';
-                    markdown += JSON.stringify(afterProps, null, 2);
-                    markdown += '\n```\n';
+                    const before = rc.BeforeContext
+                        ? JSON.parse(rc.BeforeContext)
+                        : undefined;
+                    const after = rc.AfterContext
+                        ? JSON.parse(rc.AfterContext)
+                        : undefined;
+                    markdown += generateJsonDiff(before, after, rc.Details);
                 }
                 catch (_c) {
-                    // Skip if can't parse
-                }
-            }
-            // BeforeContext for Remove actions
-            if (rc.Action === 'Remove' && rc.BeforeContext) {
-                try {
-                    const beforeProps = JSON.parse(rc.BeforeContext);
-                    markdown += '\n**Properties:**\n```json\n';
-                    markdown += JSON.stringify(beforeProps, null, 2);
-                    markdown += '\n```\n';
-                }
-                catch (_d) {
-                    // Skip if can't parse
+                    // If parsing fails, fall back to showing raw JSON
+                    if (rc.AfterContext) {
+                        markdown += '\n**Properties:**\n```json\n';
+                        markdown += rc.AfterContext;
+                        markdown += '\n```\n';
+                    }
+                    else if (rc.BeforeContext) {
+                        markdown += '\n**Properties:**\n```json\n';
+                        markdown += rc.BeforeContext;
+                        markdown += '\n```\n';
+                    }
                 }
             }
             markdown += '\n</details>\n\n';