@aws-amplify/cli-internal-gen2-migration-experimental-alpha 0.1.0

package/lib/commands/drift-detection/services/drift-formatter.js

@@ -0,0 +1,651 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DriftFormatter = void 0;
+const client_cloudformation_1 = require("@aws-sdk/client-cloudformation");
+const chalk_1 = __importDefault(require("chalk"));
+const amplify_config_service_1 = require("./amplify-config-service");
+const DISPLAY_CONSTANTS = {
+    BORDER_WIDTH: 61,
+    TITLE_PADDING: 19,
+    LABEL_PROJECT: 10,
+    LABEL_STACKS_CHECKED: 23,
+    LABEL_RESOURCES_DRIFT: 23,
+    LABEL_RESOURCES_SYNC: 20,
+    LABEL_UNCHECKED: 22,
+    LABEL_FAILED: 22,
+};
+const TREE_SYMBOLS = {
+    BRANCH: '├──',
+    LAST_BRANCH: '└──',
+    VERTICAL: '│   ',
+    EMPTY: '    ',
+};
+class DriftFormatter {
+    constructor(cfnService) {
+        this.rootStackName = '';
+        this.rootTemplate = {};
+        this.rootDrifts = [];
+        this.nestedStacks = [];
+        this.summary = {
+            totalStacks: 0,
+            totalDrifted: 0,
+            totalInSync: 0,
+            totalUnchecked: 0,
+            totalFailed: 0,
+        };
+        this.phase2Results = null;
+        this.phase3Results = null;
+        this.configService = new amplify_config_service_1.AmplifyConfigService();
+        this.cfnService = cfnService;
+    }
+    async processResults(cfn, stackName, rootTemplate, combinedResults) {
+        this.rootStackName = stackName;
+        this.rootTemplate = rootTemplate;
+        this.rootDrifts = combinedResults.rootStackDrifts.StackResourceDrifts || [];
+        this.summary = {
+            totalStacks: 1,
+            totalDrifted: 0,
+            totalInSync: 0,
+            totalUnchecked: 0,
+            totalFailed: 0,
+        };
+        this.summary.totalDrifted += this.countDrifted(this.rootDrifts);
+        this.summary.totalInSync += this.countInSync(this.rootDrifts);
+        this.summary.totalUnchecked += this.countUnchecked(this.rootDrifts, this.rootTemplate);
+        this.summary.totalFailed += this.countFailed(this.rootDrifts);
+        this.nestedStacks = [];
+        for (const [logicalId, nestedDrift] of combinedResults.nestedStackDrifts.entries()) {
+            if (!nestedDrift.StackResourceDrifts) {
+                continue;
+            }
+            const physicalName = combinedResults.nestedStackPhysicalIds.get(logicalId) || logicalId;
+            const nestedTemplate = await this.cfnService.getStackTemplate(cfn, physicalName);
+            const nestedDrifts = nestedDrift.StackResourceDrifts;
+            this.summary.totalDrifted += this.countDrifted(nestedDrifts);
+            this.summary.totalInSync += this.countInSync(nestedDrifts);
+            this.summary.totalUnchecked += this.countUnchecked(nestedDrifts, nestedTemplate);
+            this.summary.totalFailed += this.countFailed(nestedDrifts);
+            this.summary.totalStacks++;
+            this.nestedStacks.push({
+                logicalId,
+                physicalName,
+                category: this.configService.extractCategory(logicalId),
+                drifts: nestedDrifts,
+                template: nestedTemplate,
+            });
+        }
+    }
+    formatDrift(format = 'tree') {
+        const summaryDashboard = this.createSummaryDashboard();
+        let treeView;
+        let detailedChanges;
+        let categoryBreakdown;
+        switch (format) {
+            case 'tree':
+                treeView = this.createTreeView();
+                detailedChanges = this.createDetailedChanges();
+                categoryBreakdown = this.createCategoryBreakdown();
+                break;
+            case 'summary':
+                categoryBreakdown = this.createCategoryBreakdown();
+                break;
+            case 'json':
+                break;
+        }
+        return {
+            summaryDashboard,
+            treeView,
+            detailedChanges,
+            categoryBreakdown,
+            totalDrifted: this.summary.totalDrifted,
+        };
+    }
+    createSimplifiedJsonOutput() {
+        return {
+            stackName: this.rootStackName,
+            numResourcesWithDrift: this.summary.totalDrifted,
+            numResourcesUnchecked: this.summary.totalUnchecked,
+            timestamp: new Date().toISOString(),
+        };
+    }
+    createSummaryDashboard() {
+        const projectName = this.configService.getProjectName();
+        const border = '─'.repeat(DISPLAY_CONSTANTS.BORDER_WIDTH);
+        let dashboard = '';
+        dashboard += chalk_1.default.cyan(`┌${border}┐\n`);
+        dashboard += chalk_1.default.cyan(`│${' '.repeat(DISPLAY_CONSTANTS.TITLE_PADDING)}DRIFT DETECTION SUMMARY${' '.repeat(DISPLAY_CONSTANTS.TITLE_PADDING)}│\n`);
+        dashboard += chalk_1.default.cyan(`├${border}┤\n`);
+        dashboard += this.formatDashboardLine('Project', chalk_1.default.bold(projectName), DISPLAY_CONSTANTS.LABEL_PROJECT);
+        dashboard += this.formatDashboardLine('Total Stacks Checked', chalk_1.default.bold(this.summary.totalStacks), DISPLAY_CONSTANTS.LABEL_STACKS_CHECKED);
+        const driftedColor = this.summary.totalDrifted > 0 ? chalk_1.default.red : chalk_1.default.green;
+        dashboard += this.formatDashboardLine('Resources with Drift', driftedColor(this.summary.totalDrifted), DISPLAY_CONSTANTS.LABEL_RESOURCES_DRIFT);
+        dashboard += this.formatDashboardLine('Resources in Sync', chalk_1.default.green(this.summary.totalInSync), DISPLAY_CONSTANTS.LABEL_RESOURCES_SYNC);
+        dashboard += this.formatDashboardLine('Unchecked Resources', chalk_1.default.gray(this.summary.totalUnchecked), DISPLAY_CONSTANTS.LABEL_UNCHECKED);
+        if (this.summary.totalFailed > 0) {
+            dashboard += this.formatDashboardLine('Failed Drift Checks', chalk_1.default.yellow(this.summary.totalFailed), DISPLAY_CONSTANTS.LABEL_FAILED);
+        }
+        dashboard += chalk_1.default.cyan(`└${border}┘`);
+        if (this.summary.totalFailed > 0) {
+            dashboard +=
+                '\n' +
+                    chalk_1.default.yellow(`WARNING: Drift detection failed for ${this.summary.totalFailed} resource(s).\n` +
+                        `This may be due to insufficient permissions or AWS API issues.\n` +
+                        `Run with --debug to see which resources failed.`);
+        }
+        return dashboard;
+    }
+    formatDashboardLine(label, value, labelWidth) {
+        const stripAnsi = (str) => {
+            return str.replace(/\u001b\[[0-9;]*m/g, '');
+        };
+        const valueStr = value.toString();
+        const actualValueLength = stripAnsi(valueStr).length;
+        const usedLength = 2 + label.length + 2 + actualValueLength + 1;
+        const padding = DISPLAY_CONSTANTS.BORDER_WIDTH + 2 - usedLength;
+        return chalk_1.default.cyan(`│ ${label}: ${value}${' '.repeat(Math.max(0, padding))}│\n`);
+    }
+    createTreeView() {
+        let tree = '';
+        tree += chalk_1.default.bold('\nSTACK HIERARCHY:\n');
+        tree += `${chalk_1.default.blue(this.rootStackName)} ${chalk_1.default.gray('(ROOT)')}\n`;
+        const rootCounts = this.getResourceCounts(this.rootDrifts, this.rootTemplate);
+        tree += this.formatResourceCountsAsTree(rootCounts, '');
+        const stackHierarchy = this.buildStackHierarchy();
+        tree = this.renderStackHierarchy(stackHierarchy, tree, '');
+        return tree;
+    }
+    getResourceCounts(drifts, template) {
+        return {
+            drifted: this.countDrifted(drifts),
+            inSync: this.countInSync(drifts),
+            unchecked: this.countUnchecked(drifts, template),
+            failed: this.countFailed(drifts),
+        };
+    }
+    formatResourceCountsAsTree(counts, prefix) {
+        let result = '';
+        const items = [];
+        if (counts.drifted > 0) {
+            items.push({ label: 'DRIFTED', count: counts.drifted, color: chalk_1.default.red });
+        }
+        if (counts.inSync > 0) {
+            items.push({ label: 'IN SYNC', count: counts.inSync, color: chalk_1.default.green });
+        }
+        if (counts.unchecked > 0) {
+            items.push({ label: 'UNCHECKED', count: counts.unchecked, color: chalk_1.default.gray });
+        }
+        if (counts.failed > 0) {
+            items.push({ label: 'FAILED', count: counts.failed, color: chalk_1.default.yellow });
+        }
+        items.forEach((item, index) => {
+            const isLast = index === items.length - 1;
+            const symbol = isLast ? TREE_SYMBOLS.LAST_BRANCH : TREE_SYMBOLS.BRANCH;
+            const plural = item.count === 1 ? '' : 's';
+            result += `${prefix}${symbol} ${item.color(`${item.label}:`)} ${item.count} resource${plural}\n`;
+        });
+        return result;
+    }
+    buildStackHierarchy() {
+        const hierarchy = new Map();
+        this.nestedStacks.forEach((nestedStack) => {
+            const parts = nestedStack.logicalId.split('/');
+            if (parts.length === 1) {
+                if (!hierarchy.has(parts[0])) {
+                    hierarchy.set(parts[0], {
+                        stack: nestedStack,
+                        children: new Map(),
+                    });
+                }
+            }
+            else {
+                const topLevel = parts[0];
+                const childName = parts.slice(1).join('/');
+                if (!hierarchy.has(topLevel)) {
+                    hierarchy.set(topLevel, {
+                        stack: null,
+                        children: new Map(),
+                    });
+                }
+                const parent = hierarchy.get(topLevel);
+                parent.children.set(childName, {
+                    stack: nestedStack,
+                    children: new Map(),
+                });
+            }
+        });
+        return hierarchy;
+    }
+    renderStackHierarchy(hierarchy, tree, prefix) {
+        const entries = Array.from(hierarchy.entries());
+        entries.forEach(([name, node], index) => {
+            const isLastItem = index === entries.length - 1;
+            const nodePrefix = isLastItem ? TREE_SYMBOLS.LAST_BRANCH : TREE_SYMBOLS.BRANCH;
+            const childPrefix = isLastItem ? TREE_SYMBOLS.EMPTY : TREE_SYMBOLS.VERTICAL;
+            if (node.stack) {
+                const counts = this.getResourceCounts(node.stack.drifts, node.stack.template);
+                const categoryName = this.determineCategory(node.stack.category || node.stack.logicalId);
+                const displayName = name.includes('/') ? name.split('/').pop() : name;
+                tree += `${prefix}${nodePrefix} ${chalk_1.default.blue(displayName)} ${chalk_1.default.gray(`(${categoryName})`)}\n`;
+                const resourcePrefix = prefix + childPrefix;
+                tree += this.formatResourceCountsAsTree(counts, resourcePrefix);
+                if (node.children && node.children.size > 0) {
+                    tree = this.renderStackHierarchy(node.children, tree, prefix + childPrefix);
+                }
+            }
+        });
+        return tree;
+    }
+    createDetailedChanges() {
+        const allDriftedResources = this.getAllDriftedResources();
+        if (allDriftedResources.length === 0) {
+            return '';
+        }
+        let details = chalk_1.default.bold('\nDETAILED CHANGES:\n');
+        allDriftedResources.forEach((drift, index) => {
+            const isLast = index === allDriftedResources.length - 1;
+            details += this.formatDriftedResource(drift, isLast);
+        });
+        return details;
+    }
+    getAllDriftedResources() {
+        const rootDrifted = this.getDriftedResources(this.rootDrifts).map((drift) => ({
+            ...drift,
+            stackContext: 'ROOT',
+            stackName: this.rootStackName,
+            category: 'Core Infrastructure',
+        }));
+        const nestedDrifted = this.nestedStacks.flatMap((stack) => this.getDriftedResources(stack.drifts).map((drift) => ({
+            ...drift,
+            stackContext: stack.logicalId,
+            stackName: stack.physicalName,
+            category: this.determineCategory(stack.category || stack.logicalId),
+        })));
+        return [...rootDrifted, ...nestedDrifted];
+    }
+    formatDriftedResource(drift, isLast) {
+        const prefix = isLast ? TREE_SYMBOLS.LAST_BRANCH : TREE_SYMBOLS.BRANCH;
+        const parentContext = drift.stackContext === 'ROOT'
+            ? chalk_1.default.gray(` → ${chalk_1.default.bold('Root Stack')}`)
+            : chalk_1.default.gray(` → ${chalk_1.default.bold(drift.category)} → ${drift.stackContext}`);
+        let result = `${prefix} ${chalk_1.default.red('DRIFTED:')} ${chalk_1.default.cyan(drift.ResourceType)} ${chalk_1.default.bold(drift.LogicalResourceId)}${parentContext}\n`;
+        if (drift.PropertyDifferences && drift.PropertyDifferences.length > 0) {
+            const detailPrefix = isLast ? TREE_SYMBOLS.EMPTY : TREE_SYMBOLS.VERTICAL;
+            result += this.formatPropertyDifferences(drift.PropertyDifferences, detailPrefix);
+        }
+        return result;
+    }
+    formatPropertyDifferences(differences, prefix) {
+        let result = '';
+        differences.forEach((propDiff, propIndex) => {
+            const isLastProp = propIndex === differences.length - 1;
+            const propPrefix = isLastProp ? TREE_SYMBOLS.LAST_BRANCH : TREE_SYMBOLS.BRANCH;
+            result += `${prefix}${propPrefix} ${chalk_1.default.yellow('PROPERTY:')} ${propDiff.PropertyPath}\n`;
+            const valuePrefix = isLastProp ? TREE_SYMBOLS.EMPTY : TREE_SYMBOLS.VERTICAL;
+            result += `${prefix}${valuePrefix}├── ${chalk_1.default.green('[+]')} ${chalk_1.default.green(propDiff.ActualValue)}\n`;
+            result += `${prefix}${valuePrefix}└── ${chalk_1.default.red('[-]')} ${chalk_1.default.red(propDiff.ExpectedValue)}\n`;
+        });
+        return result;
+    }
+    createCategoryBreakdown() {
+        let breakdown = chalk_1.default.bold('\nAMPLIFY CATEGORIES:\n');
+        const categories = this.groupStacksByCategory();
+        const categoryEntries = Array.from(categories.entries());
+        categoryEntries.forEach(([categoryName, stacks], categoryIndex) => {
+            const isLastCategory = categoryIndex === categoryEntries.length - 1;
+            const categoryPrefix = isLastCategory ? TREE_SYMBOLS.LAST_BRANCH : TREE_SYMBOLS.BRANCH;
+            const categoryIcon = this.getCategoryIcon(categoryName);
+            const totalDrifted = stacks.reduce((sum, stack) => sum + stack.drifted, 0);
+            const statusText = totalDrifted > 0
+                ? chalk_1.default.red(`DRIFT DETECTED: ${totalDrifted} resource${totalDrifted === 1 ? '' : 's'}`)
+                : chalk_1.default.green('NO DRIFT DETECTED');
+            breakdown += `${categoryPrefix} ${categoryIcon} ${chalk_1.default.bold(categoryName)}\n`;
+            const stackPrefix = isLastCategory ? TREE_SYMBOLS.EMPTY : TREE_SYMBOLS.VERTICAL;
+            breakdown += `${stackPrefix}└── Status: ${statusText}\n`;
+        });
+        return breakdown;
+    }
+    groupStacksByCategory() {
+        const categories = new Map();
+        const rootCounts = this.getResourceCounts(this.rootDrifts, this.rootTemplate);
+        categories.set('Core Infrastructure', [
+            {
+                name: 'Root Stack',
+                ...rootCounts,
+            },
+        ]);
+        this.nestedStacks.forEach((stack) => {
+            const categoryName = this.determineCategory(stack.category || stack.logicalId);
+            const counts = this.getResourceCounts(stack.drifts, stack.template);
+            if (!categories.has(categoryName)) {
+                categories.set(categoryName, []);
+            }
+            categories.get(categoryName).push({
+                name: stack.logicalId,
+                ...counts,
+            });
+        });
+        return categories;
+    }
+    countDrifted(drifts) {
+        return drifts.filter((d) => d.StackResourceDriftStatus === client_cloudformation_1.StackResourceDriftStatus.MODIFIED || d.StackResourceDriftStatus === client_cloudformation_1.StackResourceDriftStatus.DELETED).length;
+    }
+    countInSync(drifts) {
+        return drifts.filter((d) => d.StackResourceDriftStatus === client_cloudformation_1.StackResourceDriftStatus.IN_SYNC).length;
+    }
+    countUnchecked(drifts, template) {
+        const checkedResourceIds = new Set(drifts.map((d) => d.LogicalResourceId));
+        const allResourceIds = Object.keys(template.Resources || {});
+        const notInResults = allResourceIds.filter((id) => !checkedResourceIds.has(id)).length;
+        const notChecked = drifts.filter((d) => d.StackResourceDriftStatus === client_cloudformation_1.StackResourceDriftStatus.NOT_CHECKED).length;
+        return notInResults + notChecked;
+    }
+    countFailed(drifts) {
+        return drifts.filter((d) => d.StackResourceDriftStatus === client_cloudformation_1.StackResourceDriftStatus.UNKNOWN).length;
+    }
+    getDriftedResources(drifts) {
+        return drifts.filter((d) => d.StackResourceDriftStatus === client_cloudformation_1.StackResourceDriftStatus.MODIFIED || d.StackResourceDriftStatus === client_cloudformation_1.StackResourceDriftStatus.DELETED);
+    }
+    determineCategory(identifier) {
+        const idLower = identifier.toLowerCase();
+        if (idLower.includes('auth'))
+            return 'Auth';
+        if (idLower.includes('storage'))
+            return 'Storage';
+        if (idLower.includes('function'))
+            return 'Function';
+        if (idLower.includes('api'))
+            return 'API';
+        if (idLower.includes('hosting'))
+            return 'Hosting';
+        if (idLower.includes('analytics'))
+            return 'Analytics';
+        if (idLower.includes('core') || idLower.includes('infrastructure'))
+            return 'Core Infrastructure';
+        return 'Other';
+    }
+    getCategoryIcon(category) {
+        switch (category) {
+            case 'Auth':
+                return chalk_1.default.magenta('[AUTH]');
+            case 'Storage':
+                return chalk_1.default.blue('[STORAGE]');
+            case 'Function':
+                return chalk_1.default.yellow('[FUNCTION]');
+            case 'API':
+                return chalk_1.default.green('[API]');
+            case 'Hosting':
+                return chalk_1.default.cyan('[HOSTING]');
+            case 'Analytics':
+                return chalk_1.default.red('[ANALYTICS]');
+            case 'Core Infrastructure':
+                return chalk_1.default.gray('[CORE]');
+            default:
+                return chalk_1.default.white('[OTHER]');
+        }
+    }
+    addPhase2Results(results) {
+        this.phase2Results = results;
+    }
+    addPhase3Results(results) {
+        this.phase3Results = results;
+    }
+    formatNestedChanges(nestedChanges, prefix, level) {
+        let output = '';
+        nestedChanges.forEach((change, index) => {
+            const isLast = index === nestedChanges.length - 1;
+            const changePrefix = isLast ? '└──' : '├──';
+            const action = change.action || 'Unknown';
+            const resourceId = change.logicalResourceId || 'Unknown';
+            const resourceType = change.resourceType || 'Unknown';
+            let actionColor = chalk_1.default.yellow;
+            let actionSymbol = '~';
+            if (action === 'Add') {
+                actionColor = chalk_1.default.green;
+                actionSymbol = '+';
+            }
+            else if (action === 'Remove') {
+                actionColor = chalk_1.default.red;
+                actionSymbol = '-';
+            }
+            else if (action === 'Modify') {
+                actionColor = chalk_1.default.yellow;
+                actionSymbol = '~';
+            }
+            output += `\n${prefix}${changePrefix} ${actionColor(`${actionSymbol} ${action}`)}: ${chalk_1.default.bold(resourceId)} (${chalk_1.default.gray(resourceType)})`;
+            if (change.details && change.details.length > 0) {
+                const detailPrefix = isLast ? '    ' : '│   ';
+                change.details.forEach((detail) => {
+                    if (detail.name) {
+                        output += `\n${prefix}${detailPrefix}└── Property: ${detail.name}`;
+                        if (detail.changeSource) {
+                            output += chalk_1.default.gray(` (${detail.changeSource})`);
+                        }
+                    }
+                });
+            }
+            if (change.nestedChanges && change.nestedChanges.length > 0) {
+                const childPrefix = isLast ? '    ' : '│   ';
+                output += this.formatNestedChanges(change.nestedChanges, prefix + childPrefix, level + 1);
+            }
+        });
+        return output;
+    }
+    formatPhase2Results() {
+        if (!this.phase2Results)
+            return null;
+        if (this.phase2Results.skipped || this.phase2Results.error) {
+            return null;
+        }
+        const changes = this.phase2Results.changes || [];
+        if (changes.length === 0) {
+            return '\nTEMPLATE CHANGES:\n└── Status: NO DRIFT DETECTED';
+        }
+        let output = '\nTEMPLATE CHANGES:';
+        if (changes.length > 0) {
+            output += '\n├── Status: ' + chalk_1.default.yellow('DRIFT DETECTED');
+            changes.forEach((change, index) => {
+                const isLast = index === changes.length - 1;
+                const prefix = isLast ? '└──' : '├──';
+                const action = change.action || 'Unknown';
+                const resourceId = change.logicalResourceId || 'Unknown';
+                const resourceType = change.resourceType || 'Unknown';
+                let actionColor = chalk_1.default.yellow;
+                let actionSymbol = '~';
+                if (action === 'Add') {
+                    actionColor = chalk_1.default.green;
+                    actionSymbol = '+';
+                }
+                else if (action === 'Remove') {
+                    actionColor = chalk_1.default.red;
+                    actionSymbol = '-';
+                }
+                else if (action === 'Modify') {
+                    actionColor = chalk_1.default.yellow;
+                    actionSymbol = '~';
+                }
+                output += `\n${prefix} ${actionColor(`${actionSymbol} ${action}`)}: ${chalk_1.default.bold(resourceId)} (${chalk_1.default.gray(resourceType)})`;
+                if (change.replacement) {
+                    output += chalk_1.default.red(' [REQUIRES REPLACEMENT]');
+                }
+                if (change.details && change.details.length > 0) {
+                    const detailPrefix = isLast ? '    ' : '│   ';
+                    const isNestedStack = resourceType === 'AWS::CloudFormation::Stack';
+                    const hasOnlyAutomaticChanges = change.details.every((d) => d.changeSource === 'Automatic' && !d.name);
+                    if (isNestedStack && hasOnlyAutomaticChanges) {
+                        if (change.nestedChanges && change.nestedChanges.length > 0) {
+                            output += `\n${detailPrefix}└── ${chalk_1.default.cyan('Nested stack changes detected:')}`;
+                            change.nestedChanges.forEach((nestedChange, nestedIndex) => {
+                                const isLastNested = nestedIndex === change.nestedChanges.length - 1;
+                                const nestedPrefix = isLastNested ? '    └──' : '    ├──';
+                                const nestedAction = nestedChange.action || 'Unknown';
+                                const nestedResourceId = nestedChange.logicalResourceId || 'Unknown';
+                                const nestedResourceType = nestedChange.resourceType || 'Unknown';
+                                let nestedActionColor = chalk_1.default.yellow;
+                                let nestedActionSymbol = '~';
+                                if (nestedAction === 'Add') {
+                                    nestedActionColor = chalk_1.default.green;
+                                    nestedActionSymbol = '+';
+                                }
+                                else if (nestedAction === 'Remove') {
+                                    nestedActionColor = chalk_1.default.red;
+                                    nestedActionSymbol = '-';
+                                }
+                                else if (nestedAction === 'Modify') {
+                                    nestedActionColor = chalk_1.default.yellow;
+                                    nestedActionSymbol = '~';
+                                }
+                                output += `\n${detailPrefix}${nestedPrefix} ${nestedActionColor(`${nestedActionSymbol} ${nestedAction}`)}: ${chalk_1.default.bold(nestedResourceId)} (${chalk_1.default.gray(nestedResourceType)})`;
+                                if (nestedChange.details && nestedChange.details.length > 0) {
+                                    const nestedDetailPrefix = isLastNested ? '            ' : '    │       ';
+                                    nestedChange.details.forEach((detail) => {
+                                        if (detail.name) {
+                                            output += `\n${detailPrefix}${nestedDetailPrefix}└── Property: ${detail.name}`;
+                                        }
+                                    });
+                                }
+                                if (nestedChange.nestedChanges && nestedChange.nestedChanges.length > 0) {
+                                    output += this.formatNestedChanges(nestedChange.nestedChanges, detailPrefix + '        ', 3);
+                                }
+                            });
+                        }
+                        else {
+                            output += `\n${detailPrefix}└── ${chalk_1.default.cyan('Template changed in nested stack')}`;
+                            output += `\n${detailPrefix}    ${chalk_1.default.gray('(The nested stack template or its resources have been modified)')}`;
+                        }
+                    }
+                    else {
+                        const propDetails = change.details.filter((d) => d.name);
+                        if (propDetails.length > 0) {
+                            propDetails.forEach((detail, detailIndex) => {
+                                const isLastDetail = detailIndex === propDetails.length - 1;
+                                const detailSymbol = isLastDetail ? '└──' : '├──';
+                                let changeType = 'Modified';
+                                let changeColor = chalk_1.default.yellow;
+                                if (detail.changeSource === 'DirectModification') {
+                                    changeType = 'Direct Change';
+                                    changeColor = chalk_1.default.cyan;
+                                }
+                                else if (detail.changeSource === 'Automatic') {
+                                    changeType = 'Automatic';
+                                    changeColor = chalk_1.default.gray;
+                                }
+                                output += `\n${detailPrefix}${detailSymbol} ${chalk_1.default.bold('Property')}: ${detail.name}`;
+                                if (detail.requiresRecreation) {
+                                    const recreationPrefix = isLastDetail ? '        ' : '│       ';
+                                    const recreationType = detail.requiresRecreation === 'Always'
+                                        ? chalk_1.default.red('Always requires replacement')
+                                        : detail.requiresRecreation === 'Never'
+                                            ? chalk_1.default.green('No replacement needed')
+                                            : chalk_1.default.yellow('May require replacement');
+                                    output += `\n${detailPrefix}${recreationPrefix}└── Impact: ${recreationType}`;
+                                }
+                            });
+                        }
+                        else if (change.details.length > 0) {
+                            output += `\n${detailPrefix}└── ${chalk_1.default.gray('Template or configuration change detected')}`;
+                        }
+                    }
+                }
+            });
+        }
+        else {
+            output += '\n└── Status: NO DRIFT DETECTED';
+        }
+        return output;
+    }
+    formatPhase3Results() {
+        if (!this.phase3Results) {
+            return '';
+        }
+        let output = '';
+        output += chalk_1.default.bold('\nLOCAL CHANGES:\n');
+        if (this.phase3Results.skipped) {
+            output += `└── Status: ${chalk_1.default.gray(this.phase3Results.skipReason)}\n`;
+            return output;
+        }
+        const categoryGroups = this.groupPhase3ResourcesByCategory();
+        const allCategories = this.getAllCategoriesForPhase3(categoryGroups);
+        const categoryEntries = Array.from(allCategories.entries());
+        const hasConfigUpdates = !this.phase3Results.skipped && (this.phase3Results.tagsUpdated || this.phase3Results.rootStackUpdated);
+        categoryEntries.forEach(([categoryName, resources], categoryIndex) => {
+            const isLastCategory = categoryIndex === categoryEntries.length - 1;
+            const categoryPrefix = isLastCategory ? TREE_SYMBOLS.LAST_BRANCH : TREE_SYMBOLS.BRANCH;
+            const categoryIcon = this.getCategoryIcon(categoryName);
+            let statusText;
+            if (categoryName === 'Core Infrastructure') {
+                const resourceCount = resources.length;
+                const configCount = hasConfigUpdates ? 1 : 0;
+                const totalCount = resourceCount + configCount;
+                if (totalCount > 0) {
+                    const items = [];
+                    if (resourceCount > 0)
+                        items.push(`${resourceCount} resource${resourceCount === 1 ? '' : 's'}`);
+                    if (!this.phase3Results.skipped && this.phase3Results.tagsUpdated)
+                        items.push('tags');
+                    if (!this.phase3Results.skipped && this.phase3Results.rootStackUpdated)
+                        items.push('root stack');
+                    statusText = chalk_1.default.red(`DRIFT DETECTED: ${items.join(', ')}`);
+                }
+                else {
+                    statusText = chalk_1.default.green('NO DRIFT DETECTED');
+                }
+            }
+            else {
+                statusText =
+                    resources.length > 0
+                        ? chalk_1.default.red(`DRIFT DETECTED: ${resources.length} resource${resources.length === 1 ? '' : 's'}`)
+                        : chalk_1.default.green('NO DRIFT DETECTED');
+            }
+            output += `${categoryPrefix} ${categoryIcon} ${chalk_1.default.bold(categoryName)}\n`;
+            const stackPrefix = isLastCategory ? TREE_SYMBOLS.EMPTY : TREE_SYMBOLS.VERTICAL;
+            output += `${stackPrefix}└── Status: ${statusText}\n`;
+        });
+        return output;
+    }
+    groupPhase3ResourcesByCategory() {
+        const categories = new Map();
+        if (!this.phase3Results || this.phase3Results.skipped)
+            return categories;
+        const allResources = [
+            ...(this.phase3Results.resourcesToBeCreated || []),
+            ...(this.phase3Results.resourcesToBeUpdated || []),
+            ...(this.phase3Results.resourcesToBeDeleted || []),
+        ];
+        allResources.forEach((resource) => {
+            const categoryName = this.determineCategory(resource.category || resource.service || 'Other');
+            if (!categories.has(categoryName)) {
+                categories.set(categoryName, []);
+            }
+            categories.get(categoryName).push(resource);
+        });
+        return categories;
+    }
+    getAllCategoriesForPhase3(driftedCategories) {
+        const allCategories = new Map();
+        allCategories.set('Core Infrastructure', driftedCategories.get('Core Infrastructure') || []);
+        this.nestedStacks.forEach((stack) => {
+            const categoryName = this.determineCategory(stack.category || stack.logicalId);
+            if (!allCategories.has(categoryName)) {
+                allCategories.set(categoryName, driftedCategories.get(categoryName) || []);
+            }
+        });
+        driftedCategories.forEach((resources, categoryName) => {
+            if (!allCategories.has(categoryName)) {
+                allCategories.set(categoryName, resources);
+            }
+        });
+        return allCategories;
+    }
+    getTotalDriftCount() {
+        let total = this.summary.totalDrifted;
+        if (this.phase3Results && !this.phase3Results.skipped && this.phase3Results.totalDrifted) {
+            total += this.phase3Results.totalDrifted;
+        }
+        return total;
+    }
+}
+exports.DriftFormatter = DriftFormatter;
+//# sourceMappingURL=drift-formatter.js.map