pnpm-catalog-updates 1.0.2 → 1.1.0

package/src/cli/themes/colorTheme.ts

@@ -4,6 +4,7 @@
  * Provides consistent color schemes and styling across the CLI
  */
 
+import { t } from '@pcu/utils'
 import chalk from 'chalk'
 
 export interface ColorTheme {
@@ -289,27 +290,27 @@ export class StyledText {
   }
 
   static iconInfo(text?: string): string {
-    return StyledText.icon('ℹ️', text)
+    return StyledText.icon('[i]', text)
   }
 
   static iconPackage(text?: string): string {
-    return StyledText.icon('📦', text)
+    return StyledText.icon('[PKG]', text)
   }
 
   static iconCatalog(text?: string): string {
-    return StyledText.icon('📋', text)
+    return StyledText.icon('[CAT]', text)
   }
 
   static iconUpdate(text?: string): string {
-    return StyledText.icon('🔄', text)
+    return StyledText.icon('[UPD]', text)
   }
 
   static iconSecurity(text?: string): string {
-    return StyledText.icon('🔒', text)
+    return StyledText.icon('[SEC]', text)
   }
 
   static iconAnalysis(text?: string): string {
-    return StyledText.icon('🔍', text)
+    return StyledText.icon('[*]', text)
   }
 
   static iconCheck(text?: string): string {
@@ -317,27 +318,53 @@ export class StyledText {
   }
 
   static iconProgress(text?: string): string {
-    return StyledText.icon('⏳', text)
+    return StyledText.icon('[...]', text)
   }
 
   static iconComplete(text?: string): string {
-    return StyledText.icon('🎉', text)
+    return StyledText.icon('[OK]', text)
   }
+
+  // Text formatting
+  static bold(text: string): string {
+    return chalk.bold(text)
+  }
+
+  static dim(text: string): string {
+    return chalk.dim(text)
+  }
+
+  static italic(text: string): string {
+    return chalk.italic(text)
+  }
+
+  static underline(text: string): string {
+    return chalk.underline(text)
+  }
+}
+
+/**
+ * Chalk-like color function type
+ */
+type ColorFunction = {
+  (text: string): string
+  bold: (text: string) => string
+  dim: (text: string) => string
 }
 
 /**
  * Table styling utilities
  */
 export class TableStyles {
-  static createHeaderStyle(color: any) {
+  static createHeaderStyle(color: ColorFunction) {
     return (text: string) => color.bold(text)
   }
 
-  static createBorderStyle(color: any) {
+  static createBorderStyle(color: ColorFunction) {
     return (text: string) => color.dim(text)
   }
 
-  static createCellStyle(color: any) {
+  static createCellStyle(color: (text: string) => string) {
     return (text: string) => color(text)
   }
 }
@@ -349,7 +376,7 @@ export interface ThemeConfig {
   name: string
   colors: Partial<ColorTheme>
   icons: Record<string, string>
-  styles: Record<string, any>
+  styles: Record<string, string | number | boolean>
 }
 
 /**
@@ -358,22 +385,22 @@ export interface ThemeConfig {
 export const themePresets = {
   development: {
     name: 'development',
-    description: 'Bright colors for development environments',
+    description: t('theme.preset.development'),
     theme: 'modern',
   },
   production: {
     name: 'production',
-    description: 'Subtle colors for production environments',
+    description: t('theme.preset.production'),
     theme: 'minimal',
   },
   presentation: {
     name: 'presentation',
-    description: 'High contrast colors for presentations',
+    description: t('theme.preset.presentation'),
     theme: 'neon',
   },
   default: {
     name: 'default',
-    description: 'Balanced colors for general use',
+    description: t('theme.preset.default'),
     theme: 'default',
   },
 }

package/src/cli/utils/cliOutput.ts

@@ -0,0 +1,118 @@
+/**
+ * CLI Output Service
+ *
+ * Provides a unified interface for CLI output, making it easier to test
+ * and control output behavior. This separates user-facing output from
+ * internal logging (which should use the logger from @pcu/utils).
+ *
+ * Usage:
+ * - Use cliOutput for user-facing messages (formatted, styled)
+ * - Use logger from @pcu/utils for internal logging (debug, errors)
+ */
+
+/**
+ * Interface for CLI output operations
+ * Allows mocking in tests without console hijacking
+ */
+export interface ICliOutput {
+  /** Print standard output (user-facing messages) */
+  print(...args: unknown[]): void
+  /** Print error output (user-facing errors) */
+  error(...args: unknown[]): void
+  /** Print warning output (user-facing warnings) */
+  warn(...args: unknown[]): void
+  /** Print info output (alias for print) */
+  info(...args: unknown[]): void
+}
+
+/**
+ * Default CLI output implementation using console
+ */
+class CliOutputImpl implements ICliOutput {
+  print(...args: unknown[]): void {
+    console.log(...args)
+  }
+
+  error(...args: unknown[]): void {
+    console.error(...args)
+  }
+
+  warn(...args: unknown[]): void {
+    console.warn(...args)
+  }
+
+  info(...args: unknown[]): void {
+    console.log(...args)
+  }
+}
+
+/**
+ * Singleton instance for CLI output
+ * Can be replaced in tests via setCliOutput()
+ */
+let cliOutputInstance: ICliOutput = new CliOutputImpl()
+
+/**
+ * Get the current CLI output instance
+ */
+export function getCliOutput(): ICliOutput {
+  return cliOutputInstance
+}
+
+/**
+ * Set a custom CLI output instance (useful for testing)
+ */
+export function setCliOutput(output: ICliOutput): void {
+  cliOutputInstance = output
+}
+
+/**
+ * Reset CLI output to the default implementation
+ */
+export function resetCliOutput(): void {
+  cliOutputInstance = new CliOutputImpl()
+}
+
+/**
+ * Default CLI output instance for convenience
+ */
+export const cliOutput: ICliOutput = {
+  print: (...args: unknown[]) => cliOutputInstance.print(...args),
+  error: (...args: unknown[]) => cliOutputInstance.error(...args),
+  warn: (...args: unknown[]) => cliOutputInstance.warn(...args),
+  info: (...args: unknown[]) => cliOutputInstance.info(...args),
+}
+
+/**
+ * Create a mock CLI output for testing
+ * Returns the mock and arrays of captured output
+ */
+export function createMockCliOutput(): {
+  mock: ICliOutput
+  prints: unknown[][]
+  errors: unknown[][]
+  warns: unknown[][]
+  infos: unknown[][]
+  clear: () => void
+} {
+  const prints: unknown[][] = []
+  const errors: unknown[][] = []
+  const warns: unknown[][] = []
+  const infos: unknown[][] = []
+
+  const mock: ICliOutput = {
+    print: (...args: unknown[]) => prints.push(args),
+    error: (...args: unknown[]) => errors.push(args),
+    warn: (...args: unknown[]) => warns.push(args),
+    info: (...args: unknown[]) => infos.push(args),
+  }
+
+  const clear = () => {
+    prints.length = 0
+    errors.length = 0
+    warns.length = 0
+    infos.length = 0
+  }
+
+  return { mock, prints, errors, warns, infos, clear }
+}

package/src/cli/utils/commandHelpers.ts

@@ -0,0 +1,249 @@
+/**
+ * Command Helpers
+ *
+ * Shared utilities for CLI command initialization and common patterns.
+ * Reduces code duplication across check, update, and other commands.
+ */
+
+import type { PackageFilterConfig, TranslationKey } from '@pcu/utils'
+import { ConfigLoader, Logger, logger, t } from '@pcu/utils'
+import { type OutputFormat, OutputFormatter } from '../formatters/outputFormatter.js'
+import { StyledText, ThemeManager } from '../themes/colorTheme.js'
+import { cliOutput } from './cliOutput.js'
+
+/**
+ * Common command options shared across multiple commands
+ */
+export interface CommonCommandOptions {
+  workspace?: string
+  format?: OutputFormat
+  color?: boolean
+  verbose?: boolean
+}
+
+/**
+ * Command context created during initialization
+ */
+export interface CommandContext {
+  config: PackageFilterConfig
+  formatter: OutputFormatter
+  workspacePath: string
+}
+
+/**
+ * Command initialization options
+ */
+export interface InitOptions {
+  /** Theme to use (default: 'default') */
+  theme?: 'default' | 'minimal' | 'neon' | 'modern'
+  /** Whether to show verbose initialization info */
+  showVerboseInfo?: boolean
+  /** Additional info to show in verbose mode */
+  verboseInfo?: Record<string, string | undefined>
+}
+
+/**
+ * Initialize theme for a command
+ * Common pattern used in: checkCommand, updateCommand, securityCommand, etc.
+ */
+export function initializeTheme(
+  theme: 'default' | 'minimal' | 'neon' | 'modern' = 'default'
+): void {
+  ThemeManager.setTheme(theme)
+}
+
+/**
+ * Load and merge configuration with CLI options
+ * Common pattern used in: checkCommand, updateCommand, watchCommand
+ */
+export async function loadConfiguration(workspacePath?: string): Promise<PackageFilterConfig> {
+  const effectivePath = workspacePath || process.cwd()
+  return ConfigLoader.loadConfig(effectivePath)
+}
+
+/**
+ * Create an output formatter with common configuration
+ * Common pattern used in: checkCommand, updateCommand, analyzeCommand, workspaceCommand
+ */
+export function createFormatter(
+  format: OutputFormat | undefined,
+  config: PackageFilterConfig,
+  colorEnabled: boolean = true
+): OutputFormatter {
+  const effectiveFormat = format || config.defaults?.format || 'table'
+  return new OutputFormatter(effectiveFormat as OutputFormat, colorEnabled)
+}
+
+/**
+ * Initialize a command with common setup
+ * Combines theme initialization, config loading, and formatter creation
+ */
+export async function initializeCommand(
+  options: CommonCommandOptions,
+  initOptions: InitOptions = {}
+): Promise<CommandContext> {
+  // Initialize theme
+  initializeTheme(initOptions.theme)
+
+  // Set logger to debug level when verbose mode is enabled
+  if (options.verbose) {
+    Logger.setGlobalLevel('debug')
+  }
+
+  // Show verbose initialization info
+  if (initOptions.showVerboseInfo && options.verbose) {
+    showVerboseInfo(options, initOptions.verboseInfo)
+  }
+
+  // Load configuration
+  const workspacePath = options.workspace || process.cwd()
+  const config = await loadConfiguration(workspacePath)
+
+  // Create formatter
+  const formatter = createFormatter(options.format, config, options.color !== false)
+
+  return {
+    config,
+    formatter,
+    workspacePath,
+  }
+}
+
+/**
+ * Show verbose initialization information
+ * QUAL-012: Use unified output helpers (cliOutput, StyledText)
+ */
+function showVerboseInfo(
+  options: CommonCommandOptions,
+  additionalInfo?: Record<string, string | undefined>
+): void {
+  cliOutput.print(StyledText.iconAnalysis(t('info.checkingUpdates')))
+  cliOutput.print(
+    StyledText.muted(`${t('command.workspace.title')}: ${options.workspace || process.cwd()}`)
+  )
+
+  if (additionalInfo) {
+    for (const [key, value] of Object.entries(additionalInfo)) {
+      if (value !== undefined) {
+        cliOutput.print(StyledText.muted(`${key}: ${value}`))
+      }
+    }
+  }
+
+  cliOutput.print('')
+}
+
+/**
+ * Error handling options for commands
+ * QUAL-007: Unified error handling configuration
+ */
+export interface ErrorHandlingOptions {
+  /** Whether to show verbose information (stack trace) */
+  verbose?: boolean
+  /** Progress bar to stop/fail on error */
+  progressBar?: { stop: () => void; fail: (msg: string) => void }
+  /** Custom error message for logging */
+  errorMessage?: string
+  /** Additional context for logging */
+  context?: Record<string, unknown>
+  /** Custom i18n key for failed progress message */
+  failedProgressKey?: string
+  /** Custom i18n key for error display */
+  errorDisplayKey?: string
+}
+
+/**
+ * Check if error is a user cancellation (e.g., Ctrl+C)
+ */
+export function isUserCancellation(error: unknown): boolean {
+  return (
+    error instanceof Error &&
+    (error.name === 'ExitPromptError' || error.message.includes('force closed'))
+  )
+}
+
+/**
+ * Handle command error with consistent logging
+ * QUAL-007: Unified error handling pattern for all commands
+ *
+ * @returns true if error was handled as user cancellation (command should return gracefully)
+ */
+export function handleCommandError(
+  error: Error | unknown,
+  options: ErrorHandlingOptions = {}
+): boolean {
+  const {
+    verbose = false,
+    progressBar,
+    errorMessage = 'Command failed',
+    context,
+    failedProgressKey = 'progress.operationFailed',
+    errorDisplayKey,
+  } = options
+
+  // Handle user cancellation gracefully (Ctrl+C)
+  if (isUserCancellation(error)) {
+    progressBar?.stop()
+    cliOutput.print(StyledText.iconWarning(t('cli.cancelled')))
+    return true
+  }
+
+  // Log error with context
+  logger.error(errorMessage, error instanceof Error ? error : undefined, context)
+
+  // Fail progress bar if provided
+  if (progressBar) {
+    progressBar.fail(t(failedProgressKey as TranslationKey))
+  }
+
+  // Display error to user
+  const displayKey = errorDisplayKey || 'cli.error'
+  cliOutput.error(StyledText.iconError(t(displayKey as TranslationKey)))
+  cliOutput.error(StyledText.error(String(error)))
+
+  // Show stack trace in verbose mode
+  if (verbose && error instanceof Error) {
+    cliOutput.error(StyledText.muted(t('common.stackTrace')))
+    cliOutput.error(StyledText.muted(error.stack || t('common.noStackTrace')))
+  }
+
+  return false
+}
+
+/**
+ * Merge CLI options with config defaults
+ * Returns the effective value prioritizing CLI > config > fallback
+ */
+export function mergeWithConfig<T>(
+  cliValue: T | undefined,
+  configValue: T | undefined,
+  fallback: T
+): T {
+  return cliValue ?? configValue ?? fallback
+}
+
+/**
+ * Get effective target from options and config
+ */
+export function getEffectiveTarget(
+  optionTarget: string | undefined,
+  configTarget: string | undefined
+): 'latest' | 'greatest' | 'minor' | 'patch' | 'newest' {
+  return (optionTarget || configTarget || 'latest') as
+    | 'latest'
+    | 'greatest'
+    | 'minor'
+    | 'patch'
+    | 'newest'
+}
+
+/**
+ * Get effective include/exclude patterns
+ * CLI options take priority over config file
+ */
+export function getEffectivePatterns(
+  cliPatterns: string[] | undefined,
+  configPatterns: string[] | undefined
+): string[] | undefined {
+  return cliPatterns?.length ? cliPatterns : configPatterns
+}