pnpm-catalog-updates 1.0.3 → 1.1.0

package/src/cli/interactive/interactivePrompts.ts

@@ -4,10 +4,12 @@
  * Provides smart prompts and auto-completion for CLI commands
  */
 
-import { FileSystemService } from '@pcu/core'
+import { FileSystemService, FileWorkspaceRepository, WorkspaceService } from '@pcu/core'
+import { logger, t } from '@pcu/utils'
 import chalk from 'chalk'
 import inquirer from 'inquirer'
 import { StyledText } from '../themes/colorTheme.js'
+import { cliOutput } from '../utils/cliOutput.js'
 
 export interface AutoCompleteOption {
   name: string
@@ -15,6 +17,37 @@ export interface AutoCompleteOption {
   description?: string
 }
 
+/**
+ * Package choice for selection prompts
+ */
+interface PackageChoice {
+  name: string
+  current: string
+  latest: string
+  type: string
+}
+
+/**
+ * Configuration wizard result
+ */
+interface ConfigurationWizardResult {
+  theme: string
+  interactive: boolean
+  backup: boolean
+  updateStrategy: string
+  timeout: number
+}
+
+/**
+ * Update impact preview
+ */
+interface UpdateImpact {
+  totalUpdates: number
+  riskLevel: string
+  affectedCount: number
+  securityUpdates: number
+}
+
 export class InteractivePrompts {
   private fsService: FileSystemService
 
@@ -25,9 +58,7 @@ export class InteractivePrompts {
   /**
    * Interactive package selection with search
    */
-  async selectPackages(
-    packages: Array<{ name: string; current: string; latest: string; type: string }>
-  ): Promise<string[]> {
+  async selectPackages(packages: PackageChoice[]): Promise<string[]> {
     if (packages.length === 0) {
       return []
     }
@@ -41,12 +72,12 @@ export class InteractivePrompts {
     const answers = await inquirer.prompt({
       type: 'checkbox',
       name: 'selectedPackages',
-      message: StyledText.iconPackage('Select packages to update:'),
+      message: StyledText.iconPackage(t('prompt.selectPackages')),
       choices,
       pageSize: 15,
       validate: (input: unknown) => {
         const selected = input as string[]
-        return selected.length > 0 || 'Please select at least one package'
+        return selected.length > 0 || t('prompt.selectAtLeastOne')
       },
     })
 
@@ -66,7 +97,7 @@ export class InteractivePrompts {
     }
 
     const choices = [
-      { name: 'All catalogs', value: 'all' },
+      { name: t('prompt.allCatalogs'), value: 'all' },
       ...catalogs.map((name) => ({ name, value: name })),
     ]
 
@@ -74,7 +105,7 @@ export class InteractivePrompts {
       {
         type: 'list',
         name: 'catalog',
-        message: StyledText.iconCatalog('Select catalog to update:'),
+        message: StyledText.iconCatalog(t('prompt.selectCatalog')),
         choices,
         pageSize: 10,
       },
@@ -88,18 +119,18 @@ export class InteractivePrompts {
    */
   async selectUpdateStrategy(): Promise<string> {
     const strategies = [
-      { name: 'Latest (recommended)', value: 'latest' },
-      { name: 'Greatest (highest version)', value: 'greatest' },
-      { name: 'Minor (non-breaking)', value: 'minor' },
-      { name: 'Patch (bug fixes only)', value: 'patch' },
-      { name: 'Newest (latest release)', value: 'newest' },
+      { name: t('prompt.strategyLatest'), value: 'latest' },
+      { name: t('prompt.strategyGreatest'), value: 'greatest' },
+      { name: t('prompt.strategyMinor'), value: 'minor' },
+      { name: t('prompt.strategyPatch'), value: 'patch' },
+      { name: t('prompt.strategyNewest'), value: 'newest' },
     ]
 
     const answers = await inquirer.prompt([
       {
         type: 'list',
         name: 'strategy',
-        message: StyledText.iconUpdate('Select update strategy:'),
+        message: StyledText.iconUpdate(t('prompt.selectUpdateStrategy')),
         choices: strategies,
       },
     ])
@@ -111,16 +142,16 @@ export class InteractivePrompts {
    * Confirm dangerous operations
    */
   async confirmDangerousOperation(operation: string, details?: string): Promise<boolean> {
-    console.log('')
+    cliOutput.print('')
     if (details) {
-      console.log(chalk.yellow('⚠️  Warning:'), details)
+      cliOutput.print(chalk.yellow(`⚠️ ${t('prompt.warning')}`), details)
     }
 
     const answers = await inquirer.prompt([
       {
         type: 'confirm',
         name: 'confirmed',
-        message: StyledText.warning(`Are you sure you want to ${operation}?`),
+        message: StyledText.warning(t('prompt.confirmOperation', { operation })),
         default: false,
       },
     ])
@@ -133,7 +164,7 @@ export class InteractivePrompts {
    */
   async autoCompletePackage(
     packages: string[],
-    message: string = 'Select package:'
+    message: string = t('prompt.selectPackage')
   ): Promise<string> {
     const answers = await inquirer.prompt([
       {
@@ -154,15 +185,15 @@ export class InteractivePrompts {
   async selectWorkspacePath(): Promise<string> {
     const currentDir = process.cwd()
     const choices = [
-      { name: `Current directory (${currentDir})`, value: currentDir },
-      { name: 'Browse for directory...', value: 'browse' },
+      { name: t('prompt.currentDirectory', { path: currentDir }), value: currentDir },
+      { name: t('prompt.browseDirectory'), value: 'browse' },
     ]
 
     const answers = await inquirer.prompt([
       {
         type: 'list',
         name: 'path',
-        message: StyledText.icon('📁', 'Select workspace directory:'),
+        message: t('prompt.selectWorkspace'),
         choices,
       },
     ])
@@ -180,10 +211,10 @@ export class InteractivePrompts {
   private async browseDirectory(currentPath = process.cwd()): Promise<string> {
     const directoryNames = await this.fsService.listDirectories(currentPath)
     const choices = [
-      { name: '.. (parent directory)', value: '..' },
-      { name: `. (current: ${currentPath})`, value: '.' },
+      { name: t('prompt.parentDirectory'), value: '..' },
+      { name: t('prompt.currentDirectory', { path: currentPath }), value: '.' },
       ...directoryNames.map((name: string) => ({
-        name: `📁 ${name}`,
+        name: `[dir] ${name}`,
         value: `${currentPath}/${name}`,
       })),
     ]
@@ -192,7 +223,7 @@ export class InteractivePrompts {
       {
         type: 'list',
         name: 'selected',
-        message: `Browse: ${currentPath}`,
+        message: t('prompt.browsePath', { path: currentPath }),
         choices,
         pageSize: 15,
       },
@@ -222,7 +253,7 @@ export class InteractivePrompts {
         {
           type: 'confirm',
           name: 'useThis',
-          message: `Use ${answers.selected} as workspace?`,
+          message: t('prompt.useAsWorkspace', { path: answers.selected }),
           default: true,
         },
       ])
@@ -235,21 +266,42 @@ export class InteractivePrompts {
     return this.browseDirectory(answers.selected)
   }
 
+  /**
+   * Simple theme selection with cancel option
+   */
+  async selectTheme(): Promise<string | null> {
+    const answers = await inquirer.prompt({
+      type: 'list',
+      name: 'theme',
+      message: t('prompt.selectTheme'),
+      choices: [
+        { name: t('prompt.themeDefault'), value: 'default' },
+        { name: t('prompt.themeModern'), value: 'modern' },
+        { name: t('prompt.themeMinimal'), value: 'minimal' },
+        { name: t('prompt.themeNeon'), value: 'neon' },
+        { name: t('prompt.cancel'), value: null },
+      ],
+      default: 'default',
+    })
+
+    return answers.theme
+  }
+
   /**
    * Multi-step configuration wizard
    */
-  async configurationWizard(): Promise<any> {
-    console.log(chalk.bold.blue('\n🧙‍♂️ Configuration Wizard\n'))
+  async configurationWizard(): Promise<ConfigurationWizardResult> {
+    cliOutput.print(chalk.bold.blue(`\n${t('prompt.configWizard')}\n`))
 
     const themeAnswer = await inquirer.prompt({
       type: 'list',
       name: 'theme',
-      message: 'Select color theme:',
+      message: t('prompt.selectTheme'),
       choices: [
-        { name: 'Default - Balanced colors', value: 'default' },
-        { name: 'Modern - Vibrant colors', value: 'modern' },
-        { name: 'Minimal - Clean and simple', value: 'minimal' },
-        { name: 'Neon - High contrast', value: 'neon' },
+        { name: t('prompt.themeDefault'), value: 'default' },
+        { name: t('prompt.themeModern'), value: 'modern' },
+        { name: t('prompt.themeMinimal'), value: 'minimal' },
+        { name: t('prompt.themeNeon'), value: 'neon' },
       ],
       default: 'default',
     })
@@ -257,25 +309,25 @@ export class InteractivePrompts {
     const interactiveAnswer = await inquirer.prompt({
       type: 'confirm',
       name: 'interactive',
-      message: 'Enable interactive mode by default?',
+      message: t('prompt.enableInteractive'),
       default: true,
     })
 
     const backupAnswer = await inquirer.prompt({
       type: 'confirm',
       name: 'backup',
-      message: 'Create backups before updates?',
+      message: t('prompt.createBackups'),
       default: true,
     })
 
     const strategyAnswer = await inquirer.prompt({
       type: 'list',
       name: 'updateStrategy',
-      message: 'Default update strategy:',
+      message: t('prompt.defaultStrategy'),
       choices: [
-        { name: 'Latest stable versions', value: 'latest' },
-        { name: 'Minor updates (non-breaking)', value: 'minor' },
-        { name: 'Patch updates (bug fixes)', value: 'patch' },
+        { name: t('prompt.strategyLatestStable'), value: 'latest' },
+        { name: t('prompt.strategyMinorUpdates'), value: 'minor' },
+        { name: t('prompt.strategyPatchUpdates'), value: 'patch' },
       ],
       default: 'latest',
     })
@@ -283,20 +335,20 @@ export class InteractivePrompts {
     const timeoutAnswer = await inquirer.prompt({
       type: 'number',
       name: 'timeout',
-      message: 'Network timeout (seconds):',
+      message: t('prompt.networkTimeout'),
       default: 30,
       validate: (input: number | undefined) => {
-        if (input === undefined) return 'Timeout is required'
-        return input > 0 || 'Timeout must be positive'
+        if (input === undefined) return t('prompt.timeoutRequired')
+        return input > 0 || t('prompt.timeoutPositive')
       },
     })
 
-    const answers = {
-      ...themeAnswer,
-      ...interactiveAnswer,
-      ...backupAnswer,
-      ...strategyAnswer,
-      ...timeoutAnswer,
+    const answers: ConfigurationWizardResult = {
+      theme: themeAnswer.theme as string,
+      interactive: interactiveAnswer.interactive as boolean,
+      backup: backupAnswer.backup as boolean,
+      updateStrategy: strategyAnswer.updateStrategy as string,
+      timeout: timeoutAnswer.timeout as number,
     }
 
     return answers
@@ -305,25 +357,27 @@ export class InteractivePrompts {
   /**
    * Impact preview before update
    */
-  async previewImpact(impact: any): Promise<boolean> {
-    console.log(chalk.bold.blue('\n📊 Impact Preview\n'))
+  async previewImpact(impact: UpdateImpact): Promise<boolean> {
+    cliOutput.print(chalk.bold.blue(`\n${t('prompt.impactPreview')}\n`))
 
     // Display impact summary
-    console.log(`Packages to update: ${impact.totalUpdates}`)
-    console.log(`Risk level: ${impact.riskLevel}`)
-    console.log(`Affected packages: ${impact.affectedCount}`)
+    cliOutput.print(t('prompt.packagesToUpdate', { count: impact.totalUpdates }))
+    cliOutput.print(t('prompt.riskLevel', { level: impact.riskLevel }))
+    cliOutput.print(t('prompt.affectedPackages', { count: impact.affectedCount }))
 
     if (impact.securityUpdates > 0) {
-      console.log(StyledText.iconSecurity(`${impact.securityUpdates} security updates`))
+      cliOutput.print(
+        StyledText.iconSecurity(t('prompt.securityUpdatesCount', { count: impact.securityUpdates }))
+      )
     }
 
-    console.log('')
+    cliOutput.print('')
 
     const answers = await inquirer.prompt([
       {
         type: 'confirm',
         name: 'proceed',
-        message: 'Proceed with update?',
+        message: t('prompt.proceedWithUpdate'),
         default: true,
       },
     ])
@@ -336,17 +390,17 @@ export class InteractivePrompts {
    */
   async errorRecoveryOptions(error: string): Promise<string> {
     const options = [
-      { name: 'Retry operation', value: 'retry' },
-      { name: 'Skip this package', value: 'skip' },
-      { name: 'Continue with remaining', value: 'continue' },
-      { name: 'Abort operation', value: 'abort' },
+      { name: t('prompt.retryOperation'), value: 'retry' },
+      { name: t('prompt.skipPackage'), value: 'skip' },
+      { name: t('prompt.continueRemaining'), value: 'continue' },
+      { name: t('prompt.abortOperation'), value: 'abort' },
     ]
 
     const answers = await inquirer.prompt([
       {
         type: 'list',
         name: 'action',
-        message: StyledText.iconError(`Error: ${error}`),
+        message: StyledText.iconError(t('prompt.errorMessage', { error })),
         choices: options,
       },
     ])
@@ -373,8 +427,8 @@ export class InteractivePrompts {
   /**
    * Format package choice for display
    */
-  private formatPackageChoice(pkg: any): string {
-    const updateTypeColor: Record<string, any> = {
+  private formatPackageChoice(pkg: PackageChoice): string {
+    const updateTypeColor: Record<string, (text: string) => string> = {
       major: chalk.red,
       minor: chalk.yellow,
       patch: chalk.green,
@@ -390,6 +444,15 @@ export class InteractivePrompts {
  * Auto-completion utilities
  */
 export class AutoCompleteManager {
+  /**
+   * Get workspace service instance for auto-completion
+   */
+  private static getWorkspaceService(): WorkspaceService {
+    const fsService = new FileSystemService()
+    const repository = new FileWorkspaceRepository(fsService)
+    return new WorkspaceService(repository)
+  }
+
   static async suggestWorkspaces(current: string): Promise<string[]> {
     const suggestions: string[] = []
 
@@ -411,58 +474,101 @@ export class AutoCompleteManager {
             suggestions.push(dir)
           }
         })
-      } catch {
-        // Ignore errors
+      } catch (error) {
+        // ERR-002: Log glob errors for debugging instead of silently ignoring
+        logger.debug('Failed to glob workspace pattern', { pattern, error })
       }
     }
 
     return suggestions.filter((s) => s.toLowerCase().includes(current.toLowerCase()))
   }
 
+  /**
+   * STUB-001: Suggest catalog names from current workspace
+   */
   static async suggestCatalogs(): Promise<string[]> {
-    return []
+    try {
+      const workspaceService = AutoCompleteManager.getWorkspaceService()
+      const catalogs = await workspaceService.getCatalogs()
+      return catalogs.map((catalog) => catalog.name)
+    } catch (error) {
+      // Workspace not found or other error - return empty for auto-complete
+      logger.debug('Failed to get catalogs for auto-complete', { error })
+      return []
+    }
   }
 
+  /**
+   * STUB-001: Suggest package names from current workspace catalogs
+   */
   static async suggestPackages(): Promise<string[]> {
-    return []
+    try {
+      const workspaceService = AutoCompleteManager.getWorkspaceService()
+      const catalogs = await workspaceService.getCatalogs()
+
+      // Collect all unique package names from all catalogs
+      const packageNames = new Set<string>()
+      for (const catalog of catalogs) {
+        for (const pkgName of catalog.packages) {
+          packageNames.add(pkgName)
+        }
+      }
+
+      return Array.from(packageNames).sort()
+    } catch (error) {
+      // Workspace not found or other error - return empty for auto-complete
+      logger.debug('Failed to get packages for auto-complete', { error })
+      return []
+    }
   }
 }
 
+/**
+ * Command builder options type
+ */
+interface CommandBuilderOptions {
+  format?: string
+  interactive?: boolean
+  dryRun?: boolean
+  backup?: boolean
+  prerelease?: boolean
+}
+
 /**
  * Interactive command builder
  */
 export class InteractiveCommandBuilder {
   static async buildCommand(): Promise<{
     command: string
-    options: Record<string, any>
+    options: CommandBuilderOptions
   }> {
     const baseCommand = await inquirer.prompt([
       {
         type: 'list',
         name: 'command',
-        message: 'What would you like to do?',
+        message: t('prompt.whatToDo'),
         choices: [
-          { name: 'Check for updates', value: 'check' },
-          { name: 'Update dependencies', value: 'update' },
-          { name: 'Analyze impact', value: 'analyze' },
-          { name: 'Show workspace info', value: 'workspace' },
+          { name: t('prompt.checkForUpdates'), value: 'check' },
+          { name: t('prompt.updateDependencies'), value: 'update' },
+          { name: t('prompt.analyzeImpact'), value: 'analyze' },
+          { name: t('prompt.showWorkspaceInfo'), value: 'workspace' },
         ],
       },
     ])
 
-    const options: Record<string, any> = {}
+    const options: CommandBuilderOptions = {}
 
     // Common options
     const common = await inquirer.prompt([
       {
         type: 'list',
         name: 'format',
-        message: 'Output format:',
+        message: t('prompt.outputFormat'),
         choices: [
-          { name: 'Table (rich)', value: 'table' },
-          { name: 'JSON', value: 'json' },
-          { name: 'YAML', value: 'yaml' },
-          { name: 'Minimal', value: 'minimal' },
+          { name: t('prompt.formatTable'), value: 'table' },
+          { name: t('prompt.formatJson'), value: 'json' },
+          { name: t('prompt.formatYaml'), value: 'yaml' },
+          { name: t('prompt.formatMinimal'), value: 'minimal' },
         ],
         default: 'table',
       },
@@ -477,19 +583,19 @@ export class InteractiveCommandBuilder {
           {
             type: 'confirm',
             name: 'interactive',
-            message: 'Interactive mode?',
+            message: t('prompt.interactiveMode'),
             default: true,
           },
           {
             type: 'confirm',
             name: 'dryRun',
-            message: 'Dry run mode?',
+            message: t('prompt.dryRunMode'),
             default: false,
           },
           {
             type: 'confirm',
             name: 'backup',
-            message: 'Create backup?',
+            message: t('prompt.createBackup'),
             default: true,
           },
         ])
@@ -502,7 +608,7 @@ export class InteractiveCommandBuilder {
           {
             type: 'confirm',
             name: 'includePrerelease',
-            message: 'Include pre-release versions?',
+            message: t('prompt.includePrerelease'),
             default: false,
           },
         ])

package/src/cli/interactive/optionUtils.ts

@@ -0,0 +1,89 @@
+/**
+ * Option Utilities
+ *
+ * Common utilities for merging CLI options with defaults.
+ */
+
+/**
+ * Option types supported by the merge utility
+ */
+type OptionType = 'string' | 'boolean' | 'number' | 'array' | 'optional-string'
+
+/**
+ * Schema definition for a single option
+ */
+interface OptionSchema<T = unknown> {
+  type: OptionType
+  default: T
+}
+
+/**
+ * Schema for a complete set of options
+ */
+export type OptionsSchema<T> = {
+  [K in keyof T]: OptionSchema<T[K]>
+}
+
+/**
+ * Merge a single value with its default based on type
+ */
+function mergeValue<T>(value: unknown, schema: OptionSchema<T>): T {
+  switch (schema.type) {
+    case 'string':
+      return ((value as string) || schema.default) as T
+
+    case 'optional-string':
+      return ((value as string) || undefined) as T
+
+    case 'boolean':
+      return ((value as boolean | undefined) ?? schema.default) as T
+
+    case 'number':
+      return ((value as number | undefined) ?? schema.default) as T
+
+    case 'array':
+      return ((value as T) || schema.default) as T
+
+    default:
+      return (value ?? schema.default) as T
+  }
+}
+
+/**
+ * Merge existing options with defaults based on schema
+ *
+ * @param existing - Options provided by user/CLI
+ * @param schema - Schema defining types and defaults
+ * @returns Merged options with proper types
+ */
+export function mergeOptions<T extends Record<string, unknown>>(
+  existing: Record<string, unknown>,
+  schema: OptionsSchema<T>
+): T {
+  const result = {} as T
+
+  for (const key of Object.keys(schema) as (keyof T)[]) {
+    const optionSchema = schema[key]
+    const value = existing[key as string]
+    result[key] = mergeValue(value, optionSchema)
+  }
+
+  return result
+}
+
+/**
+ * Common option schemas reused across commands
+ */
+export const commonSchemas = {
+  catalog: { type: 'optional-string' as const, default: undefined as string | undefined },
+  format: { type: 'string' as const, default: 'table' as string },
+  target: { type: 'string' as const, default: 'latest' as string },
+  prerelease: { type: 'boolean' as const, default: false as boolean },
+  include: { type: 'array' as const, default: [] as string[] },
+  exclude: { type: 'array' as const, default: [] as string[] },
+  force: { type: 'boolean' as const, default: false as boolean },
+  dryRun: { type: 'boolean' as const, default: false as boolean },
+  ai: { type: 'boolean' as const, default: false as boolean },
+  provider: { type: 'string' as const, default: 'auto' as string },
+  analysisType: { type: 'string' as const, default: 'impact' as string },
+}