pnpm-catalog-updates 1.0.3 → 1.1.0

package/src/cli/commands/__tests__/workspaceCommand.test.ts

@@ -0,0 +1,286 @@
+/**
+ * Workspace Command Tests
+ */
+
+import type { WorkspaceService } from '@pcu/core'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+// Use vi.hoisted to ensure mocks are available during vi.mock hoisting
+const mocks = vi.hoisted(() => {
+  // Create a mock CommandExitError class for instanceof checks
+  class MockCommandExitError extends Error {
+    public readonly exitCode: number
+    public readonly silent: boolean
+
+    constructor(exitCode: number, message?: string, silent = false) {
+      super(message || (exitCode === 0 ? 'Command completed successfully' : 'Command failed'))
+      this.name = 'CommandExitError'
+      this.exitCode = exitCode
+      this.silent = silent
+    }
+
+    static success(message?: string): MockCommandExitError {
+      return new MockCommandExitError(0, message, true)
+    }
+
+    static failure(message?: string): MockCommandExitError {
+      return new MockCommandExitError(1, message)
+    }
+
+    static withCode(code: number, message?: string): MockCommandExitError {
+      return new MockCommandExitError(code, message)
+    }
+  }
+
+  return {
+    CommandExitError: MockCommandExitError,
+  }
+})
+
+// Mock @pcu/utils - include CommandExitError for instanceof checks
+vi.mock('@pcu/utils', () => ({
+  CommandExitError: mocks.CommandExitError,
+  logger: {
+    error: vi.fn(),
+    warn: vi.fn(),
+    info: vi.fn(),
+    debug: vi.fn(),
+  },
+  t: (key: string) => key,
+}))
+
+// Mock ThemeManager and StyledText
+vi.mock('../../themes/colorTheme.js', () => ({
+  ThemeManager: {
+    setTheme: vi.fn(),
+    getTheme: vi.fn().mockReturnValue({
+      major: (text: string) => text,
+      minor: (text: string) => text,
+      patch: (text: string) => text,
+    }),
+  },
+  StyledText: {
+    iconAnalysis: (text: string) => `[analysis]${text}`,
+    iconSuccess: (text: string) => `[success]${text}`,
+    iconInfo: (text: string) => `[info]${text}`,
+    iconError: (text: string) => `[error]${text}`,
+    iconSecurity: (text: string) => `[security]${text}`,
+    iconUpdate: (text: string) => `[update]${text}`,
+    iconWarning: (text?: string) => (text ? `[warning]${text}` : '[warning]'),
+    muted: (text: string) => `[muted]${text}`,
+    error: (text: string) => `[error]${text}`,
+    bold: (text: string) => `[bold]${text}`,
+  },
+}))
+
+// Create a chainable chalk mock
+const createChalkMock = () => {
+  const createColorFn = (text: string) => text
+  const colorFn = Object.assign(createColorFn, {
+    bold: Object.assign((text: string) => text, {
+      cyan: (text: string) => text,
+      white: (text: string) => text,
+    }),
+    dim: Object.assign((text: string) => text, {
+      white: (text: string) => text,
+    }),
+    red: Object.assign((text: string) => text, {
+      bold: (text: string) => text,
+    }),
+    green: (text: string) => text,
+    yellow: (text: string) => text,
+    blue: (text: string) => text,
+    gray: (text: string) => text,
+    cyan: (text: string) => text,
+    white: (text: string) => text,
+  })
+  return colorFn
+}
+
+// Mock chalk
+vi.mock('chalk', () => ({
+  default: createChalkMock(),
+}))
+
+// Mock OutputFormatter - needs to be a proper class constructor
+vi.mock('../../formatters/outputFormatter.js', () => {
+  return {
+    OutputFormatter: class MockOutputFormatter {
+      formatValidationReport = vi.fn().mockReturnValue('Formatted validation')
+      formatWorkspaceStats = vi.fn().mockReturnValue('Formatted stats')
+      formatWorkspaceInfo = vi.fn().mockReturnValue('Formatted workspace info: default, react17')
+      formatMessage = vi.fn().mockImplementation((msg: string) => msg)
+      formatOutdatedReport = vi.fn()
+      formatUpdatePlan = vi.fn()
+      formatUpdateResult = vi.fn()
+      formatSecurityReport = vi.fn()
+      formatImpactAnalysis = vi.fn()
+    },
+  }
+})
+
+// Import after mock setup
+const { WorkspaceCommand } = await import('../workspaceCommand.js')
+
+describe('WorkspaceCommand', () => {
+  let command: InstanceType<typeof WorkspaceCommand>
+  let mockWorkspaceService: WorkspaceService
+  let consoleSpy: ReturnType<typeof vi.spyOn>
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+
+    // Mock console.log
+    consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
+
+    // Create mock workspace service
+    mockWorkspaceService = {
+      discoverWorkspace: vi.fn(),
+      getWorkspaceInfo: vi.fn().mockResolvedValue({
+        path: '/test/workspace',
+        name: 'test-workspace',
+        isValid: true,
+        hasPackages: true,
+        hasCatalogs: true,
+        packageCount: 5,
+        catalogCount: 2,
+        catalogNames: ['default', 'react17'],
+      }),
+      validateWorkspace: vi.fn().mockResolvedValue({
+        isValid: true,
+        errors: [],
+        warnings: [],
+        recommendations: [],
+        workspace: { isValid: true },
+        catalogs: { isValid: true, errors: [], warnings: [] },
+        packages: { isValid: true, errors: [], warnings: [] },
+      }),
+      getWorkspaceStats: vi.fn().mockResolvedValue({
+        workspace: { path: '/test/workspace', name: 'test-workspace' },
+        packages: { total: 5, withCatalogReferences: 3 },
+        catalogs: { total: 2, names: ['default', 'react17'], totalEntries: 30 },
+        dependencies: {
+          total: 50,
+          catalogManaged: 30,
+          catalogReferences: 25,
+          byType: {
+            dependencies: 25,
+            devDependencies: 15,
+            peerDependencies: 5,
+            optionalDependencies: 5,
+          },
+        },
+      }),
+      getCatalogs: vi.fn(),
+      getPackages: vi.fn(),
+      usesCatalogs: vi.fn(),
+      getPackagesUsingCatalog: vi.fn(),
+      findWorkspaces: vi.fn(),
+      checkHealth: vi.fn(),
+    } as unknown as WorkspaceService
+
+    // Create command instance
+    command = new WorkspaceCommand(mockWorkspaceService)
+  })
+
+  afterEach(() => {
+    consoleSpy.mockRestore()
+    vi.resetAllMocks()
+  })
+
+  describe('execute', () => {
+    it('should show workspace info by default', async () => {
+      try {
+        await command.execute({})
+      } catch (error) {
+        expect((error as { exitCode: number }).exitCode).toBe(0)
+      }
+      expect(mockWorkspaceService.getWorkspaceInfo).toHaveBeenCalled()
+      expect(consoleSpy).toHaveBeenCalled()
+    })
+
+    it('should show workspace info with specified workspace path', async () => {
+      try {
+        await command.execute({ workspace: '/custom/workspace' })
+      } catch {
+        // Expected to throw CommandExitError
+      }
+
+      expect(mockWorkspaceService.getWorkspaceInfo).toHaveBeenCalledWith('/custom/workspace')
+    })
+
+    it('should validate workspace when --validate flag is set', async () => {
+      try {
+        await command.execute({ validate: true })
+      } catch (error) {
+        expect((error as { exitCode: number }).exitCode).toBe(0)
+      }
+      expect(mockWorkspaceService.validateWorkspace).toHaveBeenCalled()
+    })
+
+    it('should return exit code 1 when validation fails', async () => {
+      mockWorkspaceService.validateWorkspace = vi.fn().mockResolvedValue({
+        isValid: false,
+        errors: ['Error 1'],
+        warnings: [],
+        recommendations: [],
+        workspace: { isValid: false },
+        catalogs: { isValid: false, errors: ['Catalog error'], warnings: [] },
+        packages: { isValid: true, errors: [], warnings: [] },
+      })
+
+      try {
+        await command.execute({ validate: true })
+        // Should not reach here
+        expect.fail('Should have thrown CommandExitError')
+      } catch (error) {
+        expect((error as { exitCode: number }).exitCode).toBe(1)
+      }
+    })
+
+    it('should show stats when --stats flag is set', async () => {
+      try {
+        await command.execute({ stats: true })
+      } catch (error) {
+        expect((error as { exitCode: number }).exitCode).toBe(0)
+      }
+      expect(mockWorkspaceService.getWorkspaceStats).toHaveBeenCalled()
+    })
+
+    it('should show catalog names in output', async () => {
+      try {
+        await command.execute({})
+      } catch {
+        // Expected to throw CommandExitError
+      }
+
+      // Check that console.log was called with catalog names
+      const calls = consoleSpy.mock.calls
+      const catalogNamesCall = calls.find(
+        (call) => String(call[0]).includes('default') && String(call[0]).includes('react17')
+      )
+      expect(catalogNamesCall).toBeDefined()
+    })
+
+    it('should work with different output formats', async () => {
+      try {
+        await command.execute({ format: 'json' })
+      } catch {
+        // Expected to throw CommandExitError
+      }
+
+      expect(mockWorkspaceService.getWorkspaceInfo).toHaveBeenCalled()
+    })
+  })
+
+  describe('getHelpText', () => {
+    it('should return help text', () => {
+      const helpText = WorkspaceCommand.getHelpText()
+
+      expect(helpText).toContain('Workspace information')
+      expect(helpText).toContain('--validate')
+      expect(helpText).toContain('--stats')
+      expect(helpText).toContain('--format')
+    })
+  })
+})

