pnpm-catalog-updates 1.0.3 → 1.1.0

package/src/cli/commands/updateCommand.ts

@@ -5,23 +5,32 @@
  * Supports interactive mode, dry-run, and various update strategies.
  */
 
-import {
-  AIAnalysisService,
-  type AnalysisType,
-  type CatalogUpdateService,
-  FileSystemService,
-  FileWorkspaceRepository,
-  type UpdateOptions,
-  type UpdatePlan,
-  type UpdateTarget,
+import type {
+  AnalysisType,
+  CatalogUpdateService,
+  IPackageManagerService,
+  UpdateOptions,
+  UpdatePlan,
+  UpdateTarget,
   WorkspaceService,
 } from '@pcu/core'
-import { ConfigLoader } from '@pcu/utils'
-import chalk from 'chalk'
-import { type OutputFormat, OutputFormatter } from '../formatters/outputFormatter.js'
+import { type PackageFilterConfig, t } from '@pcu/utils'
+import type { OutputFormat, OutputFormatter } from '../formatters/outputFormatter.js'
 import { ProgressBar } from '../formatters/progressBar.js'
+import { AIAnalysisHandler, ChangelogHandler, InstallHandler } from '../handlers/index.js'
 import { InteractivePrompts } from '../interactive/interactivePrompts.js'
-import { StyledText, ThemeManager } from '../themes/colorTheme.js'
+import { StyledText } from '../themes/colorTheme.js'
+import { cliOutput } from '../utils/cliOutput.js'
+import {
+  createFormatter,
+  getEffectivePatterns,
+  getEffectiveTarget,
+  handleCommandError,
+  initializeTheme,
+  loadConfiguration,
+  mergeWithConfig,
+} from '../utils/commandHelpers.js'
+import { errorsOnly, validateUpdateOptions } from '../validators/index.js'
 
 export interface UpdateCommandOptions {
   workspace?: string
@@ -42,220 +51,153 @@ export interface UpdateCommandOptions {
   provider?: string
   analysisType?: AnalysisType
   skipCache?: boolean
+  // Auto install after update
+  install?: boolean
+  // Show changelog for updates
+  changelog?: boolean
+  // Skip security vulnerability checks
+  noSecurity?: boolean
 }
 
 export class UpdateCommand {
   private readonly updateService: CatalogUpdateService
-
-  constructor(updateService: CatalogUpdateService) {
+  private readonly aiAnalysisHandler: AIAnalysisHandler
+  private readonly changelogHandler: ChangelogHandler
+  private readonly installHandler: InstallHandler
+
+  constructor(
+    updateService: CatalogUpdateService,
+    workspaceService: WorkspaceService,
+    packageManagerService: IPackageManagerService
+  ) {
     this.updateService = updateService
+    this.aiAnalysisHandler = new AIAnalysisHandler(workspaceService)
+    this.changelogHandler = new ChangelogHandler()
+    // ARCH-002: Extracted install logic to dedicated handler
+    this.installHandler = new InstallHandler(packageManagerService)
   }
 
   /**
    * Execute the update command
    */
   async execute(options: UpdateCommandOptions = {}): Promise<void> {
-    let progressBar: ProgressBar | undefined
+    const progressBar = this.createProgressBar()
 
     try {
-      // Initialize theme
-      ThemeManager.setTheme('default')
-
-      // Create progress bar for the update process
-      progressBar = new ProgressBar({
-        text: '正在规划更新...',
-        total: 4, // 4 main steps
-      })
-      progressBar.start('正在加载工作区配置...')
-
-      // Load configuration file first
-      const config = ConfigLoader.loadConfig(options.workspace || process.cwd())
-
-      // Use format from CLI options first, then config file, then default
-      const effectiveFormat = options.format || config.defaults?.format || 'table'
-
-      // Create output formatter with effective format
-      const formatter = new OutputFormatter(
-        effectiveFormat as OutputFormat,
-        options.color !== false
-      )
-
-      // Merge CLI options with configuration file settings
-      const updateOptions: UpdateOptions = {
-        workspacePath: options.workspace,
-        catalogName: options.catalog,
-        target: options.target || config.defaults?.target,
-        includePrerelease: options.prerelease ?? config.defaults?.includePrerelease ?? false,
-        // CLI include/exclude options take priority over config file
-        include: options.include?.length ? options.include : config.include,
-        exclude: options.exclude?.length ? options.exclude : config.exclude,
-        interactive: options.interactive ?? config.defaults?.interactive ?? false,
-        dryRun: options.dryRun ?? config.defaults?.dryRun ?? false,
-        force: options.force ?? false,
-        createBackup: options.createBackup ?? config.defaults?.createBackup ?? false,
-      }
+      // Load configuration and merge with CLI options
+      const { updateOptions, formatter } = await this.prepareUpdateContext(options)
 
-      // Step 1: Planning updates
-      progressBar.update('正在检查包版本...', 1, 4)
-      const plan = await this.updateService.planUpdates(updateOptions)
-
-      // Step 2: Check if any updates found
-      progressBar.update('正在分析更新...', 2, 4)
+      // Plan updates
+      const plan = await this.planUpdates(progressBar, updateOptions)
 
+      // Handle empty plan
       if (!plan.updates.length) {
-        progressBar.succeed('所有依赖包都是最新的')
-        console.log(StyledText.iconSuccess('All dependencies are up to date!'))
+        progressBar.succeed(t('command.update.allUpToDate'))
+        cliOutput.print(StyledText.iconSuccess(t('command.update.allUpToDate')))
         return
       }
 
-      console.log(
-        StyledText.iconPackage(
-          `Found ${plan.totalUpdates} update${plan.totalUpdates === 1 ? '' : 's'} available`
-        )
-      )
-
-      // Interactive selection if enabled
-      let finalPlan = plan
-      if (options.interactive) {
-        finalPlan = await this.interactiveSelection(plan)
-        if (!finalPlan.updates.length) {
-          progressBar.warn('未选择任何更新')
-          console.log(StyledText.iconWarning('No updates selected'))
-          return
-        }
-      }
-
-      // AI batch analysis if enabled - analyze ALL packages in one request
-      if (options.ai) {
-        progressBar.update('🤖 正在进行 AI 批量分析...', 2.5, 4)
-        progressBar.stop()
+      progressBar.succeed(t('command.update.foundUpdates', { count: plan.totalUpdates }))
 
-        console.log(
-          chalk.blue(
-            `\n🤖 Running AI-powered batch analysis for ${finalPlan.updates.length} packages...`
-          )
-        )
-        console.log(chalk.gray('This analyzes all packages in a single request for efficiency.\n'))
-
-        try {
-          const aiResult = await this.performBatchAIAnalysis(finalPlan, options)
-
-          // Display AI analysis results
-          console.log(chalk.blue('\n📊 AI Analysis Results:'))
-          console.log(chalk.gray('─'.repeat(60)))
-          console.log(chalk.cyan(`Provider: ${aiResult.provider}`))
-          console.log(chalk.cyan(`Confidence: ${(aiResult.confidence * 100).toFixed(0)}%`))
-          console.log(chalk.cyan(`Processing time: ${aiResult.processingTimeMs}ms`))
-          console.log(chalk.gray('─'.repeat(60)))
-          console.log(chalk.yellow('\n📝 Summary:'))
-          console.log(aiResult.summary)
-
-          // Display recommendations for each package
-          if (aiResult.recommendations.length > 0) {
-            console.log(chalk.yellow('\n📦 Package Recommendations:'))
-            for (const rec of aiResult.recommendations) {
-              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
-
-              console.log(
-                `\n  ${actionIcon} ${chalk.bold(rec.package)}: ${rec.currentVersion} → ${rec.targetVersion}`
-              )
-              console.log(
-                `     Action: ${chalk.bold(rec.action.toUpperCase())} | Risk: ${riskColor(rec.riskLevel)}`
-              )
-              console.log(`     ${rec.reason}`)
-
-              if (rec.breakingChanges && rec.breakingChanges.length > 0) {
-                console.log(
-                  chalk.red(`     ⚠️  Breaking changes: ${rec.breakingChanges.join(', ')}`)
-                )
-              }
-              if (rec.securityFixes && rec.securityFixes.length > 0) {
-                console.log(chalk.green(`     🔒 Security fixes: ${rec.securityFixes.join(', ')}`))
-              }
-            }
-          }
-
-          // Display warnings
-          if (aiResult.warnings && aiResult.warnings.length > 0) {
-            console.log(chalk.yellow('\n⚠️  Warnings:'))
-            for (const warning of aiResult.warnings) {
-              console.log(chalk.yellow(`  - ${warning}`))
-            }
-          }
-
-          console.log(chalk.gray(`\n${'─'.repeat(60)}`))
-
-          // If there are critical/skip recommendations, warn the user
-          const skipRecommendations = aiResult.recommendations.filter((r) => r.action === 'skip')
-          if (skipRecommendations.length > 0 && !options.force) {
-            console.log(
-              chalk.red(
-                `\n⛔ AI recommends skipping ${skipRecommendations.length} package(s) due to risks.`
-              )
-            )
-            console.log(chalk.yellow('Use --force to override AI recommendations.\n'))
-          }
-        } catch (aiError) {
-          console.warn(
-            chalk.yellow('\n⚠️  AI batch analysis failed, continuing without AI insights:')
-          )
-          if (options.verbose) {
-            console.warn(chalk.gray(String(aiError)))
-          }
-        }
-
-        // Restart progress bar
-        progressBar = new ProgressBar({
-          text: '准备应用更新...',
-          total: 4,
-        })
-        progressBar.start('正在准备应用更新...')
-      }
+      // Process optional features and get final plan
+      const finalPlan = await this.processOptionalFeatures(plan, options)
+      if (!finalPlan) return
 
-      // Step 3: Apply updates
-      progressBar.update('正在准备应用更新...', 3, 4)
-
-      if (!options.dryRun) {
-        // Replace the progress bar with one for applying updates
-        progressBar.stop()
-        progressBar = new ProgressBar({
-          text: 'Applying updates...',
-          total: finalPlan.updates.length,
-        })
-        progressBar.start('正在应用更新...')
-
-        const result = await this.updateService.executeUpdates(finalPlan, updateOptions)
-        progressBar.succeed(`Applied ${finalPlan.updates.length} updates`)
-
-        console.log(formatter.formatUpdateResult(result))
-      } else {
-        progressBar.update('正在生成预览...', 4, 4)
-        progressBar.succeed('更新预览完成')
-        console.log(StyledText.iconInfo('Dry run - no changes made'))
-        console.log(JSON.stringify(finalPlan, null, 2))
-      }
+      // Execute updates or show dry-run preview
+      await this.executeUpdatesOrDryRun(finalPlan, updateOptions, options, formatter)
 
-      console.log(StyledText.iconComplete('Update process completed!'))
+      cliOutput.print(StyledText.iconComplete(t('command.update.processComplete')))
     } catch (error) {
-      if (progressBar) {
-        progressBar.fail('Operation failed')
-      }
+      this.handleExecuteError(error, progressBar, options)
+    }
+  }
 
-      if (error instanceof Error) {
-        console.error(StyledText.iconError(`Error: ${error.message}`))
-      } else {
-        console.error(StyledText.iconError('Unknown error occurred'))
+  /**
+   * Create and initialize progress bar
+   */
+  private createProgressBar(): ProgressBar {
+    initializeTheme('default')
+    const progressBar = new ProgressBar({
+      text: t('command.update.planningUpdates'),
+      total: 4,
+    })
+    progressBar.start(t('command.update.loadingConfig'))
+    return progressBar
+  }
+
+  /**
+   * Plan updates with progress tracking
+   */
+  private async planUpdates(
+    progressBar: ProgressBar,
+    updateOptions: UpdateOptions
+  ): Promise<UpdatePlan> {
+    progressBar.update(t('command.update.checkingVersions'), 1, 4)
+    const plan = await this.updateService.planUpdates(updateOptions)
+    progressBar.update(t('command.update.analyzingUpdates'), 2, 4)
+    return plan
+  }
+
+  /**
+   * Process optional features (changelog, interactive selection, AI analysis)
+   * @returns Final plan or null if user cancelled
+   */
+  private async processOptionalFeatures(
+    plan: UpdatePlan,
+    options: UpdateCommandOptions
+  ): Promise<UpdatePlan | null> {
+    // Display changelog if enabled (uses ChangelogHandler)
+    if (options.changelog) {
+      await this.changelogHandler.displayChangelogs(plan, options.verbose)
+    }
+
+    // Interactive selection if enabled
+    let finalPlan = plan
+    if (options.interactive) {
+      finalPlan = await this.interactiveSelection(plan)
+      if (!finalPlan.updates.length) {
+        cliOutput.print(StyledText.iconWarning(t('command.update.noUpdatesSelected')))
+        return null
       }
-      throw error
     }
+
+    // AI batch analysis if enabled (uses AIAnalysisHandler)
+    if (options.ai) {
+      await this.aiAnalysisHandler.analyzeAndDisplay(finalPlan, {
+        workspace: options.workspace,
+        provider: options.provider,
+        analysisType: options.analysisType,
+        skipCache: options.skipCache,
+        verbose: options.verbose,
+        force: options.force,
+      })
+    }
+
+    return finalPlan
+  }
+
+  /**
+   * Handle errors during execute()
+   * QUAL-007: Uses unified error handling from commandHelpers
+   */
+  private handleExecuteError(
+    error: unknown,
+    progressBar: ProgressBar,
+    options: UpdateCommandOptions
+  ): never | undefined {
+    // Use unified error handling - returns true if user cancellation was handled
+    const wasCancelled = handleCommandError(error, {
+      verbose: options.verbose,
+      progressBar,
+      errorMessage: 'Update command failed',
+      context: { options },
+    })
+
+    if (wasCancelled) {
+      return
+    }
+
+    throw error
   }
 
   /**
@@ -287,78 +229,83 @@ export class UpdateCommand {
   }
 
   /**
-   * Perform batch AI analysis for all packages in the update plan
-   * This analyzes ALL packages in a single AI request for efficiency
+   * Prepare update context by loading config and merging with CLI options
    */
-  private async performBatchAIAnalysis(plan: UpdatePlan, options: UpdateCommandOptions) {
-    const workspacePath = options.workspace || process.cwd()
-
-    // Create workspace service to get workspace info
-    const fileSystemService = new FileSystemService()
-    const workspaceRepository = new FileWorkspaceRepository(fileSystemService)
-    const workspaceService = new WorkspaceService(workspaceRepository)
-    const workspaceInfo = await workspaceService.getWorkspaceInfo(workspacePath)
-
-    // Create AI service
-    const aiService = new AIAnalysisService({
-      config: {
-        preferredProvider: options.provider === 'auto' ? 'auto' : options.provider,
-        cache: { enabled: !options.skipCache, ttl: 3600 },
-        fallback: { enabled: true, useRuleEngine: true },
-      },
-    })
-
-    // Convert all planned updates to PackageUpdateInfo format for batch analysis
-    const packages = plan.updates.map((update) => ({
-      name: update.packageName,
-      currentVersion: update.currentVersion,
-      targetVersion: update.newVersion,
-      updateType: update.updateType,
-      catalogName: update.catalogName,
-    }))
-
-    // Build workspace info for AI
-    const wsInfo = {
-      name: workspaceInfo.name,
-      path: workspaceInfo.path,
-      packageCount: workspaceInfo.packageCount,
-      catalogCount: workspaceInfo.catalogCount,
+  private async prepareUpdateContext(options: UpdateCommandOptions): Promise<{
+    config: PackageFilterConfig
+    updateOptions: UpdateOptions
+    formatter: OutputFormatter
+  }> {
+    // Load configuration using shared helper
+    const config = await loadConfiguration(options.workspace)
+
+    // Create output formatter using shared helper
+    const formatter = createFormatter(options.format, config, options.color !== false)
+
+    // Merge CLI options with configuration file settings using shared helpers
+    const updateOptions: UpdateOptions = {
+      workspacePath: options.workspace,
+      catalogName: options.catalog,
+      target: getEffectiveTarget(options.target, config.defaults?.target),
+      includePrerelease: mergeWithConfig(
+        options.prerelease,
+        config.defaults?.includePrerelease,
+        false
+      ),
+      include: getEffectivePatterns(options.include, config.include),
+      exclude: getEffectivePatterns(options.exclude, config.exclude),
+      interactive: mergeWithConfig(options.interactive, config.defaults?.interactive, false),
+      dryRun: mergeWithConfig(options.dryRun, config.defaults?.dryRun, false),
+      force: options.force ?? false,
+      createBackup: mergeWithConfig(options.createBackup, config.defaults?.createBackup, true),
+      noSecurity: options.noSecurity,
     }
 
-    // Perform single batch analysis for ALL packages
-    const result = await aiService.analyzeUpdates(packages, wsInfo, {
-      analysisType: options.analysisType || 'impact',
-      skipCache: options.skipCache,
-    })
-
-    return result
+    return { config, updateOptions, formatter }
   }
 
   /**
-   * Validate command options
+   * Execute updates or show dry-run preview
    */
-  static validateOptions(options: UpdateCommandOptions): string[] {
-    const errors: string[] = []
+  private async executeUpdatesOrDryRun(
+    finalPlan: UpdatePlan,
+    updateOptions: UpdateOptions,
+    options: UpdateCommandOptions,
+    formatter: OutputFormatter
+  ): Promise<void> {
+    if (!options.dryRun) {
+      // Create new progress bar for applying updates
+      const progressBar = new ProgressBar({
+        text: t('command.update.applyingUpdates'),
+        total: finalPlan.updates.length,
+      })
+      progressBar.start(t('command.update.applyingUpdates'))
 
-    // Validate format
-    if (options.format && !['table', 'json', 'yaml', 'minimal'].includes(options.format)) {
-      errors.push('Invalid format. Must be one of: table, json, yaml, minimal')
-    }
+      const result = await this.updateService.executeUpdates(finalPlan, updateOptions)
+      progressBar.succeed(t('command.update.appliedUpdates', { count: finalPlan.updates.length }))
 
-    // Validate target
-    if (
-      options.target &&
-      !['latest', 'greatest', 'minor', 'patch', 'newest'].includes(options.target)
-    ) {
-      errors.push('Invalid target. Must be one of: latest, greatest, minor, patch, newest')
-    }
+      cliOutput.print(formatter.formatUpdateResult(result))
 
-    // Interactive and dry-run conflict
-    if (options.interactive && options.dryRun) {
-      errors.push('Cannot use --interactive with --dry-run')
+      // Run pnpm install if enabled (default: true)
+      // ARCH-002: Delegated to InstallHandler
+      if (options.install !== false) {
+        await this.installHandler.runInstall(
+          updateOptions.workspacePath || process.cwd(),
+          options.verbose
+        )
+      }
+    } else {
+      cliOutput.print(StyledText.iconInfo(t('command.update.dryRunHint')))
+      cliOutput.print(formatter.formatUpdatePlan(finalPlan))
     }
+  }
 
-    return errors
+  /**
+   * Validate command options
+   * QUAL-002: Uses unified validator from validators/
+   */
+  static validateOptions(options: UpdateCommandOptions): string[] {
+    return errorsOnly(validateUpdateOptions)(options)
   }
 
   /**
@@ -382,14 +329,19 @@ Options:
   --prerelease           Include prerelease versions
   --include <pattern>    Include packages matching pattern (can be used multiple times)
   --exclude <pattern>    Exclude packages matching pattern (can be used multiple times)
-  --create-backup        Create backup files before updating
+  --create-backup        Create backup files before updating (default: true)
+  --no-backup            Skip creating backup before updating
+  --install              Run pnpm install after update (default: true)
+  --no-install           Skip pnpm install after update
   --verbose              Show detailed information
   --no-color             Disable colored output
 
 Examples:
-  pcu update                          # Update all catalogs
+  pcu update                          # Update all catalogs (with backup and pnpm install)
   pcu update --interactive            # Interactive update selection
   pcu update --dry-run               # Preview updates without applying
+  pcu update --no-backup             # Update without creating backup
+  pcu update --no-install            # Update catalogs without running pnpm install
   pcu update --catalog react17       # Update specific catalog
   pcu update --target minor          # Update to latest minor versions only
   pcu update --force                 # Force updates despite conflicts

package/src/cli/commands/workspaceCommand.ts

@@ -0,0 +1,73 @@
+/**
+ * Workspace Command
+ *
+ * CLI command to display workspace information and validation.
+ */
+
+import type { WorkspaceService } from '@pcu/core'
+import { CommandExitError } from '@pcu/utils'
+import { type OutputFormat, OutputFormatter } from '../formatters/outputFormatter.js'
+import { cliOutput } from '../utils/cliOutput.js'
+
+export interface WorkspaceCommandOptions {
+  workspace?: string
+  validate?: boolean
+  stats?: boolean
+  format?: OutputFormat
+  verbose?: boolean
+  color?: boolean
+}
+
+export class WorkspaceCommand {
+  constructor(private readonly workspaceService: WorkspaceService) {}
+
+  /**
+   * Execute the workspace command
+   */
+  async execute(options: WorkspaceCommandOptions = {}): Promise<void> {
+    const formatter = new OutputFormatter(options.format || 'table', options.color !== false)
+
+    if (options.validate) {
+      const report = await this.workspaceService.validateWorkspace(options.workspace)
+      const formattedOutput = formatter.formatValidationReport(report)
+      cliOutput.print(formattedOutput)
+      throw report.isValid
+        ? CommandExitError.success()
+        : CommandExitError.failure('Validation failed')
+    } else if (options.stats) {
+      const stats = await this.workspaceService.getWorkspaceStats(options.workspace)
+      const formattedOutput = formatter.formatWorkspaceStats(stats)
+      cliOutput.print(formattedOutput)
+      throw CommandExitError.success()
+    } else {
+      const info = await this.workspaceService.getWorkspaceInfo(options.workspace)
+      const formattedOutput = formatter.formatWorkspaceInfo(info)
+      cliOutput.print(formattedOutput)
+      throw CommandExitError.success()
+    }
+  }
+
+  /**
+   * Get command help text
+   */
+  static getHelpText(): string {
+    return `
+Workspace information and validation
+
+Usage:
+  pcu workspace [options]
+
+Options:
+  --validate           Validate workspace configuration
+  -s, --stats          Show workspace statistics
+  -f, --format <type>  Output format: table, json, yaml, minimal (default: table)
+  --verbose            Show detailed information
+
+Examples:
+  pcu workspace                  # Show basic workspace info
+  pcu workspace --validate       # Validate workspace configuration
+  pcu workspace --stats          # Show workspace statistics
+  pcu workspace --format json    # Output as JSON
+    `
+  }
+}