pcu 0.2.6

package/dist/cli/formatters/OutputFormatter.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Output Formatter
+ *
+ * Provides formatted output for CLI commands in various formats.
+ * Supports table, JSON, YAML, and minimal output formats.
+ */
+import { ImpactAnalysis, OutdatedReport, UpdateResult } from '../../application/services/CatalogUpdateService.js';
+import { WorkspaceStats, WorkspaceValidationReport } from '../../application/services/WorkspaceService.js';
+export type OutputFormat = 'table' | 'json' | 'yaml' | 'minimal';
+export declare class OutputFormatter {
+    private readonly format;
+    private readonly useColor;
+    constructor(format?: OutputFormat, useColor?: boolean);
+    /**
+     * Format outdated dependencies report
+     */
+    formatOutdatedReport(report: OutdatedReport): string;
+    /**
+     * Format update result
+     */
+    formatUpdateResult(result: UpdateResult): string;
+    /**
+     * Format impact analysis
+     */
+    formatImpactAnalysis(analysis: ImpactAnalysis): string;
+    /**
+     * Format workspace validation report
+     */
+    formatValidationReport(report: WorkspaceValidationReport): string;
+    /**
+     * Format workspace statistics
+     */
+    formatWorkspaceStats(stats: WorkspaceStats): string;
+    /**
+     * Format simple message with optional styling
+     */
+    formatMessage(message: string, type?: 'success' | 'error' | 'warning' | 'info'): string;
+    /**
+     * Format outdated dependencies as table
+     */
+    private formatOutdatedTable;
+    /**
+     * Format outdated dependencies minimally (npm-check-updates style)
+     */
+    private formatOutdatedMinimal;
+    /**
+     * Format update result as table
+     */
+    private formatUpdateTable;
+    /**
+     * Format update result minimally (npm-check-updates style)
+     */
+    private formatUpdateMinimal;
+    /**
+     * Format impact analysis as table
+     */
+    private formatImpactTable;
+    /**
+     * Format impact analysis minimally
+     */
+    private formatImpactMinimal;
+    /**
+     * Format validation report as table
+     */
+    private formatValidationTable;
+    /**
+     * Format validation report minimally
+     */
+    private formatValidationMinimal;
+    /**
+     * Format workspace statistics as table
+     */
+    private formatStatsTable;
+    /**
+     * Format workspace statistics minimally
+     */
+    private formatStatsMinimal;
+    /**
+     * Apply color if color is enabled
+     */
+    private colorize;
+    /**
+     * Colorize table headers
+     */
+    private colorizeHeaders;
+    /**
+     * Get color for update type
+     */
+    private getUpdateTypeColor;
+    /**
+     * Get color for risk level
+     */
+    private getRiskColor;
+    /**
+     * Colorize version differences between current and latest
+     */
+    private colorizeVersionDiff;
+}
+//# sourceMappingURL=OutputFormatter.d.ts.map

package/dist/cli/formatters/OutputFormatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OutputFormatter.d.ts","sourceRoot":"","sources":["../../../src/cli/formatters/OutputFormatter.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EACL,cAAc,EACd,cAAc,EACd,YAAY,EACb,MAAM,oDAAoD,CAAC;AAC5D,OAAO,EACL,cAAc,EACd,yBAAyB,EAC1B,MAAM,gDAAgD,CAAC;AAMxD,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;AAMjE,qBAAa,eAAe;IAExB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,QAAQ;gBADR,MAAM,GAAE,YAAsB,EAC9B,QAAQ,GAAE,OAAc;IAG3C;;OAEG;IACH,oBAAoB,CAAC,MAAM,EAAE,cAAc,GAAG,MAAM;IAcpD;;OAEG;IACH,kBAAkB,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM;IAchD;;OAEG;IACH,oBAAoB,CAAC,QAAQ,EAAE,cAAc,GAAG,MAAM;IActD;;OAEG;IACH,sBAAsB,CAAC,MAAM,EAAE,yBAAyB,GAAG,MAAM;IAcjE;;OAEG;IACH,oBAAoB,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM;IAcnD;;OAEG;IACH,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,GAAE,SAAS,GAAG,OAAO,GAAG,SAAS,GAAG,MAAe,GAAG,MAAM;IAkB/F;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAsD3B;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAwD7B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAsEzB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IA+C3B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IA4EzB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAQ3B;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAgD7B;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAQ/B;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAgCxB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAQ1B;;OAEG;IACH,OAAO,CAAC,QAAQ;IAIhB;;OAEG;IACH,OAAO,CAAC,eAAe;IAIvB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAa1B;;OAEG;IACH,OAAO,CAAC,YAAY;IAapB;;OAEG;IACH,OAAO,CAAC,mBAAmB;CA6E5B"}