package/src/cli/commands/aiCommand.ts

@@ -0,0 +1,163 @@
+/**
+ * AI Command
+ *
+ * CLI command to check AI provider status and availability.
+ */
+
+import { AIAnalysisService, AIDetector, analysisCache } from '@pcu/core'
+import { t } from '@pcu/utils'
+import chalk from 'chalk'
+import { cliOutput } from '../utils/cliOutput.js'
+
+export interface AiCommandOptions {
+  status?: boolean
+  test?: boolean
+  cacheStats?: boolean
+  clearCache?: boolean
+}
+
+export class AiCommand {
+  /**
+   * Execute the AI command
+   */
+  async execute(options: AiCommandOptions = {}): Promise<void> {
+    if (options.clearCache) {
+      analysisCache.clear()
+      cliOutput.print(chalk.green(`✅ ${t('command.ai.cacheCleared')}`))
+      return
+    }
+
+    if (options.cacheStats) {
+      const stats = analysisCache.getStats()
+      cliOutput.print(chalk.blue(`📊 ${t('command.ai.cacheStats')}`))
+      cliOutput.print(chalk.gray('─────────────────────────────────'))
+      cliOutput.print(`  ${t('command.ai.totalEntries')}: ${chalk.cyan(stats.totalEntries)}`)
+      cliOutput.print(`  ${t('command.ai.cacheHits')}:    ${chalk.green(stats.hits)}`)
+      cliOutput.print(`  ${t('command.ai.cacheMisses')}:  ${chalk.yellow(stats.misses)}`)
+      cliOutput.print(
+        `  ${t('command.ai.hitRate')}:      ${chalk.cyan(`${(stats.hitRate * 100).toFixed(1)}%`)}`
+      )
+      return
+    }
+
+    if (options.test) {
+      await this.runTest()
+      return
+    }
+
+    // Default: show status
+    await this.showStatus()
+  }
+
+  /**
+   * Run AI analysis test
+   */
+  private async runTest(): Promise<void> {
+    cliOutput.print(chalk.blue(`🧪 ${t('command.ai.testingAnalysis')}`))
+
+    const aiService = new AIAnalysisService({
+      config: {
+        fallback: { enabled: true, useRuleEngine: true },
+      },
+    })
+
+    const testPackages = [
+      {
+        name: 'lodash',
+        currentVersion: '4.17.20',
+        targetVersion: '4.17.21',
+        updateType: 'patch' as const,
+      },
+    ]
+
+    const testWorkspaceInfo = {
+      name: 'test-workspace',
+      path: process.cwd(),
+      packageCount: 1,
+      catalogCount: 1,
+    }
+
+    try {
+      const result = await aiService.analyzeUpdates(testPackages, testWorkspaceInfo, {
+        analysisType: 'impact',
+      })
+      cliOutput.print(chalk.green(`✅ ${t('command.ai.testSuccess')}`))
+      cliOutput.print(chalk.gray('─────────────────────────────────'))
+      cliOutput.print(`  ${t('command.ai.providerLabel')} ${chalk.cyan(result.provider)}`)
+      cliOutput.print(
+        `  ${t('command.ai.confidenceLabel')} ${chalk.cyan(`${(result.confidence * 100).toFixed(0)}%`)}`
+      )
+      cliOutput.print(`  ${t('command.ai.summaryLabel')} ${result.summary}`)
+    } catch (error) {
+      cliOutput.print(chalk.yellow(`⚠️  ${t('command.ai.testFailed')}`))
+      cliOutput.print(chalk.gray(String(error)))
+    }
+  }
+
+  /**
+   * Show AI provider status
+   */
+  private async showStatus(): Promise<void> {
+    const aiDetector = new AIDetector()
+
+    cliOutput.print(chalk.blue(`🤖 ${t('command.ai.providerStatus')}`))
+    cliOutput.print(chalk.gray('─────────────────────────────────'))
+
+    const summary = await aiDetector.getDetectionSummary()
+    cliOutput.print(summary)
+
+    const providers = await aiDetector.detectAvailableProviders()
+    cliOutput.print('')
+    cliOutput.print(chalk.blue(`📋 ${t('command.ai.providerDetails')}`))
+    cliOutput.print(chalk.gray('─────────────────────────────────'))
+
+    for (const provider of providers) {
+      const statusIcon = provider.available ? chalk.green('✓') : chalk.red('✗')
+      const statusText = provider.available
+        ? chalk.green(t('command.ai.available'))
+        : chalk.gray(t('command.ai.notFound'))
+      const priorityText = chalk.gray(`(priority: ${provider.priority})`)
+
+      cliOutput.print(
+        `  ${statusIcon} ${chalk.cyan(provider.name)} - ${statusText} ${priorityText}`
+      )
+
+      if (provider.available && provider.path) {
+        cliOutput.print(chalk.gray(`      ${t('command.ai.pathLabel')} ${provider.path}`))
+      }
+      if (provider.available && provider.version) {
+        cliOutput.print(chalk.gray(`      ${t('command.ai.versionLabel')} ${provider.version}`))
+      }
+    }
+
+    const best = await aiDetector.getBestProvider()
+    if (best) {
+      cliOutput.print('')
+      cliOutput.print(chalk.green(`✨ ${t('command.ai.bestProvider', { provider: best.name })}`))
+    }
+  }
+
+  /**
+   * Get command help text
+   */
+  static getHelpText(): string {
+    return `
+Check AI provider status and availability
+
+Usage:
+  pcu ai [options]
+
+Options:
+  --status             Show status of all AI providers (default)
+  --test               Test AI analysis with a sample request
+  --cache-stats        Show AI analysis cache statistics
+  --clear-cache        Clear AI analysis cache
+
+Examples:
+  pcu ai                  # Show AI provider status
+  pcu ai --test           # Test AI analysis
+  pcu ai --cache-stats    # Show cache statistics
+  pcu ai --clear-cache    # Clear the cache
+    `
+  }
+}

