pnpm-catalog-updates 1.0.3 → 1.1.2

package/src/cli/commands/checkCommand.ts

@@ -5,10 +5,26 @@
  * Provides detailed information about available updates.
  */
 
-import type { CatalogUpdateService, CheckOptions } from '@pcu/core'
-import { ConfigLoader } from '@pcu/utils'
-import { type OutputFormat, OutputFormatter } from '../formatters/outputFormatter.js'
+import type {
+  CatalogUpdateInfo,
+  CatalogUpdateService,
+  CheckOptions,
+  OutdatedDependencyInfo,
+  OutdatedReport,
+} from '@pcu/core'
+import { countUpdateTypesFromCatalogs } from '@pcu/core'
+import { CommandExitError, t } from '@pcu/utils'
+import type { OutputFormat } from '../formatters/outputFormatter.js'
 import { StyledText, ThemeManager } from '../themes/colorTheme.js'
+import { cliOutput } from '../utils/cliOutput.js'
+import {
+  getEffectivePatterns,
+  getEffectiveTarget,
+  handleCommandError,
+  initializeCommand,
+  mergeWithConfig,
+} from '../utils/commandHelpers.js'
+import { errorsOnly, validateCheckOptions } from '../validators/index.js'
 
 export interface CheckCommandOptions {
   workspace?: string
@@ -20,6 +36,9 @@ export interface CheckCommandOptions {
   exclude?: string[]
   verbose?: boolean
   color?: boolean
+  exitCode?: boolean
+  /** Skip security vulnerability checks */
+  noSecurity?: boolean
 }
 
 export class CheckCommand {
@@ -30,45 +49,30 @@ export class CheckCommand {
    */
   async execute(options: CheckCommandOptions = {}): Promise<void> {
     try {
-      // Initialize theme
-      ThemeManager.setTheme('default')
-
-      if (options.verbose) {
-        console.log(StyledText.iconAnalysis('Checking for outdated catalog dependencies'))
-        console.log(StyledText.muted(`Workspace: ${options.workspace || process.cwd()}`))
-
-        if (options.catalog) {
-          console.log(StyledText.muted(`Catalog: ${options.catalog}`))
-        }
-
-        if (options.target && options.target !== 'latest') {
-          console.log(StyledText.muted(`Target: ${options.target}`))
-        }
-
-        console.log('')
-      }
-
-      // 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
+      // Initialize command with shared helper (theme, config, formatter)
+      const { config, formatter } = await initializeCommand(options, {
+        showVerboseInfo: true,
+        verboseInfo: {
+          [t('command.check.catalogLabel', { catalog: '' }).replace(': ', '')]:
+            options.catalog || undefined,
+          [t('command.check.targetLabel', { target: '' }).replace(': ', '')]:
+            options.target && options.target !== 'latest' ? options.target : undefined,
+        },
+      })
+
+      // Build check options using shared helpers
       const checkOptions: CheckOptions = {
         workspacePath: options.workspace,
         catalogName: options.catalog,
-        target: options.target || config.defaults?.target || 'latest',
-        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,
+        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),
+        noSecurity: options.noSecurity,
       }
 
       // Execute check
@@ -76,117 +80,106 @@ export class CheckCommand {
 
       // Format and display results
       const formattedOutput = formatter.formatOutdatedReport(report)
-      console.log(formattedOutput)
+      cliOutput.print(formattedOutput)
 
       // Show summary
       if (options.verbose || options.format === 'table') {
         this.showSummary(report, options)
       }
 
-      // Always exit with 0 since this is just a check command
-      // and finding updates is not an error condition
-      process.exit(0)
-    } catch (error) {
-      console.error(StyledText.iconError('Error checking dependencies:'))
-      console.error(StyledText.error(String(error)))
+      // Exit with code 1 if --exit-code is set and updates are available (for CI/CD)
+      if (options.exitCode && report.hasUpdates) {
+        throw CommandExitError.failure('Updates available')
+      }
 
-      if (options.verbose && error instanceof Error) {
-        console.error(StyledText.muted('Stack trace:'))
-        console.error(StyledText.muted(error.stack || 'No stack trace available'))
+      // Otherwise exit with 0 since this is just a check command
+      throw CommandExitError.success()
+    } catch (error) {
+      // Re-throw CommandExitError as-is (success or controlled exit)
+      if (error instanceof CommandExitError) {
+        throw error
       }
 
-      process.exit(1)
+      // QUAL-007: Use unified error handling
+      handleCommandError(error, {
+        verbose: options.verbose,
+        errorMessage: 'Check dependencies failed',
+        context: { options },
+        errorDisplayKey: 'command.check.errorChecking',
+      })
+      throw CommandExitError.failure('Check command failed')
     }
   }
 
   /**
    * Show command summary
    */
-  private showSummary(report: any, _options: CheckCommandOptions): void {
+  private showSummary(report: OutdatedReport, _options: CheckCommandOptions): void {
     const lines: string[] = []
     const theme = ThemeManager.getTheme()
 
     if (!report.hasUpdates) {
-      lines.push(StyledText.iconSuccess('All catalog dependencies are up to date!'))
+      lines.push(StyledText.iconSuccess(t('info.noUpdatesFound')))
     } else {
-      lines.push(StyledText.iconInfo('Summary:'))
-      lines.push(`  • ${report.totalOutdated} outdated dependencies found`)
-      lines.push(`  • ${report.catalogs.length} catalogs checked`)
+      lines.push(StyledText.iconInfo(`${t('command.check.summary')}:`))
+      lines.push(`  • ${t('info.foundOutdated', { count: report.totalOutdated })}`)
+      lines.push(`  • ${t('command.check.catalogsChecked', { count: report.catalogs.length })}`)
 
       const totalPackages = report.catalogs.reduce(
-        (sum: number, cat: any) => sum + cat.totalPackages,
+        (sum: number, cat: CatalogUpdateInfo) => sum + cat.totalPackages,
         0
       )
-      lines.push(`  • ${totalPackages} total catalog entries`)
+      lines.push(`  • ${t('command.check.totalCatalogEntries', { count: totalPackages })}`)
 
       // Show breakdown by update type
-      const updateTypes = { major: 0, minor: 0, patch: 0 }
-
-      for (const catalog of report.catalogs) {
-        for (const dep of catalog.outdatedDependencies) {
-          updateTypes[dep.updateType as keyof typeof updateTypes]++
-        }
-      }
+      const updateTypes = countUpdateTypesFromCatalogs(report.catalogs)
 
       if (updateTypes.major > 0) {
-        lines.push(theme.major(`  • ${updateTypes.major} major updates`))
+        lines.push(
+          theme.major(`  • ${t('command.check.majorUpdates', { count: updateTypes.major })}`)
+        )
       }
       if (updateTypes.minor > 0) {
-        lines.push(theme.minor(`  • ${updateTypes.minor} minor updates`))
+        lines.push(
+          theme.minor(`  • ${t('command.check.minorUpdates', { count: updateTypes.minor })}`)
+        )
       }
       if (updateTypes.patch > 0) {
-        lines.push(theme.patch(`  • ${updateTypes.patch} patch updates`))
+        lines.push(
+          theme.patch(`  • ${t('command.check.patchUpdates', { count: updateTypes.patch })}`)
+        )
       }
 
       // Security updates
-      const securityUpdates = report.catalogs.reduce((sum: number, cat: any) => {
-        return sum + cat.outdatedDependencies.filter((dep: any) => dep.isSecurityUpdate).length
+      const securityUpdates = report.catalogs.reduce((sum: number, cat: CatalogUpdateInfo) => {
+        return (
+          sum +
+          cat.outdatedDependencies.filter((dep: OutdatedDependencyInfo) => dep.isSecurityUpdate)
+            .length
+        )
       }, 0)
 
       if (securityUpdates > 0) {
-        lines.push(StyledText.iconSecurity(`${securityUpdates} security updates`))
+        lines.push(StyledText.iconSecurity(t('info.securityUpdates', { count: securityUpdates })))
       }
 
       lines.push('')
-      lines.push(StyledText.iconUpdate('Run with --update to apply updates'))
+      lines.push(StyledText.iconUpdate(t('info.runWithUpdate')))
 
       if (updateTypes.major > 0) {
-        lines.push(StyledText.iconWarning('Major updates may contain breaking changes'))
+        lines.push(StyledText.iconWarning(t('info.majorWarning')))
       }
     }
 
-    console.log(lines.join('\n'))
+    cliOutput.print(lines.join('\n'))
   }
 
   /**
    * Validate command options
+   * QUAL-002: Uses unified validator from validators/
    */
   static validateOptions(options: CheckCommandOptions): string[] {
-    const errors: string[] = []
-
-    // Validate format
-    if (options.format && !['table', 'json', 'yaml', 'minimal'].includes(options.format)) {
-      errors.push('Invalid format. Must be one of: table, json, yaml, minimal')
-    }
-
-    // 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')
-    }
-
-    // Validate include/exclude patterns
-    if (options.include?.some((pattern) => !pattern.trim())) {
-      errors.push('Include patterns cannot be empty')
-    }
-
-    if (options.exclude?.some((pattern) => !pattern.trim())) {
-      errors.push('Exclude patterns cannot be empty')
-    }
-
-    return errors
+    return errorsOnly(validateCheckOptions)(options)
   }
 
   /**