pnpm-catalog-updates 1.0.3 → 1.1.2

package/src/cli/formatters/outputFormatter.ts

@@ -2,38 +2,78 @@
  * Output Formatter
  *
  * Provides formatted output for CLI commands in various formats.
- * Supports table, JSON, YAML, and minimal output formats.
+ * Supports table, JSON, YAML, minimal, and CI/CD output formats.
+ * CI formats include GitHub Actions, GitLab CI, JUnit XML, and SARIF.
  */
 
 import type {
   AnalysisResult,
   ImpactAnalysis,
   OutdatedReport,
+  UpdatePlan,
   UpdateResult,
+  WorkspaceInfo,
   WorkspaceStats,
   WorkspaceValidationReport,
 } from '@pcu/core'
+import { countUpdateTypes } from '@pcu/core'
+import { t } from '@pcu/utils'
 import chalk from 'chalk'
 import Table from 'cli-table3'
 import YAML from 'yaml'
 import type { SecurityReport } from '../commands/securityCommand.js'
-
-export type OutputFormat = 'table' | 'json' | 'yaml' | 'minimal'
-
-// Build ANSI escape regex without literal control characters
-const ANSI_ESCAPE = String.fromCharCode(27)
-const ansiRegex: RegExp = new RegExp(`${ANSI_ESCAPE}\\[[0-9;]*m`, 'g')
+import { CIFormatter, type CIOutputFormat } from './ciFormatter.js'
+import { ColorUtils } from './colorUtils.js'
+import { VersionFormatter } from './versionFormatter.js'
+
+export type OutputFormat =
+  | 'table'
+  | 'json'
+  | 'yaml'
+  | 'minimal'
+  | 'github'
+  | 'gitlab'
+  | 'junit'
+  | 'sarif'
+
+export type CIFormat = 'github' | 'gitlab' | 'junit' | 'sarif'
+
+export function isCIFormat(format: OutputFormat): format is CIFormat {
+  return ['github', 'gitlab', 'junit', 'sarif'].includes(format)
+}
 
 export class OutputFormatter {
+  private ciFormatter: CIFormatter | null = null
+  private readonly colorUtils: ColorUtils
+  private readonly versionFormatter: VersionFormatter
+
   constructor(
     private readonly format: OutputFormat = 'table',
     private readonly useColor: boolean = true
-  ) {}
+  ) {
+    this.colorUtils = new ColorUtils(useColor)
+    this.versionFormatter = new VersionFormatter(this.colorUtils, useColor)
+  }
+
+  /**
+   * Get or create CIFormatter instance for CI output formats
+   */
+  private getCIFormatter(): CIFormatter {
+    if (!this.ciFormatter) {
+      this.ciFormatter = new CIFormatter(this.format as CIOutputFormat)
+    }
+    return this.ciFormatter
+  }
 
   /**
    * Format outdated dependencies report
    */
   formatOutdatedReport(report: OutdatedReport): string {
+    // Delegate to CIFormatter for CI output formats
+    if (isCIFormat(this.format)) {
+      return this.getCIFormatter().formatOutdatedReport(report)
+    }
+
     switch (this.format) {
       case 'json':
         return JSON.stringify(report, null, 2)
@@ -50,6 +90,11 @@ export class OutputFormatter {
    * Format update result
    */
   formatUpdateResult(result: UpdateResult): string {
+    // Delegate to CIFormatter for CI output formats
+    if (isCIFormat(this.format)) {
+      return this.getCIFormatter().formatUpdateResult(result)
+    }
+
     switch (this.format) {
       case 'json':
         return JSON.stringify(result, null, 2)
@@ -62,6 +107,27 @@ export class OutputFormatter {
     }
   }
 
+  /**
+   * Format update plan (for dry-run mode)
+   */
+  formatUpdatePlan(plan: UpdatePlan): string {
+    // Delegate to CIFormatter for CI output formats
+    if (isCIFormat(this.format)) {
+      return this.getCIFormatter().formatUpdatePlan(plan)
+    }
+
+    switch (this.format) {
+      case 'json':
+        return JSON.stringify(plan, null, 2)
+      case 'yaml':
+        return YAML.stringify(plan)
+      case 'minimal':
+        return this.formatUpdatePlanMinimal(plan)
+      default:
+        return this.formatUpdatePlanTable(plan)
+    }
+  }
+
   /**
    * Format impact analysis
    */
@@ -82,6 +148,11 @@ export class OutputFormatter {
    * Format workspace validation report
    */
   formatValidationReport(report: WorkspaceValidationReport): string {
+    // Delegate to CIFormatter for CI output formats
+    if (isCIFormat(this.format)) {
+      return this.getCIFormatter().formatValidationReport(report)
+    }
+
     switch (this.format) {
       case 'json':
         return JSON.stringify(report, null, 2)
@@ -94,6 +165,22 @@ export class OutputFormatter {
     }
   }
 
+  /**
+   * Format workspace information
+   */
+  formatWorkspaceInfo(info: WorkspaceInfo): string {
+    switch (this.format) {
+      case 'json':
+        return JSON.stringify(info, null, 2)
+      case 'yaml':
+        return YAML.stringify(info)
+      case 'minimal':
+        return this.formatWorkspaceInfoMinimal(info)
+      default:
+        return this.formatWorkspaceInfoTable(info)
+    }
+  }
+
   /**
    * Format workspace statistics
    */
@@ -114,6 +201,11 @@ export class OutputFormatter {
    * Format security report
    */
   formatSecurityReport(report: SecurityReport): string {
+    // Delegate to CIFormatter for CI output formats
+    if (isCIFormat(this.format)) {
+      return this.getCIFormatter().formatSecurityReport(report)
+    }
+
     switch (this.format) {
       case 'json':
         return JSON.stringify(report, null, 2)
@@ -153,35 +245,50 @@ export class OutputFormatter {
     const lines: string[] = []
 
     // Header
-    lines.push(this.colorize(chalk.bold, `\n📦 Workspace: ${report.workspace.name}`))
-    lines.push(this.colorize(chalk.gray, `Path: ${report.workspace.path}`))
+    lines.push(
+      this.colorUtils.colorize(chalk.bold, `\n${t('format.workspace')}: ${report.workspace.name}`)
+    )
+    lines.push(
+      this.colorUtils.colorize(chalk.gray, `${t('format.path')}: ${report.workspace.path}`)
+    )
 
     if (!report.hasUpdates) {
-      lines.push(this.colorize(chalk.green, '\n✅ All catalog dependencies are up to date!'))
+      lines.push(this.colorUtils.colorize(chalk.green, `\n✅ ${t('format.allUpToDate')}`))
       return lines.join('\n')
     }
 
     lines.push(
-      this.colorize(chalk.yellow, `\n🔄 Found ${report.totalOutdated} outdated dependencies\n`)
+      this.colorUtils.colorize(
+        chalk.yellow,
+        `\n${t('format.foundOutdated', { count: String(report.totalOutdated) })}\n`
+      )
     )
 
     for (const catalogInfo of report.catalogs) {
       if (catalogInfo.outdatedCount === 0) continue
 
-      lines.push(this.colorize(chalk.bold, `📋 Catalog: ${catalogInfo.catalogName}`))
+      lines.push(
+        this.colorUtils.colorize(chalk.bold, `${t('format.catalog')}: ${catalogInfo.catalogName}`)
+      )
 
       const table = new Table({
-        head: this.colorizeHeaders(['Package', 'Current', 'Latest', 'Type', 'Packages']),
+        head: this.colorUtils.colorizeHeaders([
+          t('table.header.package'),
+          t('table.header.current'),
+          t('table.header.latest'),
+          t('table.header.type'),
+          t('table.header.packagesCount'),
+        ]),
         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 ? '🔒 ' : ''
+        const typeColor = this.colorUtils.getUpdateTypeColor(dep.updateType)
+        const securityIcon = dep.isSecurityUpdate ? '[SEC] ' : ''
 
         // Colorize version differences
-        const { currentColored, latestColored } = this.colorizeVersionDiff(
+        const { currentColored, latestColored } = this.versionFormatter.colorizeVersionDiff(
           dep.currentVersion,
           dep.latestVersion,
           dep.updateType
@@ -191,8 +298,8 @@ export class OutputFormatter {
           `${securityIcon}${dep.packageName}`,
           currentColored,
           latestColored,
-          this.colorize(typeColor, dep.updateType),
-          `${dep.affectedPackages.length} package(s)`,
+          this.colorUtils.colorize(typeColor, dep.updateType),
+          t('common.packagesCount', { count: String(dep.affectedPackages.length) }),
         ])
       }
 
@@ -208,7 +315,7 @@ export class OutputFormatter {
    */
   private formatOutdatedMinimal(report: OutdatedReport): string {
     if (!report.hasUpdates) {
-      return 'All dependencies up to date'
+      return t('format.allUpToDate')
     }
 
     // Collect all dependencies first to calculate max package name width
@@ -221,8 +328,8 @@ export class OutputFormatter {
 
     for (const catalogInfo of report.catalogs) {
       for (const dep of catalogInfo.outdatedDependencies) {
-        const securityIcon = dep.isSecurityUpdate ? '🔒 ' : ''
-        const { currentColored, latestColored } = this.colorizeVersionDiff(
+        const securityIcon = dep.isSecurityUpdate ? '[SEC] ' : ''
+        const { currentColored, latestColored } = this.versionFormatter.colorizeVersionDiff(
           dep.currentVersion,
           dep.latestVersion,
           dep.updateType
@@ -242,19 +349,16 @@ export class OutputFormatter {
     )
 
     // Calculate max version widths (need to strip color codes for accurate width calculation)
-    const stripAnsi = (str: string) => str.replace(ansiRegex, '')
-    const maxCurrentWidth = Math.max(...allDeps.map((dep) => stripAnsi(dep.currentColored).length))
+    const maxCurrentWidth = Math.max(
+      ...allDeps.map((dep) => this.colorUtils.stripAnsi(dep.currentColored).length)
+    )
 
     // Format lines with proper alignment
     const lines: string[] = []
     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)
+      const paddedCurrent = this.colorUtils.padAnsi(dep.currentColored, maxCurrentWidth)
 
       lines.push(`${paddedName}  ${paddedCurrent} → ${dep.latestColored}`)
     }
@@ -269,31 +373,44 @@ export class OutputFormatter {
     const lines: string[] = []
 
     // Header
-    lines.push(this.colorize(chalk.bold, `\n📦 Workspace: ${result.workspace.name}`))
+    lines.push(
+      this.colorUtils.colorize(chalk.bold, `\n${t('format.workspace')}: ${result.workspace.name}`)
+    )
 
     if (result.success) {
-      lines.push(this.colorize(chalk.green, '✅ Update completed successfully!'))
+      lines.push(this.colorUtils.colorize(chalk.green, `✅ ${t('format.updateCompleted')}`))
     } else {
-      lines.push(this.colorize(chalk.red, '❌ Update completed with errors'))
+      lines.push(this.colorUtils.colorize(chalk.red, `❌ ${t('format.updateFailed')}`))
     }
 
     lines.push('')
 
     // Updated dependencies
     if (result.updatedDependencies.length > 0) {
-      lines.push(this.colorize(chalk.green, `🎉 Updated ${result.totalUpdated} dependencies:`))
+      lines.push(
+        this.colorUtils.colorize(
+          chalk.green,
+          `${t('format.updatedCount', { count: String(result.totalUpdated) })}:`
+        )
+      )
 
       const table = new Table({
-        head: this.colorizeHeaders(['Catalog', 'Package', 'From', 'To', 'Type']),
+        head: this.colorUtils.colorizeHeaders([
+          t('table.header.catalog'),
+          t('table.header.package'),
+          t('table.header.from'),
+          t('table.header.to'),
+          t('table.header.type'),
+        ]),
         style: { head: [], border: [] },
         colWidths: [15, 25, 15, 15, 8],
       })
 
       for (const dep of result.updatedDependencies) {
-        const typeColor = this.getUpdateTypeColor(dep.updateType)
+        const typeColor = this.colorUtils.getUpdateTypeColor(dep.updateType)
 
         // Colorize version differences
-        const { currentColored, latestColored } = this.colorizeVersionDiff(
+        const { currentColored, latestColored } = this.versionFormatter.colorizeVersionDiff(
           dep.fromVersion,
           dep.toVersion,
           dep.updateType
@@ -304,7 +421,7 @@ export class OutputFormatter {
           dep.packageName,
           currentColored,
           latestColored,
-          this.colorize(typeColor, dep.updateType),
+          this.colorUtils.colorize(typeColor, dep.updateType),
         ])
       }
 
@@ -314,7 +431,12 @@ export class OutputFormatter {
 
     // Skipped dependencies
     if (result.skippedDependencies.length > 0) {
-      lines.push(this.colorize(chalk.yellow, `⚠️  Skipped ${result.totalSkipped} dependencies:`))
+      lines.push(
+        this.colorUtils.colorize(
+          chalk.yellow,
+          `⚠️ ${t('format.skippedDeps')} (${result.totalSkipped}):`
+        )
+      )
 
       for (const dep of result.skippedDependencies) {
         lines.push(`  ${dep.catalogName}:${dep.packageName} - ${dep.reason}`)
@@ -324,10 +446,15 @@ export class OutputFormatter {
 
     // Errors
     if (result.errors.length > 0) {
-      lines.push(this.colorize(chalk.red, `❌ ${result.totalErrors} errors occurred:`))
+      lines.push(
+        this.colorUtils.colorize(
+          chalk.red,
+          `❌ ${t('format.errorCount', { count: String(result.totalErrors) })}:`
+        )
+      )
 
       for (const error of result.errors) {
-        const prefix = error.fatal ? '💥' : '⚠️ '
+        const prefix = error.fatal ? '!!' : '⚠️'
         lines.push(`  ${prefix} ${error.catalogName}:${error.packageName} - ${error.error}`)
       }
     }
@@ -342,15 +469,15 @@ export class OutputFormatter {
     const lines: string[] = []
 
     if (result.success) {
-      lines.push(`Updated ${result.totalUpdated} dependencies`)
+      lines.push(t('format.updatedCount', { count: String(result.totalUpdated) }))
     } else {
-      lines.push(`Update failed with ${result.totalErrors} errors`)
+      lines.push(t('format.errorCount', { count: String(result.totalErrors) }))
     }
 
     if (result.updatedDependencies.length > 0) {
       // Collect version info for alignment calculation
       const depsWithVersions = result.updatedDependencies.map((dep) => {
-        const { currentColored, latestColored } = this.colorizeVersionDiff(
+        const { currentColored, latestColored } = this.versionFormatter.colorizeVersionDiff(
           dep.fromVersion,
           dep.toVersion,
           dep.updateType
@@ -364,19 +491,13 @@ export class OutputFormatter {
 
       // Calculate max widths for alignment
       const maxNameWidth = Math.max(...depsWithVersions.map((dep) => dep.packageName.length))
-
-      const stripAnsi = (str: string) => str.replace(ansiRegex, '')
       const maxCurrentWidth = Math.max(
-        ...depsWithVersions.map((dep) => stripAnsi(dep.currentColored).length)
+        ...depsWithVersions.map((dep) => this.colorUtils.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)
+        const paddedCurrent = this.colorUtils.padAnsi(dep.currentColored, maxCurrentWidth)
 
         lines.push(`${paddedName}  ${paddedCurrent} → ${dep.latestColored}`)
       }
@@ -385,6 +506,167 @@ export class OutputFormatter {
     return lines.join('\n')
   }
 
+  /**
+   * Format update plan as table (for dry-run mode)
+   */
+  private formatUpdatePlanTable(plan: UpdatePlan): string {
+    const lines: string[] = []
+
+    // Header
+    lines.push(
+      this.colorUtils.colorize(chalk.bold, `\n${t('format.workspace')}: ${plan.workspace.name}`)
+    )
+    lines.push(this.colorUtils.colorize(chalk.gray, `${t('format.path')}: ${plan.workspace.path}`))
+
+    if (plan.totalUpdates === 0) {
+      lines.push(this.colorUtils.colorize(chalk.green, `\n✅ ${t('format.noUpdatesPlanned')}`))
+      return lines.join('\n')
+    }
+
+    lines.push(
+      this.colorUtils.colorize(
+        chalk.cyan,
+        `\n${t('format.plannedUpdates', { count: String(plan.totalUpdates) })}`
+      )
+    )
+    lines.push('')
+
+    // Updates table
+    if (plan.updates.length > 0) {
+      const table = new Table({
+        head: this.colorUtils.colorizeHeaders([
+          t('table.header.catalog'),
+          t('table.header.package'),
+          t('table.header.current'),
+          t('table.header.new'),
+          t('table.header.type'),
+        ]),
+        style: { head: [], border: [] },
+        colWidths: [15, 30, 15, 15, 8],
+      })
+
+      for (const update of plan.updates) {
+        const typeColor = this.colorUtils.getUpdateTypeColor(update.updateType)
+        const { currentColored, latestColored } = this.versionFormatter.colorizeVersionDiff(
+          update.currentVersion,
+          update.newVersion,
+          update.updateType
+        )
+
+        table.push([
+          update.catalogName,
+          update.packageName,
+          currentColored,
+          latestColored,
+          this.colorUtils.colorize(typeColor, update.updateType),
+        ])
+      }
+
+      lines.push(table.toString())
+      lines.push('')
+    }
+
+    // Conflicts warning
+    if (plan.hasConflicts && plan.conflicts.length > 0) {
+      lines.push(this.colorUtils.colorize(chalk.yellow, `⚠️ ${t('format.versionConflicts')}:`))
+      lines.push('')
+
+      for (const conflict of plan.conflicts) {
+        lines.push(this.colorUtils.colorize(chalk.bold, `  ${conflict.packageName}:`))
+        for (const catalog of conflict.catalogs) {
+          lines.push(
+            `    ${catalog.catalogName}: ${catalog.currentVersion} → ${catalog.proposedVersion}`
+          )
+        }
+        if (conflict.recommendation) {
+          lines.push(
+            this.colorUtils.colorize(
+              chalk.gray,
+              `    ${t('format.recommendation')}: ${conflict.recommendation}`
+            )
+          )
+        }
+        lines.push('')
+      }
+    }
+
+    // Summary breakdown
+    const updateTypes = countUpdateTypes(plan.updates)
+
+    lines.push(this.colorUtils.colorize(chalk.bold, `${t('format.summary')}:`))
+    if (updateTypes.major > 0) {
+      lines.push(
+        this.colorUtils.colorize(
+          chalk.red,
+          `  • ${t('command.check.majorUpdates', { count: String(updateTypes.major) })}`
+        )
+      )
+    }
+    if (updateTypes.minor > 0) {
+      lines.push(
+        this.colorUtils.colorize(
+          chalk.yellow,
+          `  • ${t('command.check.minorUpdates', { count: String(updateTypes.minor) })}`
+        )
+      )
+    }
+    if (updateTypes.patch > 0) {
+      lines.push(
+        this.colorUtils.colorize(
+          chalk.green,
+          `  • ${t('command.check.patchUpdates', { count: String(updateTypes.patch) })}`
+        )
+      )
+    }
+
+    return lines.join('\n')
+  }
+
+  /**
+   * Format update plan minimally (for dry-run mode)
+   */
+  private formatUpdatePlanMinimal(plan: UpdatePlan): string {
+    if (plan.totalUpdates === 0) {
+      return t('format.noUpdatesPlanned')
+    }
+
+    // Collect update info for alignment calculation
+    const updatesWithVersions = plan.updates.map((update) => {
+      const { currentColored, latestColored } = this.versionFormatter.colorizeVersionDiff(
+        update.currentVersion,
+        update.newVersion,
+        update.updateType
+      )
+      return {
+        packageName: update.packageName,
+        currentColored,
+        latestColored,
+      }
+    })
+
+    // Calculate max widths for alignment
+    const maxNameWidth = Math.max(...updatesWithVersions.map((u) => u.packageName.length))
+    const maxCurrentWidth = Math.max(
+      ...updatesWithVersions.map((u) => this.colorUtils.stripAnsi(u.currentColored).length)
+    )
+
+    const lines: string[] = []
+    for (const update of updatesWithVersions) {
+      const paddedName = update.packageName.padEnd(maxNameWidth)
+      const paddedCurrent = this.colorUtils.padAnsi(update.currentColored, maxCurrentWidth)
+
+      lines.push(`${paddedName}  ${paddedCurrent} → ${update.latestColored}`)
+    }
+
+    // Add conflicts warning if any
+    if (plan.hasConflicts && plan.conflicts.length > 0) {
+      lines.push('')
+      lines.push(`⚠️ ${plan.conflicts.length} ${t('format.conflictsDetected')}`)
+    }
+
+    return lines.join('\n')
+  }
+
   /**
    * Format impact analysis as table
    */
@@ -392,35 +674,57 @@ export class OutputFormatter {
     const lines: string[] = []
 
     // 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}`)
+      this.colorUtils.colorize(
+        chalk.bold,
+        `\n${t('format.impactAnalysis')}: ${analysis.packageName}`
+      )
+    )
+    lines.push(
+      this.colorUtils.colorize(chalk.gray, `${t('format.catalog')}: ${analysis.catalogName}`)
+    )
+    lines.push(
+      this.colorUtils.colorize(
+        chalk.gray,
+        `${t('format.updateInfo')}: ${analysis.currentVersion} → ${analysis.proposedVersion}`
+      )
+    )
+    lines.push(
+      this.colorUtils.colorize(chalk.gray, `${t('table.header.type')}: ${analysis.updateType}`)
     )
-    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()}`))
+    const riskColor = this.colorUtils.getRiskColor(analysis.riskLevel)
+    lines.push(
+      this.colorUtils.colorize(
+        riskColor,
+        `${t('format.riskLevel')}: ${analysis.riskLevel.toUpperCase()}`
+      )
+    )
     lines.push('')
 
     // Affected packages
     if (analysis.affectedPackages.length > 0) {
-      lines.push(this.colorize(chalk.bold, '📦 Affected Packages:'))
+      lines.push(this.colorUtils.colorize(chalk.bold, `${t('format.affectedPackages')}:`))
 
       const table = new Table({
-        head: this.colorizeHeaders(['Package', 'Path', 'Dependency Type', 'Risk']),
+        head: this.colorUtils.colorizeHeaders([
+          t('table.header.package'),
+          t('table.header.path'),
+          t('table.header.dependencyType'),
+          t('table.header.risk'),
+        ]),
         style: { head: [], border: [] },
         colWidths: [20, 30, 15, 10],
       })
 
       for (const pkg of analysis.affectedPackages) {
-        const riskColor = this.getRiskColor(pkg.compatibilityRisk)
+        const riskColor = this.colorUtils.getRiskColor(pkg.compatibilityRisk)
         table.push([
           pkg.packageName,
           pkg.packagePath,
           pkg.dependencyType,
-          this.colorize(riskColor, pkg.compatibilityRisk),
+          this.colorUtils.colorize(riskColor, pkg.compatibilityRisk),
         ])
       }
 
@@ -430,22 +734,22 @@ export class OutputFormatter {
 
     // Security impact
     if (analysis.securityImpact.hasVulnerabilities) {
-      lines.push(this.colorize(chalk.bold, '🔒 Security Impact:'))
+      lines.push(this.colorUtils.colorize(chalk.bold, `${t('format.securityImpact')}:`))
 
       if (analysis.securityImpact.fixedVulnerabilities > 0) {
         lines.push(
-          this.colorize(
+          this.colorUtils.colorize(
             chalk.green,
-            `  ✅ Fixes ${analysis.securityImpact.fixedVulnerabilities} vulnerabilities`
+            `  ✅ ${t('format.fixesVulns', { count: String(analysis.securityImpact.fixedVulnerabilities) })}`
           )
         )
       }
 
       if (analysis.securityImpact.newVulnerabilities > 0) {
         lines.push(
-          this.colorize(
+          this.colorUtils.colorize(
             chalk.red,
-            `  ⚠️  Introduces ${analysis.securityImpact.newVulnerabilities} vulnerabilities`
+            `  ⚠️ ${t('format.introducesVulns', { count: String(analysis.securityImpact.newVulnerabilities) })}`
           )
         )
       }
@@ -455,7 +759,7 @@ export class OutputFormatter {
 
     // Recommendations
     if (analysis.recommendations.length > 0) {
-      lines.push(this.colorize(chalk.bold, '💡 Recommendations:'))
+      lines.push(this.colorUtils.colorize(chalk.bold, `${t('format.recommendations')}:`))
       for (const rec of analysis.recommendations) {
         lines.push(`  ${rec}`)
       }
@@ -470,8 +774,8 @@ export class OutputFormatter {
   private formatImpactMinimal(analysis: ImpactAnalysis): string {
     return [
       `${analysis.packageName}: ${analysis.currentVersion} → ${analysis.proposedVersion}`,
-      `Risk: ${analysis.riskLevel}`,
-      `Affected: ${analysis.affectedPackages.length} packages`,
+      `${t('format.riskLevel')}: ${analysis.riskLevel}`,
+      `${t('format.affectedPackages')}: ${analysis.affectedPackages.length} ${t('format.packages')}`,
     ].join('\n')
   }
 
@@ -485,21 +789,28 @@ export class OutputFormatter {
     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(
+      this.colorUtils.colorize(chalk.bold, `\n${statusIcon} ${t('format.workspaceValidation')}`)
+    )
+    lines.push(
+      this.colorUtils.colorize(
+        statusColor,
+        `${t('format.status')}: ${report.isValid ? t('format.valid') : t('format.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(this.colorUtils.colorize(chalk.bold, `${t('format.workspaceInfo')}:`))
+    lines.push(`  ${t('format.path')}: ${report.workspace.path}`)
+    lines.push(`  ${t('format.name')}: ${report.workspace.name}`)
+    lines.push(`  ${t('format.packages')}: ${report.workspace.packageCount}`)
+    lines.push(`  ${t('format.catalogs')}: ${report.workspace.catalogCount}`)
     lines.push('')
 
     // Errors
     if (report.errors.length > 0) {
-      lines.push(this.colorize(chalk.red, '❌ Errors:'))
+      lines.push(this.colorUtils.colorize(chalk.red, `❌ ${t('format.errors')}:`))
       for (const error of report.errors) {
         lines.push(`  • ${error}`)
       }
@@ -508,7 +819,7 @@ export class OutputFormatter {
 
     // Warnings
     if (report.warnings.length > 0) {
-      lines.push(this.colorize(chalk.yellow, '⚠️  Warnings:'))
+      lines.push(this.colorUtils.colorize(chalk.yellow, `⚠️ ${t('format.warnings')}:`))
       for (const warning of report.warnings) {
         lines.push(`  • ${warning}`)
       }
@@ -517,7 +828,7 @@ export class OutputFormatter {
 
     // Recommendations
     if (report.recommendations.length > 0) {
-      lines.push(this.colorize(chalk.blue, '💡 Recommendations:'))
+      lines.push(this.colorUtils.colorize(chalk.blue, `${t('format.recommendations')}:`))
       for (const rec of report.recommendations) {
         lines.push(`  • ${rec}`)
       }
@@ -530,11 +841,124 @@ export class OutputFormatter {
    * Format validation report minimally
    */
   private formatValidationMinimal(report: WorkspaceValidationReport): string {
-    const status = report.isValid ? 'VALID' : 'INVALID'
+    const status = report.isValid ? t('format.valid') : t('format.invalid')
     const errors = report.errors.length
     const warnings = report.warnings.length
 
-    return `${status} (${errors} errors, ${warnings} warnings)`
+    return `${status} (${errors} ${t('format.errors')}, ${warnings} ${t('format.warnings')})`
+  }
+
+  /**
+   * Format workspace information as beautiful table
+   */
+  private formatWorkspaceInfoTable(info: WorkspaceInfo): string {
+    const lines: string[] = []
+
+    // Use cli-table3 for reliable alignment
+    const table = new Table({
+      chars: {
+        top: '─',
+        'top-mid': '┬',
+        'top-left': '╭',
+        'top-right': '╮',
+        bottom: '─',
+        'bottom-mid': '┴',
+        'bottom-left': '╰',
+        'bottom-right': '╯',
+        left: '│',
+        'left-mid': '├',
+        mid: '─',
+        'mid-mid': '┼',
+        right: '│',
+        'right-mid': '┤',
+        middle: '│',
+      },
+      style: {
+        head: [],
+        border: this.useColor ? ['cyan'] : [],
+        'padding-left': 1,
+        'padding-right': 1,
+      },
+      colWidths: [20, 55],
+      wordWrap: true,
+    })
+
+    // Header row
+    table.push([
+      {
+        colSpan: 2,
+        content: this.colorUtils.colorize(chalk.bold.cyan, 'WORKSPACE'),
+        hAlign: 'center',
+      },
+    ])
+
+    // Status icon (default to valid if not specified)
+    const isValid = info.isValid ?? true
+    const statusIcon = isValid
+      ? this.colorUtils.colorize(chalk.green, '✓')
+      : this.colorUtils.colorize(chalk.red, '✗')
+    const statusText = isValid
+      ? this.colorUtils.colorize(chalk.green, 'Valid')
+      : this.colorUtils.colorize(chalk.red, 'Invalid')
+
+    // Data rows - clean, no emojis
+    table.push([
+      this.colorUtils.colorize(chalk.gray, 'Name'),
+      this.colorUtils.colorize(chalk.bold.white, info.name),
+    ])
+
+    table.push([
+      this.colorUtils.colorize(chalk.gray, 'Path'),
+      this.colorUtils.colorize(chalk.dim, info.path),
+    ])
+
+    table.push([this.colorUtils.colorize(chalk.gray, 'Status'), `${statusIcon} ${statusText}`])
+
+    table.push([
+      this.colorUtils.colorize(chalk.gray, 'Packages'),
+      this.colorUtils.colorize(
+        info.packageCount > 0 ? chalk.green : chalk.yellow,
+        String(info.packageCount)
+      ),
+    ])
+
+    table.push([
+      this.colorUtils.colorize(chalk.gray, 'Catalogs'),
+      this.colorUtils.colorize(
+        info.catalogCount > 0 ? chalk.green : chalk.yellow,
+        String(info.catalogCount)
+      ),
+    ])
+
+    const catalogNames = info.catalogNames ?? []
+    if (catalogNames.length > 0) {
+      const catalogTags = catalogNames
+        .map((name: string) => this.colorUtils.colorize(chalk.cyan, name))
+        .join(this.colorUtils.colorize(chalk.gray, ', '))
+
+      table.push([this.colorUtils.colorize(chalk.gray, 'Catalog Names'), catalogTags])
+    }
+
+    lines.push('')
+    lines.push(table.toString())
+    lines.push('')
+
+    return lines.join('\n')
+  }
+
+  /**
+   * Format workspace information minimally
+   */
+  private formatWorkspaceInfoMinimal(info: WorkspaceInfo): string {
+    const lines: string[] = []
+    lines.push(`${info.name} (${info.path})`)
+    lines.push(
+      `${t('command.workspace.packages')}: ${info.packageCount}, ${t('command.workspace.catalogs')}: ${info.catalogCount}`
+    )
+    if (info.catalogNames && info.catalogNames.length > 0) {
+      lines.push(`${t('command.workspace.catalogNames')}: ${info.catalogNames.join(', ')}`)
+    }
+    return lines.join('\n')
   }
 
   /**
@@ -543,26 +967,34 @@ export class OutputFormatter {
   private formatStatsTable(stats: WorkspaceStats): string {
     const lines: string[] = []
 
-    lines.push(this.colorize(chalk.bold, `\n📊 Workspace Statistics`))
-    lines.push(this.colorize(chalk.gray, `Workspace: ${stats.workspace.name}`))
+    lines.push(this.colorUtils.colorize(chalk.bold, `\n${t('format.workspaceStatistics')}`))
+    lines.push(
+      this.colorUtils.colorize(chalk.gray, `${t('format.workspace')}: ${stats.workspace.name}`)
+    )
     lines.push('')
 
     const table = new Table({
-      head: this.colorizeHeaders(['Metric', 'Count']),
+      head: this.colorUtils.colorizeHeaders([t('table.header.metric'), t('table.header.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()])
+    table.push([t('stats.totalPackages'), stats.packages.total.toString()])
+    table.push([
+      t('stats.packagesWithCatalogRefs'),
+      stats.packages.withCatalogReferences.toString(),
+    ])
+    table.push([t('stats.totalCatalogs'), stats.catalogs.total.toString()])
+    table.push([t('stats.catalogEntries'), stats.catalogs.totalEntries.toString()])
+    table.push([t('stats.totalDependencies'), stats.dependencies.total.toString()])
+    table.push([t('stats.catalogReferences'), stats.dependencies.catalogReferences.toString()])
+    table.push([t('stats.dependencies'), stats.dependencies.byType.dependencies.toString()])
+    table.push([t('stats.devDependencies'), stats.dependencies.byType.devDependencies.toString()])
+    table.push([t('stats.peerDependencies'), stats.dependencies.byType.peerDependencies.toString()])
+    table.push([
+      t('stats.optionalDependencies'),
+      stats.dependencies.byType.optionalDependencies.toString(),
+    ])
 
     lines.push(table.toString())
 
@@ -574,9 +1006,9 @@ export class OutputFormatter {
    */
   private formatStatsMinimal(stats: WorkspaceStats): string {
     return [
-      `Packages: ${stats.packages.total}`,
-      `Catalogs: ${stats.catalogs.total}`,
-      `Dependencies: ${stats.dependencies.total}`,
+      `${t('format.packages')}: ${stats.packages.total}`,
+      `${t('format.catalogs')}: ${stats.catalogs.total}`,
+      `${t('stats.totalDependencies')}: ${stats.dependencies.total}`,
     ].join(', ')
   }
 
@@ -587,31 +1019,59 @@ export class OutputFormatter {
     const lines: string[] = []
 
     // Header
-    lines.push(this.colorize(chalk.bold, '\n🔒 Security Report'))
-    lines.push(this.colorize(chalk.gray, `Workspace: ${report.metadata.workspacePath}`))
+    lines.push(this.colorUtils.colorize(chalk.bold, `\n${t('format.securityReport')}`))
     lines.push(
-      this.colorize(chalk.gray, `Scan Date: ${new Date(report.metadata.scanDate).toLocaleString()}`)
+      this.colorUtils.colorize(
+        chalk.gray,
+        `${t('format.workspace')}: ${report.metadata.workspacePath}`
+      )
+    )
+    lines.push(
+      this.colorUtils.colorize(
+        chalk.gray,
+        `${t('format.scanDate')}: ${new Date(report.metadata.scanDate).toLocaleString()}`
+      )
+    )
+    lines.push(
+      this.colorUtils.colorize(
+        chalk.gray,
+        `${t('format.tools')}: ${report.metadata.scanTools.join(', ')}`
+      )
     )
-    lines.push(this.colorize(chalk.gray, `Tools: ${report.metadata.scanTools.join(', ')}`))
 
     // Summary
     lines.push('')
-    lines.push(this.colorize(chalk.bold, '📊 Summary:'))
+    lines.push(this.colorUtils.colorize(chalk.bold, `${t('format.summary')}:`))
 
     const summaryTable = new Table({
-      head: this.colorizeHeaders(['Severity', 'Count']),
+      head: this.colorUtils.colorizeHeaders([t('table.header.severity'), t('table.header.count')]),
       style: { head: [], border: [] },
       colWidths: [15, 10],
     })
 
-    summaryTable.push(['Critical', this.colorize(chalk.red, report.summary.critical.toString())])
-    summaryTable.push(['High', this.colorize(chalk.yellow, report.summary.high.toString())])
-    summaryTable.push(['Moderate', this.colorize(chalk.blue, report.summary.moderate.toString())])
-    summaryTable.push(['Low', this.colorize(chalk.green, report.summary.low.toString())])
-    summaryTable.push(['Info', this.colorize(chalk.gray, report.summary.info.toString())])
     summaryTable.push([
-      'Total',
-      this.colorize(chalk.bold, report.summary.totalVulnerabilities.toString()),
+      t('severity.critical'),
+      this.colorUtils.colorize(chalk.red, report.summary.critical.toString()),
+    ])
+    summaryTable.push([
+      t('severity.high'),
+      this.colorUtils.colorize(chalk.yellow, report.summary.high.toString()),
+    ])
+    summaryTable.push([
+      t('severity.moderate'),
+      this.colorUtils.colorize(chalk.blue, report.summary.moderate.toString()),
+    ])
+    summaryTable.push([
+      t('severity.low'),
+      this.colorUtils.colorize(chalk.green, report.summary.low.toString()),
+    ])
+    summaryTable.push([
+      t('severity.info'),
+      this.colorUtils.colorize(chalk.gray, report.summary.info.toString()),
+    ])
+    summaryTable.push([
+      t('severity.total'),
+      this.colorUtils.colorize(chalk.bold, report.summary.totalVulnerabilities.toString()),
     ])
 
     lines.push(summaryTable.toString())
@@ -619,25 +1079,30 @@ export class OutputFormatter {
     // Vulnerabilities
     if (report.vulnerabilities.length > 0) {
       lines.push('')
-      lines.push(this.colorize(chalk.bold, '🐛 Vulnerabilities:'))
+      lines.push(this.colorUtils.colorize(chalk.bold, `${t('format.vulnerabilities')}:`))
 
       const vulnTable = new Table({
-        head: this.colorizeHeaders(['Package', 'Severity', 'Title', 'Fix Available']),
+        head: this.colorUtils.colorizeHeaders([
+          t('table.header.package'),
+          t('table.header.severity'),
+          t('table.header.title'),
+          t('table.header.fixAvailable'),
+        ]),
         style: { head: [], border: [] },
         colWidths: [20, 12, 40, 15],
       })
 
       for (const vuln of report.vulnerabilities) {
-        const severityColor = this.getSeverityColor(vuln.severity)
+        const severityColor = this.colorUtils.getSeverityColor(vuln.severity)
         const fixStatus = vuln.fixAvailable
           ? typeof vuln.fixAvailable === 'string'
             ? vuln.fixAvailable
-            : 'Yes'
-          : 'No'
+            : t('common.yes')
+          : t('common.no')
 
         vulnTable.push([
           vuln.package,
-          this.colorize(severityColor, vuln.severity.toUpperCase()),
+          this.colorUtils.colorize(severityColor, vuln.severity.toUpperCase()),
           vuln.title.length > 35 ? `${vuln.title.substring(0, 35)}...` : vuln.title,
           fixStatus,
         ])
@@ -649,7 +1114,7 @@ export class OutputFormatter {
     // Recommendations
     if (report.recommendations.length > 0) {
       lines.push('')
-      lines.push(this.colorize(chalk.bold, '💡 Recommendations:'))
+      lines.push(this.colorUtils.colorize(chalk.bold, `${t('format.recommendations')}:`))
 
       for (const rec of report.recommendations) {
         lines.push(`  ${rec.package}: ${rec.currentVersion} → ${rec.recommendedVersion}`)
@@ -666,147 +1131,18 @@ export class OutputFormatter {
   private formatSecurityMinimal(report: SecurityReport): string {
     const vulnerabilities = report.summary.totalVulnerabilities
     if (vulnerabilities === 0) {
-      return 'No vulnerabilities found'
+      return t('format.noVulnsFound')
     }
 
     return [
-      `${vulnerabilities} vulnerabilities found:`,
-      `  Critical: ${report.summary.critical}`,
-      `  High: ${report.summary.high}`,
-      `  Moderate: ${report.summary.moderate}`,
-      `  Low: ${report.summary.low}`,
+      `${t('format.vulnerabilities')}: ${vulnerabilities}`,
+      `  ${t('severity.critical')}: ${report.summary.critical}`,
+      `  ${t('severity.high')}: ${report.summary.high}`,
+      `  ${t('severity.moderate')}: ${report.summary.moderate}`,
+      `  ${t('severity.low')}: ${report.summary.low}`,
     ].join('\n')
   }
 
-  /**
-   * Get color for severity level
-   */
-  private getSeverityColor(severity: string): typeof chalk {
-    switch (severity.toLowerCase()) {
-      case 'critical':
-        return chalk.red
-      case 'high':
-        return chalk.yellow
-      case 'moderate':
-        return chalk.blue
-      case 'low':
-        return chalk.green
-      default:
-        return chalk.gray
-    }
-  }
-
-  /**
-   * Apply color if color is enabled
-   */
-  private colorize(colorFn: typeof chalk, text: string): string {
-    return this.useColor ? colorFn(text) : text
-  }
-
-  /**
-   * Colorize table headers
-   */
-  private colorizeHeaders(headers: string[]): string[] {
-    return this.useColor ? headers.map((h) => chalk.bold.cyan(h)) : headers
-  }
-
-  /**
-   * Get color for update type
-   */
-  private getUpdateTypeColor(updateType: string): typeof chalk {
-    switch (updateType) {
-      case 'major':
-        return chalk.red
-      case 'minor':
-        return chalk.yellow
-      case 'patch':
-        return chalk.green
-      default:
-        return chalk.gray
-    }
-  }
-
-  /**
-   * Colorize version differences between current and latest
-   */
-  private colorizeVersionDiff(
-    current: string,
-    latest: string,
-    updateType: string
-  ): {
-    currentColored: string
-    latestColored: string
-  } {
-    if (!this.useColor) {
-      return { currentColored: current, latestColored: latest }
-    }
-
-    // Parse version numbers to identify different parts
-    const parseVersion = (version: string) => {
-      // 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: string, latestPart: string, isChanged: boolean) => {
-      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: string, currentPart: string, isChanged: boolean) => {
-      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 }
-  }
-
   /**
    * Format AI analysis result
    */
@@ -840,37 +1176,45 @@ export class OutputFormatter {
 
     lines.push('')
     lines.push(headerColor('═══════════════════════════════════════════════════════════════'))
-    lines.push(headerColor('                     🤖 AI Analysis Report'))
+    lines.push(headerColor(`                     ${t('aiReport.title')}`))
     lines.push(headerColor('═══════════════════════════════════════════════════════════════'))
     lines.push('')
 
     // Provider and analysis info
-    lines.push(`${infoColor('Provider:')}      ${providerColor(aiResult.provider)}`)
-    lines.push(`${infoColor('Analysis Type:')} ${aiResult.analysisType}`)
-    lines.push(`${infoColor('Confidence:')}    ${this.formatConfidence(aiResult.confidence)}`)
+    lines.push(`${infoColor(t('aiReport.provider'))}      ${providerColor(aiResult.provider)}`)
+    lines.push(`${infoColor(t('aiReport.analysisType'))} ${aiResult.analysisType}`)
+    lines.push(
+      `${infoColor(t('aiReport.confidence'))}    ${this.colorUtils.formatConfidence(aiResult.confidence)}`
+    )
     lines.push('')
 
     // Summary
-    lines.push(headerColor('📋 Summary'))
+    lines.push(headerColor(t('aiReport.summary')))
     lines.push(headerColor('───────────────────────────────────────────────────────────────'))
     lines.push(aiResult.summary)
     lines.push('')
 
     // Recommendations table
     if (aiResult.recommendations.length > 0) {
-      lines.push(headerColor('💡 Recommendations'))
+      lines.push(headerColor(t('aiReport.recommendations')))
       lines.push(headerColor('───────────────────────────────────────────────────────────────'))
 
       const table = new Table({
-        head: ['Package', 'Version Change', 'Action', 'Risk', 'Reason'],
+        head: [
+          t('aiReport.tablePackage'),
+          t('aiReport.tableVersionChange'),
+          t('aiReport.tableAction'),
+          t('aiReport.tableRisk'),
+          t('aiReport.tableReason'),
+        ],
         style: { head: this.useColor ? ['cyan'] : [] },
         colWidths: [20, 20, 10, 10, 35],
         wordWrap: true,
       })
 
       for (const rec of aiResult.recommendations) {
-        const riskColor = this.getRiskColor(rec.riskLevel)
-        const actionColor = this.getActionColor(rec.action)
+        const riskColor = this.colorUtils.getRiskColor(rec.riskLevel)
+        const actionColor = this.colorUtils.getActionColor(rec.action)
 
         table.push([
           rec.package,
@@ -891,7 +1235,7 @@ export class OutputFormatter {
       .flatMap((r) => r.breakingChanges || [])
 
     if (allBreakingChanges.length > 0) {
-      lines.push(errorColor('⚠️  Breaking Changes'))
+      lines.push(errorColor(t('aiReport.breakingChanges')))
       lines.push(headerColor('───────────────────────────────────────────────────────────────'))
       for (const change of allBreakingChanges) {
         lines.push(`  ${warningColor('•')} ${change}`)
@@ -905,7 +1249,7 @@ export class OutputFormatter {
       .flatMap((r) => r.securityFixes || [])
 
     if (allSecurityFixes.length > 0) {
-      lines.push(successColor('🔒 Security Fixes'))
+      lines.push(successColor(t('aiReport.securityFixes')))
       lines.push(headerColor('───────────────────────────────────────────────────────────────'))
       for (const fix of allSecurityFixes) {
         lines.push(`  ${successColor('•')} ${fix}`)
@@ -915,7 +1259,7 @@ export class OutputFormatter {
 
     // Warnings
     if (aiResult.warnings && aiResult.warnings.length > 0) {
-      lines.push(warningColor('⚡ Warnings'))
+      lines.push(warningColor(t('aiReport.warnings')))
       lines.push(headerColor('───────────────────────────────────────────────────────────────'))
       for (const warning of aiResult.warnings) {
         lines.push(`  ${warningColor('•')} ${warning}`)
@@ -925,7 +1269,7 @@ export class OutputFormatter {
 
     // Details
     if (aiResult.details) {
-      lines.push(infoColor('📝 Details'))
+      lines.push(infoColor(t('aiReport.details')))
       lines.push(headerColor('───────────────────────────────────────────────────────────────'))
       lines.push(aiResult.details)
       lines.push('')
@@ -933,7 +1277,7 @@ export class OutputFormatter {
 
     // Basic analysis info (if provided)
     if (basicAnalysis) {
-      lines.push(mutedColor('📦 Affected Packages'))
+      lines.push(mutedColor(t('aiReport.affectedPackages')))
       lines.push(headerColor('───────────────────────────────────────────────────────────────'))
       if (basicAnalysis.affectedPackages.length > 0) {
         for (const pkg of basicAnalysis.affectedPackages.slice(0, 10)) {
@@ -945,11 +1289,11 @@ export class OutputFormatter {
         }
         if (basicAnalysis.affectedPackages.length > 10) {
           lines.push(
-            `  ${mutedColor(`  ... and ${basicAnalysis.affectedPackages.length - 10} more`)}`
+            `  ${mutedColor(`  ${t('aiReport.andMore', { count: basicAnalysis.affectedPackages.length - 10 })}`)}`
           )
         }
       } else {
-        lines.push(`  ${mutedColor('No packages directly affected')}`)
+        lines.push(`  ${mutedColor(t('aiReport.noPackagesAffected'))}`)
       }
       lines.push('')
     }
@@ -960,12 +1304,12 @@ export class OutputFormatter {
       aiResult.timestamp instanceof Date
         ? aiResult.timestamp.toISOString()
         : String(aiResult.timestamp)
-    lines.push(mutedColor(`Generated at: ${timestamp}`))
+    lines.push(mutedColor(t('aiReport.generatedAt', { timestamp })))
     if (aiResult.processingTimeMs) {
-      lines.push(mutedColor(`Processing time: ${aiResult.processingTimeMs}ms`))
+      lines.push(mutedColor(t('aiReport.processingTime', { time: aiResult.processingTimeMs })))
     }
     if (aiResult.tokensUsed) {
-      lines.push(mutedColor(`Tokens used: ${aiResult.tokensUsed}`))
+      lines.push(mutedColor(t('aiReport.tokensUsed', { tokens: aiResult.tokensUsed })))
     }
     lines.push('')
 
@@ -991,65 +1335,4 @@ export class OutputFormatter {
 
     return lines.join('\n')
   }
-
-  /**
-   * Format confidence score with color
-   */
-  private formatConfidence(confidence: number): string {
-    const percentage = Math.round(confidence * 100)
-    const bar =
-      '█'.repeat(Math.floor(percentage / 10)) + '░'.repeat(10 - Math.floor(percentage / 10))
-
-    if (!this.useColor) {
-      return `${bar} ${percentage}%`
-    }
-
-    if (confidence >= 0.8) {
-      return chalk.green(`${bar} ${percentage}%`)
-    } else if (confidence >= 0.5) {
-      return chalk.yellow(`${bar} ${percentage}%`)
-    } else {
-      return chalk.red(`${bar} ${percentage}%`)
-    }
-  }
-
-  /**
-   * Get color for risk level
-   */
-  private getRiskColor(riskLevel: string): typeof chalk {
-    if (!this.useColor) return chalk
-
-    switch (riskLevel) {
-      case 'critical':
-        return chalk.red.bold
-      case 'high':
-        return chalk.red
-      case 'medium':
-        return chalk.yellow
-      case 'low':
-        return chalk.green
-      default:
-        return chalk.gray
-    }
-  }
-
-  /**
-   * Get color for action
-   */
-  private getActionColor(action: string): typeof chalk {
-    if (!this.useColor) return chalk
-
-    switch (action) {
-      case 'update':
-        return chalk.green
-      case 'wait':
-        return chalk.yellow
-      case 'skip':
-        return chalk.red
-      case 'review':
-        return chalk.cyan
-      default:
-        return chalk.white
-    }
-  }
 }