package/src/cli/commands/analyzeCommand.ts

@@ -0,0 +1,219 @@
+/**
+ * Analyze Command
+ *
+ * CLI command to analyze the impact of updating a specific dependency.
+ * Provides AI-powered and basic analysis options.
+ *
+ * QUAL-002/QUAL-003: Refactored to use unified output helpers and reduce coupling.
+ */
+
+import type { AnalysisType, CatalogUpdateService, WorkspaceService } from '@pcu/core'
+import { AIAnalysisService, NpmRegistryService } from '@pcu/core'
+import { logger, t } from '@pcu/utils'
+import type { OutputFormat } from '../formatters/outputFormatter.js'
+import { StyledText } from '../themes/colorTheme.js'
+import { cliOutput } from '../utils/cliOutput.js'
+import { handleCommandError, initializeCommand } from '../utils/commandHelpers.js'
+import { errorsOnly, validateAnalyzeOptions } from '../validators/index.js'
+
+export interface AnalyzeCommandOptions {
+  workspace?: string
+  catalog?: string
+  format?: OutputFormat
+  ai?: boolean
+  provider?: string
+  analysisType?: AnalysisType
+  skipCache?: boolean
+  verbose?: boolean
+  color?: boolean
+}
+
+export class AnalyzeCommand {
+  /**
+   * QUAL-003: Optional services can be injected for testability.
+   * If not provided, default instances are created when needed.
+   */
+  constructor(
+    private readonly catalogUpdateService: CatalogUpdateService,
+    private readonly workspaceService: WorkspaceService,
+    private readonly registryService?: NpmRegistryService,
+    private readonly aiService?: AIAnalysisService
+  ) {}
+
+  /**
+   * Execute the analyze command
+   * QUAL-002/QUAL-003: Uses unified output helpers and reduced coupling
+   */
+  async execute(
+    packageName: string,
+    version: string | undefined,
+    options: AnalyzeCommandOptions = {}
+  ): Promise<void> {
+    // QUAL-005: Use shared command initialization
+    const { formatter } = await initializeCommand(options)
+
+    try {
+      // Auto-detect catalog if not specified
+      let catalog = options.catalog
+      if (!catalog) {
+        cliOutput.print(StyledText.muted(t('command.analyze.autoDetecting', { packageName })))
+        catalog =
+          (await this.catalogUpdateService.findCatalogForPackage(packageName, options.workspace)) ??
+          undefined
+        if (!catalog) {
+          logger.error('Package not found in any catalog', undefined, {
+            packageName,
+            workspace: options.workspace,
+          })
+          cliOutput.error(
+            StyledText.iconError(t('command.analyze.notFoundInCatalog', { packageName }))
+          )
+          cliOutput.print(StyledText.muted(t('command.analyze.specifyManually')))
+          throw new Error(t('command.analyze.notFoundInCatalog', { packageName }))
+        }
+        cliOutput.print(StyledText.muted(`   ${t('command.analyze.foundInCatalog', { catalog })}`))
+      }
+
+      // Get latest version if not specified
+      // QUAL-003: Use injected registry service or create default
+      let targetVersion = version
+      if (!targetVersion) {
+        const registryService = this.registryService ?? new NpmRegistryService()
+        targetVersion = (await registryService.getLatestVersion(packageName)).toString()
+      }
+
+      // Get basic impact analysis first
+      const analysis = await this.catalogUpdateService.analyzeImpact(
+        catalog,
+        packageName,
+        targetVersion,
+        options.workspace
+      )
+
+      // AI analysis is enabled by default (use --no-ai to disable)
+      const aiEnabled = options.ai !== false
+
+      if (aiEnabled) {
+        cliOutput.print(StyledText.iconAnalysis(t('command.analyze.runningAI')))
+
+        // QUAL-003: Use injected AI service or create default
+        const aiService =
+          this.aiService ??
+          new AIAnalysisService({
+            config: {
+              preferredProvider: options.provider === 'auto' ? 'auto' : options.provider,
+              cache: { enabled: !options.skipCache, ttl: 3600 },
+              fallback: { enabled: true, useRuleEngine: true },
+            },
+          })
+
+        // Get workspace info
+        const workspaceInfo = await this.workspaceService.getWorkspaceInfo(options.workspace)
+
+        // Build packages info for AI analysis
+        const packages = [
+          {
+            name: packageName,
+            currentVersion: analysis.currentVersion,
+            targetVersion: analysis.proposedVersion,
+            updateType: analysis.updateType,
+          },
+        ]
+
+        // Build workspace info for AI
+        const wsInfo = {
+          name: workspaceInfo.name,
+          path: workspaceInfo.path,
+          packageCount: workspaceInfo.packageCount,
+          catalogCount: workspaceInfo.catalogCount,
+        }
+
+        try {
+          const aiResult = await aiService.analyzeUpdates(packages, wsInfo, {
+            analysisType: options.analysisType || 'impact',
+            skipCache: options.skipCache,
+          })
+
+          // Format and display AI analysis result
+          const aiOutput = formatter.formatAIAnalysis(aiResult, analysis)
+          cliOutput.print(aiOutput)
+          return
+        } catch (aiError) {
+          logger.warn('AI analysis failed', {
+            error: aiError instanceof Error ? aiError.message : String(aiError),
+            packageName,
+            targetVersion,
+            provider: options.provider,
+          })
+          cliOutput.warn(StyledText.iconWarning(t('command.analyze.aiFailed')))
+          if (options.verbose) {
+            cliOutput.warn(StyledText.muted(String(aiError)))
+          }
+          // Fall back to basic analysis
+          const formattedOutput = formatter.formatImpactAnalysis(analysis)
+          cliOutput.print(formattedOutput)
+          return
+        }
+      } else {
+        // Standard analysis without AI
+        const formattedOutput = formatter.formatImpactAnalysis(analysis)
+        cliOutput.print(formattedOutput)
+      }
+    } catch (error) {
+      // QUAL-002: Use unified error handling
+      handleCommandError(error, { verbose: options.verbose })
+      throw error
+    }
+  }
+
+  /**
+   * Validate command arguments
+   */
+  static validateArgs(packageName: string): string[] {
+    const errors: string[] = []
+
+    if (!packageName || packageName.trim() === '') {
+      errors.push(t('validation.packageNameRequired'))
+    }
+
+    return errors
+  }
+
+  /**
+   * Validate command options
+   */
+  static validateOptions(options: AnalyzeCommandOptions): string[] {
+    return errorsOnly(validateAnalyzeOptions)(options)
+  }
+
+  /**
+   * Get command help text
+   */
+  static getHelpText(): string {
+    return `
+Analyze the impact of updating a specific dependency
+
+Usage:
+  pcu analyze <package> [version] [options]
+
+Arguments:
+  package              Package name to analyze
+  version              New version (default: latest)
+
+Options:
+  --catalog <name>     Catalog name (auto-detected if not specified)
+  -f, --format <type>  Output format: table, json, yaml, minimal (default: table)
+  --no-ai              Disable AI-powered analysis
+  --provider <name>    AI provider: auto, claude, gemini, codex (default: auto)
+  --analysis-type <t>  AI analysis type: impact, security, compatibility, recommend
+  --skip-cache         Skip AI analysis cache
+  --verbose            Show detailed information
+
+Examples:
+  pcu analyze lodash                    # Analyze update to latest version
+  pcu analyze lodash 4.18.0            # Analyze update to specific version
+  pcu analyze @types/node --no-ai      # Disable AI analysis
+  pcu analyze react --format json      # Output as JSON
+    `
+  }
+}