pnpm-catalog-updates 1.0.3 → 1.1.0

package/src/cli/formatters/progressBar.ts

@@ -5,6 +5,7 @@
  * with multiple styles and themes.
  */
 
+import { t } from '@pcu/utils'
 import chalk from 'chalk'
 
 export interface ProgressBarOptions {
@@ -24,7 +25,7 @@ export class ProgressBar {
   private showSpeed: boolean
 
   constructor(options: ProgressBarOptions = {}) {
-    this.text = options.text || 'Processing...'
+    this.text = options.text || t('progress.processing')
     this.total = options.total || 0
     this.style = options.style || 'default'
     this.showSpeed = options.showSpeed ?? true
@@ -37,9 +38,6 @@ export class ProgressBar {
     this.text = text || this.text
     this.startTime = Date.now()
 
-    // 在开始新进度条前，彻底清理可能的残留内容
-    this.clearPreviousOutput()
-
     // 强制使用percentageBar，即使没有total也要创建
     // 这样可以避免spinner导致的冲突问题
     const effectiveTotal = this.total > 0 ? this.total : 1 // 如果没有total，设为1避免除零错误
@@ -86,7 +84,9 @@ export class ProgressBar {
     // 只使用percentageBar，不使用spinner
     if (this.percentageBar) {
       const successText = text || this.getCompletionText()
+      // complete() will clear the progress bar output
       this.percentageBar.complete(successText)
+      // Now print the success message on a clean line
       console.log(this.getSuccessMessage(successText))
       this.percentageBar = null
     }
@@ -99,6 +99,9 @@ export class ProgressBar {
     // 只使用percentageBar，不使用spinner
     if (this.percentageBar) {
       const failText = text || this.getFailureText()
+      // Clear the progress bar first
+      this.percentageBar.complete(failText)
+      // Now print the failure message on a clean line
       console.log(this.getFailureMessage(failText))
       this.percentageBar = null
     }
@@ -111,15 +114,15 @@ export class ProgressBar {
     const elapsed = this.getElapsedTime()
     switch (this.style) {
       case 'gradient':
-        return `${chalk.magenta.bold('✨')} ${chalk.green(text)} ${chalk.gray(elapsed)}`
+        return `${chalk.magenta.bold('*')} ${chalk.green(text)} ${chalk.gray(elapsed)}`
       case 'fancy':
-        return `${chalk.cyan('🎉')} ${chalk.green.bold(text)} ${chalk.cyan('🎉')} ${chalk.gray(elapsed)}`
+        return `${chalk.cyan('*')} ${chalk.green.bold(text)} ${chalk.cyan('*')} ${chalk.gray(elapsed)}`
       case 'minimal':
         return chalk.green(text)
       case 'rainbow':
-        return `${chalk.magenta('🌈')} ${chalk.green(text)} ${chalk.gray(elapsed)}`
+        return `${chalk.magenta('~')} ${chalk.green(text)} ${chalk.gray(elapsed)}`
       case 'neon':
-        return `${chalk.green.bold('⚡ SUCCESS')} ${chalk.green(text)} ${chalk.gray(elapsed)}`
+        return `${chalk.green.bold(`⚡ ${t('progress.success').toUpperCase()}`)} ${chalk.green(text)} ${chalk.gray(elapsed)}`
       default:
         return `${chalk.green('✅')} ${chalk.green(text)} ${chalk.gray(elapsed)}`
     }
@@ -132,15 +135,15 @@ export class ProgressBar {
     const elapsed = this.getElapsedTime()
     switch (this.style) {
       case 'gradient':
-        return `${chalk.red.bold('💥')} ${chalk.red(text)} ${chalk.gray(elapsed)}`
+        return `${chalk.red.bold('!!')} ${chalk.red(text)} ${chalk.gray(elapsed)}`
       case 'fancy':
-        return `${chalk.red('💔')} ${chalk.red.bold(text)} ${chalk.red('💔')} ${chalk.gray(elapsed)}`
+        return `${chalk.red('!!')} ${chalk.red.bold(text)} ${chalk.red('!!')} ${chalk.gray(elapsed)}`
       case 'minimal':
         return chalk.red(text)
       case 'rainbow':
         return `${chalk.red('⚠️')} ${chalk.red(text)} ${chalk.gray(elapsed)}`
       case 'neon':
-        return `${chalk.red.bold('⚡ ERROR')} ${chalk.red(text)} ${chalk.gray(elapsed)}`
+        return `${chalk.red.bold(`⚡ ${t('progress.error').toUpperCase()}`)} ${chalk.red(text)} ${chalk.gray(elapsed)}`
       default:
         return `${chalk.red('❌')} ${chalk.red(text)} ${chalk.gray(elapsed)}`
     }
@@ -152,14 +155,14 @@ export class ProgressBar {
   private getCompletionText(): string {
     const elapsed = this.getElapsedTime()
     const speed = this.getAverageSpeed()
-    return `${this.text} completed ${speed} ${elapsed}`
+    return `${this.text} ${t('progress.completed')} ${speed} ${elapsed}`
   }
 
   /**
    * Get failure text
    */
   private getFailureText(): string {
-    return `${this.text} failed`
+    return `${this.text} ${t('progress.failed')}`
   }
 
   /**
@@ -189,6 +192,9 @@ export class ProgressBar {
     // 只使用percentageBar，不使用spinner
     if (this.percentageBar) {
       const warnText = text || this.text
+      // Clear the progress bar first
+      this.percentageBar.complete(warnText)
+      // Now print the warning message on a clean line
       console.log(this.getWarningMessage(warnText))
       this.percentageBar = null
     }
@@ -201,6 +207,9 @@ export class ProgressBar {
     // 只使用percentageBar，不使用spinner
     if (this.percentageBar) {
       const infoText = text || this.text
+      // Clear the progress bar first
+      this.percentageBar.complete(infoText)
+      // Now print the info message on a clean line
       console.log(this.getInfoMessage(infoText))
       this.percentageBar = null
     }
@@ -213,7 +222,7 @@ export class ProgressBar {
     const elapsed = this.getElapsedTime()
     switch (this.style) {
       case 'gradient':
-        return `${chalk.yellow.bold('⚡')} ${chalk.yellow(text)} ${chalk.gray(elapsed)}`
+        return `${chalk.yellow.bold('!')} ${chalk.yellow(text)} ${chalk.gray(elapsed)}`
       case 'fancy':
         return `${chalk.yellow('⚠️')} ${chalk.yellow.bold(text)} ${chalk.yellow('⚠️')} ${chalk.gray(elapsed)}`
       case 'minimal':
@@ -221,7 +230,7 @@ export class ProgressBar {
       case 'rainbow':
         return `${chalk.yellow('⚠️')} ${chalk.yellow(text)} ${chalk.gray(elapsed)}`
       case 'neon':
-        return `${chalk.yellow.bold('⚡ WARNING')} ${chalk.yellow(text)} ${chalk.gray(elapsed)}`
+        return `${chalk.yellow.bold(`⚡ ${t('progress.warning').toUpperCase()}`)} ${chalk.yellow(text)} ${chalk.gray(elapsed)}`
       default:
         return `${chalk.yellow('⚠️')} ${chalk.yellow(text)} ${chalk.gray(elapsed)}`
     }
@@ -234,17 +243,17 @@ export class ProgressBar {
     const elapsed = this.getElapsedTime()
     switch (this.style) {
       case 'gradient':
-        return `${chalk.blue.bold('ℹ️')} ${chalk.blue(text)} ${chalk.gray(elapsed)}`
+        return `${chalk.blue.bold('[i]')} ${chalk.blue(text)} ${chalk.gray(elapsed)}`
       case 'fancy':
-        return `${chalk.blue('💡')} ${chalk.blue.bold(text)} ${chalk.blue('💡')} ${chalk.gray(elapsed)}`
+        return `${chalk.blue('[i]')} ${chalk.blue.bold(text)} ${chalk.blue('[i]')} ${chalk.gray(elapsed)}`
       case 'minimal':
         return chalk.blue(text)
       case 'rainbow':
-        return `${chalk.blue('ℹ️')} ${chalk.blue(text)} ${chalk.gray(elapsed)}`
+        return `${chalk.blue('[i]')} ${chalk.blue(text)} ${chalk.gray(elapsed)}`
       case 'neon':
-        return `${chalk.blue.bold('⚡ INFO')} ${chalk.blue(text)} ${chalk.gray(elapsed)}`
+        return `${chalk.blue.bold(`[i] ${t('progress.info').toUpperCase()}`)} ${chalk.blue(text)} ${chalk.gray(elapsed)}`
       default:
-        return `${chalk.blue('ℹ️')} ${chalk.blue(text)} ${chalk.gray(elapsed)}`
+        return `${chalk.blue('[i]')} ${chalk.blue(text)} ${chalk.gray(elapsed)}`
     }
   }
 
@@ -254,22 +263,12 @@ export class ProgressBar {
   stop(): void {
     // 只使用percentageBar，不使用spinner
     if (this.percentageBar) {
+      // Clear the progress bar before stopping
+      this.percentageBar.complete('')
       this.percentageBar = null
     }
   }
 
-  /**
-   * Clear previous output to prevent residual progress bars
-   */
-  private clearPreviousOutput(): void {
-    // 清理可能的残留进度条显示（最多清理5行，应该足够了）
-    for (let i = 0; i < 5; i++) {
-      process.stdout.write('\x1b[1A\r\x1b[K') // 上移一行并清除
-    }
-    // 确保光标在正确位置
-    process.stdout.write('\r')
-  }
-
   /**
    * Create a multi-step progress indicator
    */
@@ -345,7 +344,7 @@ export class MultiStepProgress {
   }
 
   start(): void {
-    console.log(chalk.bold('\n📋 Progress Steps:\n'))
+    console.log(chalk.bold(`\n📋 ${t('progress.steps')}:\n`))
     this.renderSteps()
   }
 
@@ -362,7 +361,7 @@ export class MultiStepProgress {
   }
 
   complete(): void {
-    console.log(chalk.green('\n🎉 All steps completed!\n'))
+    console.log(chalk.green(`\n🎉 ${t('progress.allStepsCompleted')}\n`))
   }
 
   private renderSteps(): void {
@@ -403,24 +402,9 @@ export class PercentageProgressBar {
     this.startTime = Date.now()
     this.isFirstRender = true // 重置首次渲染标记
 
-    // 清理可能的残留输出
-    this.clearPreviousLines()
-
     this.render()
   }
 
-  /**
-   * Clear any previous output lines to prevent conflicts
-   */
-  private clearPreviousLines(): void {
-    // 更强力的清理：清理多行可能的残留内容
-    for (let i = 0; i < 6; i++) {
-      process.stdout.write('\x1b[1A\r\x1b[2K') // 上移一行并完全清除该行
-    }
-    // 回到起始位置
-    process.stdout.write('\r')
-  }
-
   update(current: number, text?: string): void {
     this.current = current
     if (text) this.text = text
@@ -436,8 +420,15 @@ export class PercentageProgressBar {
   complete(text?: string): void {
     this.current = this.total
     if (text) this.text = text
-    this.render()
-    console.log('') // New line after completion
+
+    // Clear the multi-line progress bar output completely before final state
+    if (this.useMultiLine && !this.isFirstRender) {
+      // Move up 2 lines (text line + progress bar line) and clear them
+      process.stdout.write('\x1b[2A\r\x1b[2K\x1b[1B\x1b[2K\x1b[1A\r')
+    }
+
+    // Don't render anymore - just let the caller handle the final message
+    this.lastRender = ''
   }
 
   private render(): void {
@@ -678,7 +669,7 @@ export class BatchProgressManager {
 
     console.log(
       chalk.cyan(
-        `📊 Overall Progress: ${percentage}% (${this.completedOperations}/${this.totalOperations})`
+        `📊 ${t('progress.overallProgress')}: ${percentage}% (${this.completedOperations}/${this.totalOperations})`
       )
     )
     if (text) {

package/src/cli/formatters/versionFormatter.ts

@@ -0,0 +1,132 @@
+/**
+ * Version Formatter Utilities
+ *
+ * Provides version parsing and colorization utilities for CLI output.
+ * Extracted from OutputFormatter for better maintainability.
+ */
+
+import chalk from 'chalk'
+import type { ColorUtils } from './colorUtils.js'
+
+export interface VersionParts {
+  major: string
+  minor: string
+  patch: string
+  extra: string
+  prefix: string
+}
+
+export interface ColorizedVersions {
+  currentColored: string
+  latestColored: string
+}
+
+/**
+ * Version formatting utilities for CLI output
+ */
+export class VersionFormatter {
+  constructor(
+    private readonly colorUtils: ColorUtils,
+    private readonly useColor: boolean = true
+  ) {}
+
+  /**
+   * Parse a version string into its component parts
+   */
+  parseVersion(version: string): VersionParts {
+    // 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),
+    }
+  }
+
+  /**
+   * Colorize version differences between current and latest
+   */
+  colorizeVersionDiff(current: string, latest: string, updateType: string): ColorizedVersions {
+    if (!this.useColor) {
+      return { currentColored: current, latestColored: latest }
+    }
+
+    const currentParts = this.parseVersion(current)
+    const latestParts = this.parseVersion(latest)
+
+    // Determine color based on update type for highlighting differences
+    const diffColor = this.colorUtils.getUpdateTypeColor(updateType)
+
+    // 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 version strings
+    const currentColored = this.buildColoredVersion(
+      currentParts,
+      latestParts,
+      { majorChanged, minorChanged, patchChanged, extraChanged },
+      true
+    )
+
+    const latestColored = this.buildColoredVersion(
+      latestParts,
+      currentParts,
+      { majorChanged, minorChanged, patchChanged, extraChanged },
+      false,
+      diffColor
+    )
+
+    return { currentColored, latestColored }
+  }
+
+  /**
+   * Build a colored version string
+   */
+  private buildColoredVersion(
+    parts: VersionParts,
+    compareParts: VersionParts,
+    changes: {
+      majorChanged: boolean
+      minorChanged: boolean
+      patchChanged: boolean
+      extraChanged: boolean
+    },
+    isCurrent: boolean,
+    diffColor?: typeof chalk
+  ): string {
+    const colorPart = (part: string, comparePart: string, isChanged: boolean) => {
+      if (isCurrent) {
+        // For current version: dim white for changed parts
+        if (isChanged && part !== comparePart) {
+          return chalk.dim.white(part)
+        }
+        return chalk.white(part)
+      } else {
+        // For latest version: highlight changed parts with update type color
+        if (isChanged && part !== comparePart && diffColor) {
+          return diffColor(part)
+        }
+        return chalk.white(part)
+      }
+    }
+
+    let result = parts.prefix
+    result += colorPart(parts.major, compareParts.major, changes.majorChanged)
+    result += '.'
+    result += colorPart(parts.minor, compareParts.minor, changes.minorChanged)
+    result += '.'
+    result += colorPart(parts.patch, compareParts.patch, changes.patchChanged)
+
+    if (parts.extra) {
+      result += `.${colorPart(parts.extra, compareParts.extra, changes.extraChanged)}`
+    }
+
+    return result
+  }
+}

package/src/cli/handlers/aiAnalysisHandler.ts

@@ -0,0 +1,205 @@
+/**
+ * AI Analysis Handler
+ *
+ * Handles AI analysis display and formatting for the update command.
+ */
+
+import {
+  AIAnalysisService,
+  type AnalysisResult,
+  type AnalysisType,
+  type UpdatePlan,
+  type WorkspaceService,
+} from '@pcu/core'
+import { logger, t } from '@pcu/utils'
+import chalk from 'chalk'
+import { cliOutput } from '../utils/cliOutput.js'
+
+/**
+ * Options for AI analysis
+ */
+export interface AIAnalysisOptions {
+  workspace?: string
+  provider?: string
+  analysisType?: AnalysisType
+  skipCache?: boolean
+  verbose?: boolean
+  force?: boolean
+}
+
+/**
+ * Handles AI analysis for package updates
+ */
+export class AIAnalysisHandler {
+  private readonly workspaceService: WorkspaceService
+
+  constructor(workspaceService: WorkspaceService) {
+    this.workspaceService = workspaceService
+  }
+
+  /**
+   * Perform AI analysis and display results
+   */
+  async analyzeAndDisplay(plan: UpdatePlan, options: AIAnalysisOptions): Promise<void> {
+    cliOutput.print(
+      chalk.blue(`\n🤖 ${t('command.update.runningBatchAI', { count: plan.updates.length })}`)
+    )
+    cliOutput.print(chalk.gray(`${t('command.update.batchAIHint')}\n`))
+
+    try {
+      const aiResult = await this.performBatchAnalysis(plan, options)
+      this.displayResults(aiResult, options.force)
+    } catch (aiError) {
+      logger.warn('AI batch analysis failed', {
+        error: aiError instanceof Error ? aiError.message : String(aiError),
+        packageCount: plan.updates.length,
+        provider: options.provider,
+      })
+      cliOutput.warn(chalk.yellow(`\n⚠️  ${t('command.update.aiBatchFailed')}`))
+      if (options.verbose) {
+        cliOutput.warn(chalk.gray(String(aiError)))
+      }
+    }
+  }
+
+  /**
+   * Perform batch AI analysis for all packages in the update plan
+   */
+  private async performBatchAnalysis(
+    plan: UpdatePlan,
+    options: AIAnalysisOptions
+  ): Promise<AnalysisResult> {
+    const workspacePath = options.workspace || process.cwd()
+    const workspaceInfo = await this.workspaceService.getWorkspaceInfo(workspacePath)
+
+    const aiService = new AIAnalysisService({
+      config: {
+        preferredProvider: options.provider === 'auto' ? 'auto' : options.provider,
+        cache: { enabled: !options.skipCache, ttl: 3600 },
+        fallback: { enabled: true, useRuleEngine: true },
+      },
+    })
+
+    // Convert planned updates to PackageUpdateInfo format
+    const packages = plan.updates.map((update) => ({
+      name: update.packageName,
+      currentVersion: update.currentVersion,
+      targetVersion: update.newVersion,
+      updateType: update.updateType,
+      catalogName: update.catalogName,
+    }))
+
+    const wsInfo = {
+      name: workspaceInfo.name,
+      path: workspaceInfo.path,
+      packageCount: workspaceInfo.packageCount,
+      catalogCount: workspaceInfo.catalogCount,
+    }
+
+    return aiService.analyzeWithChunking(packages, wsInfo, {
+      analysisType: options.analysisType || 'impact',
+      skipCache: options.skipCache,
+      chunking: {
+        enabled: true,
+        threshold: 15,
+        chunkSize: 10,
+        onProgress: options.verbose
+          ? (progress) => {
+              cliOutput.print(
+                chalk.gray(
+                  `  ${t('command.update.processingChunks', {
+                    current: progress.currentChunk,
+                    total: progress.totalChunks,
+                  })} (${progress.percentComplete}%)`
+                )
+              )
+            }
+          : undefined,
+      },
+    })
+  }
+
+  /**
+   * Display AI analysis results
+   */
+  private displayResults(aiResult: AnalysisResult, force?: boolean): void {
+    cliOutput.print(chalk.blue(`\n📊 ${t('command.update.aiResults')}`))
+    cliOutput.print(chalk.gray('─'.repeat(60)))
+    cliOutput.print(chalk.cyan(t('command.update.provider', { provider: aiResult.provider })))
+    cliOutput.print(
+      chalk.cyan(
+        t('command.update.confidence', { confidence: (aiResult.confidence * 100).toFixed(0) })
+      )
+    )
+    cliOutput.print(
+      chalk.cyan(t('command.update.processingTime', { time: aiResult.processingTimeMs }))
+    )
+    cliOutput.print(chalk.gray('─'.repeat(60)))
+    cliOutput.print(chalk.yellow(`\n📝 ${t('command.update.summary')}`))
+    cliOutput.print(aiResult.summary)
+
+    if (aiResult.recommendations.length > 0) {
+      cliOutput.print(chalk.yellow(`\n📦 ${t('command.update.packageRecommendations')}`))
+      for (const rec of aiResult.recommendations) {
+        this.displayRecommendation(rec)
+      }
+    }
+
+    if (aiResult.warnings && aiResult.warnings.length > 0) {
+      cliOutput.print(chalk.yellow(`\n⚠️  ${t('command.update.warnings')}`))
+      for (const warning of aiResult.warnings) {
+        cliOutput.print(chalk.yellow(`  - ${warning}`))
+      }
+    }
+
+    cliOutput.print(chalk.gray(`\n${'─'.repeat(60)}`))
+
+    const skipRecommendations = aiResult.recommendations.filter((r) => r.action === 'skip')
+    if (skipRecommendations.length > 0 && !force) {
+      cliOutput.print(
+        chalk.red(
+          `\n⛔ ${t('command.update.aiSkipRecommend', { count: skipRecommendations.length })}`
+        )
+      )
+      cliOutput.print(chalk.yellow(t('command.update.useForce')))
+    }
+  }
+
+  /**
+   * Display a single package recommendation
+   */
+  private displayRecommendation(rec: AnalysisResult['recommendations'][0]): void {
+    const actionIcon = rec.action === 'update' ? '✅' : rec.action === 'skip' ? '❌' : '⚠️'
+    const riskColor =
+      rec.riskLevel === 'critical'
+        ? chalk.red
+        : rec.riskLevel === 'high'
+          ? chalk.yellow
+          : rec.riskLevel === 'medium'
+            ? chalk.cyan
+            : chalk.green
+
+    cliOutput.print(
+      `\n  ${actionIcon} ${chalk.bold(rec.package)}: ${rec.currentVersion} → ${rec.targetVersion}`
+    )
+    cliOutput.print(
+      `     Action: ${chalk.bold(rec.action.toUpperCase())} | Risk: ${riskColor(rec.riskLevel)}`
+    )
+    cliOutput.print(`     ${rec.reason}`)
+
+    if (rec.breakingChanges && rec.breakingChanges.length > 0) {
+      cliOutput.print(
+        chalk.red(
+          `     ⚠️  ${t('command.update.breakingChanges', { changes: rec.breakingChanges.join(', ') })}`
+        )
+      )
+    }
+    if (rec.securityFixes && rec.securityFixes.length > 0) {
+      cliOutput.print(
+        chalk.green(
+          `     🔒 ${t('command.update.securityFixes', { fixes: rec.securityFixes.join(', ') })}`
+        )
+      )
+    }
+  }
+}

package/src/cli/handlers/changelogHandler.ts

@@ -0,0 +1,113 @@
+/**
+ * Changelog Handler
+ *
+ * Handles changelog fetching and display for the update command.
+ */
+
+import { ChangelogService, NpmRegistryService, type UpdatePlan } from '@pcu/core'
+import { logger, t } from '@pcu/utils'
+import chalk from 'chalk'
+import { cliOutput } from '../utils/cliOutput.js'
+
+/**
+ * Handles changelog display for package updates
+ */
+export class ChangelogHandler {
+  private readonly changelogService: ChangelogService
+  private readonly npmRegistry: NpmRegistryService
+
+  constructor() {
+    this.changelogService = new ChangelogService({ cacheMinutes: 30 })
+    this.npmRegistry = new NpmRegistryService()
+  }
+
+  /**
+   * Display changelogs for all planned updates
+   */
+  async displayChangelogs(plan: UpdatePlan, verbose?: boolean): Promise<void> {
+    cliOutput.print(chalk.blue(`\n📋 ${t('command.update.fetchingChangelogs')}`))
+
+    for (const update of plan.updates) {
+      await this.displayPackageChangelog(
+        update.packageName,
+        update.currentVersion,
+        update.newVersion,
+        verbose
+      )
+    }
+
+    cliOutput.print(chalk.gray(`\n${'─'.repeat(60)}`))
+  }
+
+  /**
+   * Display changelog for a single package
+   */
+  private async displayPackageChangelog(
+    packageName: string,
+    currentVersion: string,
+    newVersion: string,
+    verbose?: boolean
+  ): Promise<void> {
+    try {
+      // Get package info to find repository URL
+      const packageInfo = await this.npmRegistry.getPackageInfo(packageName)
+      const repository = this.extractRepository(packageInfo.repository)
+
+      // Fetch changelog between versions
+      const changelog = await this.changelogService.getChangelog(
+        packageName,
+        currentVersion,
+        newVersion,
+        repository
+      )
+
+      // Display formatted changelog
+      cliOutput.print(chalk.yellow(`\n📦 ${packageName}`))
+      cliOutput.print(chalk.gray(`   ${currentVersion} → ${newVersion}`))
+      cliOutput.print(this.changelogService.formatChangelog(changelog, verbose))
+    } catch (error) {
+      logger.debug('Failed to fetch changelog', {
+        package: packageName,
+        error: error instanceof Error ? error.message : String(error),
+      })
+      this.displayFallbackInfo(packageName, currentVersion, newVersion)
+    }
+  }
+
+  /**
+   * Extract repository info from package.json repository field
+   */
+  private extractRepository(repository: unknown): { type: string; url: string } | undefined {
+    if (!repository) return undefined
+
+    if (typeof repository === 'string') {
+      return { type: 'git', url: repository }
+    }
+
+    if (typeof repository === 'object' && repository !== null) {
+      const repo = repository as { type?: string; url?: string }
+      if (repo.url) {
+        return { type: repo.type || 'git', url: repo.url }
+      }
+    }
+
+    return undefined
+  }
+
+  /**
+   * Display fallback info when changelog is not available
+   */
+  private displayFallbackInfo(
+    packageName: string,
+    currentVersion: string,
+    newVersion: string
+  ): void {
+    cliOutput.print(chalk.yellow(`\n📦 ${packageName}`))
+    cliOutput.print(chalk.gray(`   ${currentVersion} → ${newVersion}`))
+    cliOutput.print(
+      chalk.gray(
+        `   📋 ${t('command.update.changelogUnavailable')}: https://www.npmjs.com/package/${packageName}?activeTab=versions`
+      )
+    )
+  }
+}