package/dist/cli/formatters/OutputFormatter.js

@@ -0,0 +1,551 @@
+/**
+ * Output Formatter
+ *
+ * Provides formatted output for CLI commands in various formats.
+ * Supports table, JSON, YAML, and minimal output formats.
+ */
+import Table from 'cli-table3';
+import YAML from 'yaml';
+import chalk from 'chalk';
+// Build ANSI escape regex without literal control characters
+const ANSI_ESCAPE = String.fromCharCode(27);
+const ansiRegex = new RegExp(`${ANSI_ESCAPE}\\[[0-9;]*m`, 'g');
+export class OutputFormatter {
+    format;
+    useColor;
+    constructor(format = 'table', useColor = true) {
+        this.format = format;
+        this.useColor = useColor;
+    }
+    /**
+     * Format outdated dependencies report
+     */
+    formatOutdatedReport(report) {
+        switch (this.format) {
+            case 'json':
+                return JSON.stringify(report, null, 2);
+            case 'yaml':
+                return YAML.stringify(report);
+            case 'minimal':
+                return this.formatOutdatedMinimal(report);
+            case 'table':
+            default:
+                return this.formatOutdatedTable(report);
+        }
+    }
+    /**
+     * Format update result
+     */
+    formatUpdateResult(result) {
+        switch (this.format) {
+            case 'json':
+                return JSON.stringify(result, null, 2);
+            case 'yaml':
+                return YAML.stringify(result);
+            case 'minimal':
+                return this.formatUpdateMinimal(result);
+            case 'table':
+            default:
+                return this.formatUpdateTable(result);
+        }
+    }
+    /**
+     * Format impact analysis
+     */
+    formatImpactAnalysis(analysis) {
+        switch (this.format) {
+            case 'json':
+                return JSON.stringify(analysis, null, 2);
+            case 'yaml':
+                return YAML.stringify(analysis);
+            case 'minimal':
+                return this.formatImpactMinimal(analysis);
+            case 'table':
+            default:
+                return this.formatImpactTable(analysis);
+        }
+    }
+    /**
+     * Format workspace validation report
+     */
+    formatValidationReport(report) {
+        switch (this.format) {
+            case 'json':
+                return JSON.stringify(report, null, 2);
+            case 'yaml':
+                return YAML.stringify(report);
+            case 'minimal':
+                return this.formatValidationMinimal(report);
+            case 'table':
+            default:
+                return this.formatValidationTable(report);
+        }
+    }
+    /**
+     * Format workspace statistics
+     */
+    formatWorkspaceStats(stats) {
+        switch (this.format) {
+            case 'json':
+                return JSON.stringify(stats, null, 2);
+            case 'yaml':
+                return YAML.stringify(stats);
+            case 'minimal':
+                return this.formatStatsMinimal(stats);
+            case 'table':
+            default:
+                return this.formatStatsTable(stats);
+        }
+    }
+    /**
+     * Format simple message with optional styling
+     */
+    formatMessage(message, type = 'info') {
+        if (!this.useColor) {
+            return message;
+        }
+        switch (type) {
+            case 'success':
+                return chalk.green(message);
+            case 'error':
+                return chalk.red(message);
+            case 'warning':
+                return chalk.yellow(message);
+            case 'info':
+            default:
+                return chalk.blue(message);
+        }
+    }
+    /**
+     * Format outdated dependencies as table
+     */
+    formatOutdatedTable(report) {
+        const lines = [];
+        // Header
+        lines.push(this.colorize(chalk.bold, `\n📦 Workspace: ${report.workspace.name}`));
+        lines.push(this.colorize(chalk.gray, `Path: ${report.workspace.path}`));
+        if (!report.hasUpdates) {
+            lines.push(this.colorize(chalk.green, '\n✅ All catalog dependencies are up to date!'));
+            return lines.join('\n');
+        }
+        lines.push(this.colorize(chalk.yellow, `\n🔄 Found ${report.totalOutdated} outdated dependencies\n`));
+        for (const catalogInfo of report.catalogs) {
+            if (catalogInfo.outdatedCount === 0)
+                continue;
+            lines.push(this.colorize(chalk.bold, `📋 Catalog: ${catalogInfo.catalogName}`));
+            const table = new Table({
+                head: this.colorizeHeaders(['Package', 'Current', 'Latest', 'Type', 'Packages']),
+                style: { head: [], border: [] },
+                colWidths: [25, 15, 15, 8, 20],
+            });
+            for (const dep of catalogInfo.outdatedDependencies) {
+                const typeColor = this.getUpdateTypeColor(dep.updateType);
+                const securityIcon = dep.isSecurityUpdate ? '🔒 ' : '';
+                // Colorize version differences
+                const { currentColored, latestColored } = this.colorizeVersionDiff(dep.currentVersion, dep.latestVersion, dep.updateType);
+                table.push([
+                    `${securityIcon}${dep.packageName}`,
+                    currentColored,
+                    latestColored,
+                    this.colorize(typeColor, dep.updateType),
+                    `${dep.affectedPackages.length} package(s)`,
+                ]);
+            }
+            lines.push(table.toString());
+            lines.push('');
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Format outdated dependencies minimally (npm-check-updates style)
+     */
+    formatOutdatedMinimal(report) {
+        if (!report.hasUpdates) {
+            return 'All dependencies up to date';
+        }
+        // Collect all dependencies first to calculate max package name width
+        const allDeps = [];
+        for (const catalogInfo of report.catalogs) {
+            for (const dep of catalogInfo.outdatedDependencies) {
+                const securityIcon = dep.isSecurityUpdate ? '🔒 ' : '';
+                const { currentColored, latestColored } = this.colorizeVersionDiff(dep.currentVersion, dep.latestVersion, dep.updateType);
+                allDeps.push({
+                    securityIcon,
+                    packageName: dep.packageName,
+                    currentColored,
+                    latestColored,
+                });
+            }
+        }
+        // Calculate max widths for alignment
+        const maxNameWidth = Math.max(...allDeps.map((dep) => (dep.securityIcon + dep.packageName).length));
+        // Calculate max version widths (need to strip color codes for accurate width calculation)
+        const stripAnsi = (str) => str.replace(ansiRegex, '');
+        const maxCurrentWidth = Math.max(...allDeps.map((dep) => stripAnsi(dep.currentColored).length));
+        // Format lines with proper alignment
+        const lines = [];
+        for (const dep of allDeps) {
+            const nameWithIcon = dep.securityIcon + dep.packageName;
+            const paddedName = nameWithIcon.padEnd(maxNameWidth);
+            // For current version alignment, we need to pad the visible text, not the colored version
+            const currentVisible = stripAnsi(dep.currentColored);
+            const currentPadding = maxCurrentWidth - currentVisible.length;
+            const paddedCurrent = dep.currentColored + ' '.repeat(currentPadding);
+            lines.push(`${paddedName}  ${paddedCurrent} → ${dep.latestColored}`);
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Format update result as table
+     */
+    formatUpdateTable(result) {
+        const lines = [];
+        // Header
+        lines.push(this.colorize(chalk.bold, `\n📦 Workspace: ${result.workspace.name}`));
+        if (result.success) {
+            lines.push(this.colorize(chalk.green, '✅ Update completed successfully!'));
+        }
+        else {
+            lines.push(this.colorize(chalk.red, '❌ Update completed with errors'));
+        }
+        lines.push('');
+        // Updated dependencies
+        if (result.updatedDependencies.length > 0) {
+            lines.push(this.colorize(chalk.green, `🎉 Updated ${result.totalUpdated} dependencies:`));
+            const table = new Table({
+                head: this.colorizeHeaders(['Catalog', 'Package', 'From', 'To', 'Type']),
+                style: { head: [], border: [] },
+                colWidths: [15, 25, 15, 15, 8],
+            });
+            for (const dep of result.updatedDependencies) {
+                const typeColor = this.getUpdateTypeColor(dep.updateType);
+                // Colorize version differences
+                const { currentColored, latestColored } = this.colorizeVersionDiff(dep.fromVersion, dep.toVersion, dep.updateType);
+                table.push([
+                    dep.catalogName,
+                    dep.packageName,
+                    currentColored,
+                    latestColored,
+                    this.colorize(typeColor, dep.updateType),
+                ]);
+            }
+            lines.push(table.toString());
+            lines.push('');
+        }
+        // Skipped dependencies
+        if (result.skippedDependencies.length > 0) {
+            lines.push(this.colorize(chalk.yellow, `⚠️  Skipped ${result.totalSkipped} dependencies:`));
+            for (const dep of result.skippedDependencies) {
+                lines.push(`  ${dep.catalogName}:${dep.packageName} - ${dep.reason}`);
+            }
+            lines.push('');
+        }
+        // Errors
+        if (result.errors.length > 0) {
+            lines.push(this.colorize(chalk.red, `❌ ${result.totalErrors} errors occurred:`));
+            for (const error of result.errors) {
+                const prefix = error.fatal ? '💥' : '⚠️ ';
+                lines.push(`  ${prefix} ${error.catalogName}:${error.packageName} - ${error.error}`);
+            }
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Format update result minimally (npm-check-updates style)
+     */
+    formatUpdateMinimal(result) {
+        const lines = [];
+        if (result.success) {
+            lines.push(`Updated ${result.totalUpdated} dependencies`);
+        }
+        else {
+            lines.push(`Update failed with ${result.totalErrors} errors`);
+        }
+        if (result.updatedDependencies.length > 0) {
+            // Collect version info for alignment calculation
+            const depsWithVersions = result.updatedDependencies.map((dep) => {
+                const { currentColored, latestColored } = this.colorizeVersionDiff(dep.fromVersion, dep.toVersion, dep.updateType);
+                return {
+                    packageName: dep.packageName,
+                    currentColored,
+                    latestColored,
+                };
+            });
+            // Calculate max widths for alignment
+            const maxNameWidth = Math.max(...depsWithVersions.map((dep) => dep.packageName.length));
+            const stripAnsi = (str) => str.replace(ansiRegex, '');
+            const maxCurrentWidth = Math.max(...depsWithVersions.map((dep) => stripAnsi(dep.currentColored).length));
+            for (const dep of depsWithVersions) {
+                const paddedName = dep.packageName.padEnd(maxNameWidth);
+                // Pad current version for alignment
+                const currentVisible = stripAnsi(dep.currentColored);
+                const currentPadding = maxCurrentWidth - currentVisible.length;
+                const paddedCurrent = dep.currentColored + ' '.repeat(currentPadding);
+                lines.push(`${paddedName}  ${paddedCurrent} → ${dep.latestColored}`);
+            }
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Format impact analysis as table
+     */
+    formatImpactTable(analysis) {
+        const lines = [];
+        // Header
+        lines.push(this.colorize(chalk.bold, `\n🔍 Impact Analysis: ${analysis.packageName}`));
+        lines.push(this.colorize(chalk.gray, `Catalog: ${analysis.catalogName}`));
+        lines.push(this.colorize(chalk.gray, `Update: ${analysis.currentVersion} → ${analysis.proposedVersion}`));
+        lines.push(this.colorize(chalk.gray, `Type: ${analysis.updateType}`));
+        // Risk level
+        const riskColor = this.getRiskColor(analysis.riskLevel);
+        lines.push(this.colorize(riskColor, `Risk Level: ${analysis.riskLevel.toUpperCase()}`));
+        lines.push('');
+        // Affected packages
+        if (analysis.affectedPackages.length > 0) {
+            lines.push(this.colorize(chalk.bold, '📦 Affected Packages:'));
+            const table = new Table({
+                head: this.colorizeHeaders(['Package', 'Path', 'Dependency Type', 'Risk']),
+                style: { head: [], border: [] },
+                colWidths: [20, 30, 15, 10],
+            });
+            for (const pkg of analysis.affectedPackages) {
+                const riskColor = this.getRiskColor(pkg.compatibilityRisk);
+                table.push([
+                    pkg.packageName,
+                    pkg.packagePath,
+                    pkg.dependencyType,
+                    this.colorize(riskColor, pkg.compatibilityRisk),
+                ]);
+            }
+            lines.push(table.toString());
+            lines.push('');
+        }
+        // Security impact
+        if (analysis.securityImpact.hasVulnerabilities) {
+            lines.push(this.colorize(chalk.bold, '🔒 Security Impact:'));
+            if (analysis.securityImpact.fixedVulnerabilities > 0) {
+                lines.push(this.colorize(chalk.green, `  ✅ Fixes ${analysis.securityImpact.fixedVulnerabilities} vulnerabilities`));
+            }
+            if (analysis.securityImpact.newVulnerabilities > 0) {
+                lines.push(this.colorize(chalk.red, `  ⚠️  Introduces ${analysis.securityImpact.newVulnerabilities} vulnerabilities`));
+            }
+            lines.push('');
+        }
+        // Recommendations
+        if (analysis.recommendations.length > 0) {
+            lines.push(this.colorize(chalk.bold, '💡 Recommendations:'));
+            for (const rec of analysis.recommendations) {
+                lines.push(`  ${rec}`);
+            }
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Format impact analysis minimally
+     */
+    formatImpactMinimal(analysis) {
+        return [
+            `${analysis.packageName}: ${analysis.currentVersion} → ${analysis.proposedVersion}`,
+            `Risk: ${analysis.riskLevel}`,
+            `Affected: ${analysis.affectedPackages.length} packages`,
+        ].join('\n');
+    }
+    /**
+     * Format validation report as table
+     */
+    formatValidationTable(report) {
+        const lines = [];
+        // Header
+        const statusIcon = report.isValid ? '✅' : '❌';
+        const statusColor = report.isValid ? chalk.green : chalk.red;
+        lines.push(this.colorize(chalk.bold, `\n${statusIcon} Workspace Validation`));
+        lines.push(this.colorize(statusColor, `Status: ${report.isValid ? 'VALID' : 'INVALID'}`));
+        lines.push('');
+        // Workspace info
+        lines.push(this.colorize(chalk.bold, '📦 Workspace Information:'));
+        lines.push(`  Path: ${report.workspace.path}`);
+        lines.push(`  Name: ${report.workspace.name}`);
+        lines.push(`  Packages: ${report.workspace.packageCount}`);
+        lines.push(`  Catalogs: ${report.workspace.catalogCount}`);
+        lines.push('');
+        // Errors
+        if (report.errors.length > 0) {
+            lines.push(this.colorize(chalk.red, '❌ Errors:'));
+            for (const error of report.errors) {
+                lines.push(`  • ${error}`);
+            }
+            lines.push('');
+        }
+        // Warnings
+        if (report.warnings.length > 0) {
+            lines.push(this.colorize(chalk.yellow, '⚠️  Warnings:'));
+            for (const warning of report.warnings) {
+                lines.push(`  • ${warning}`);
+            }
+            lines.push('');
+        }
+        // Recommendations
+        if (report.recommendations.length > 0) {
+            lines.push(this.colorize(chalk.blue, '💡 Recommendations:'));
+            for (const rec of report.recommendations) {
+                lines.push(`  • ${rec}`);
+            }
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Format validation report minimally
+     */
+    formatValidationMinimal(report) {
+        const status = report.isValid ? 'VALID' : 'INVALID';
+        const errors = report.errors.length;
+        const warnings = report.warnings.length;
+        return `${status} (${errors} errors, ${warnings} warnings)`;
+    }
+    /**
+     * Format workspace statistics as table
+     */
+    formatStatsTable(stats) {
+        const lines = [];
+        lines.push(this.colorize(chalk.bold, `\n📊 Workspace Statistics`));
+        lines.push(this.colorize(chalk.gray, `Workspace: ${stats.workspace.name}`));
+        lines.push('');
+        const table = new Table({
+            head: this.colorizeHeaders(['Metric', 'Count']),
+            style: { head: [], border: [] },
+            colWidths: [30, 10],
+        });
+        table.push(['Total Packages', stats.packages.total.toString()]);
+        table.push(['Packages with Catalog Refs', stats.packages.withCatalogReferences.toString()]);
+        table.push(['Total Catalogs', stats.catalogs.total.toString()]);
+        table.push(['Catalog Entries', stats.catalogs.totalEntries.toString()]);
+        table.push(['Total Dependencies', stats.dependencies.total.toString()]);
+        table.push(['Catalog References', stats.dependencies.catalogReferences.toString()]);
+        table.push(['Dependencies', stats.dependencies.byType.dependencies.toString()]);
+        table.push(['Dev Dependencies', stats.dependencies.byType.devDependencies.toString()]);
+        table.push(['Peer Dependencies', stats.dependencies.byType.peerDependencies.toString()]);
+        table.push([
+            'Optional Dependencies',
+            stats.dependencies.byType.optionalDependencies.toString(),
+        ]);
+        lines.push(table.toString());
+        return lines.join('\n');
+    }
+    /**
+     * Format workspace statistics minimally
+     */
+    formatStatsMinimal(stats) {
+        return [
+            `Packages: ${stats.packages.total}`,
+            `Catalogs: ${stats.catalogs.total}`,
+            `Dependencies: ${stats.dependencies.total}`,
+        ].join(', ');
+    }
+    /**
+     * Apply color if color is enabled
+     */
+    colorize(colorFn, text) {
+        return this.useColor ? colorFn(text) : text;
+    }
+    /**
+     * Colorize table headers
+     */
+    colorizeHeaders(headers) {
+        return this.useColor ? headers.map((h) => chalk.bold.cyan(h)) : headers;
+    }
+    /**
+     * Get color for update type
+     */
+    getUpdateTypeColor(updateType) {
+        switch (updateType) {
+            case 'major':
+                return chalk.cyan;
+            case 'minor':
+                return chalk.green;
+            case 'patch':
+                return chalk.cyan;
+            default:
+                return chalk.gray;
+        }
+    }
+    /**
+     * Get color for risk level
+     */
+    getRiskColor(riskLevel) {
+        switch (riskLevel) {
+            case 'high':
+                return chalk.red;
+            case 'medium':
+                return chalk.yellow;
+            case 'low':
+                return chalk.green;
+            default:
+                return chalk.gray;
+        }
+    }
+    /**
+     * Colorize version differences between current and latest
+     */
+    colorizeVersionDiff(current, latest, updateType) {
+        if (!this.useColor) {
+            return { currentColored: current, latestColored: latest };
+        }
+        // Parse version numbers to identify different parts
+        const parseVersion = (version) => {
+            // Remove leading ^ or ~ or other prefix characters
+            const cleanVersion = version.replace(/^[\^~>=<]+/, '');
+            const parts = cleanVersion.split('.');
+            return {
+                major: parts[0] || '0',
+                minor: parts[1] || '0',
+                patch: parts[2] || '0',
+                extra: parts.slice(3).join('.'),
+                prefix: version.substring(0, version.length - cleanVersion.length),
+            };
+        };
+        const currentParts = parseVersion(current);
+        const latestParts = parseVersion(latest);
+        // Determine color based on update type for highlighting differences
+        const diffColor = this.getUpdateTypeColor(updateType);
+        // Build colored version strings by comparing each part
+        const colorCurrentPart = (part, latestPart, isChanged) => {
+            if (isChanged && part !== latestPart) {
+                return chalk.dim.white(part); // Dim white for old version part
+            }
+            return chalk.white(part); // Unchanged parts in white
+        };
+        const colorLatestPart = (part, currentPart, isChanged) => {
+            if (isChanged && part !== currentPart) {
+                return diffColor(part); // Highlight the new version part with update type color
+            }
+            return chalk.white(part); // Unchanged parts in white
+        };
+        // Check which parts are different
+        const majorChanged = currentParts.major !== latestParts.major;
+        const minorChanged = currentParts.minor !== latestParts.minor;
+        const patchChanged = currentParts.patch !== latestParts.patch;
+        const extraChanged = currentParts.extra !== latestParts.extra;
+        // Build colored current version
+        let currentColored = currentParts.prefix;
+        currentColored += colorCurrentPart(currentParts.major, latestParts.major, majorChanged);
+        currentColored += '.';
+        currentColored += colorCurrentPart(currentParts.minor, latestParts.minor, minorChanged);
+        currentColored += '.';
+        currentColored += colorCurrentPart(currentParts.patch, latestParts.patch, patchChanged);
+        if (currentParts.extra) {
+            currentColored += '.' + colorCurrentPart(currentParts.extra, latestParts.extra, extraChanged);
+        }
+        // Build colored latest version
+        let latestColored = latestParts.prefix;
+        latestColored += colorLatestPart(latestParts.major, currentParts.major, majorChanged);
+        latestColored += '.';
+        latestColored += colorLatestPart(latestParts.minor, currentParts.minor, minorChanged);
+        latestColored += '.';
+        latestColored += colorLatestPart(latestParts.patch, currentParts.patch, patchChanged);
+        if (latestParts.extra) {
+            latestColored += '.' + colorLatestPart(latestParts.extra, currentParts.extra, extraChanged);
+        }
+        return { currentColored, latestColored };
+    }
+}
+//# sourceMappingURL=OutputFormatter.js.map