@kaitranntt/ccs 3.4.6 → 4.1.0

package/bin/utils/error-manager.js

@@ -1,9 +1,10 @@
 'use strict';
 
 const { colored } = require('./helpers');
+const { ERROR_CODES, getErrorDocUrl } = require('./error-codes');
 
 /**
- * Error types with structured messages
+ * Error types with structured messages (Legacy - kept for compatibility)
  */
 const ErrorTypes = {
   NO_CLAUDE_CLI: 'NO_CLAUDE_CLI',
@@ -18,18 +19,26 @@ const ErrorTypes = {
  * Enhanced error manager with context-aware messages
  */
 class ErrorManager {
+  /**
+   * Show error code and documentation URL
+   * @param {string} errorCode - Error code (e.g., E301)
+   */
+  static showErrorCode(errorCode) {
+    console.error(colored(`Error: ${errorCode}`, 'yellow'));
+    console.error(colored(getErrorDocUrl(errorCode), 'yellow'));
+    console.error('');
+  }
+
   /**
    * Show Claude CLI not found error
    */
   static showClaudeNotFound() {
     console.error('');
-    console.error(colored('╔══════════════════════════════════════════════════════════╗', 'red'));
-    console.error(colored('║  ERROR: Claude CLI not found                             ║', 'red'));
-    console.error(colored('╚══════════════════════════════════════════════════════════╝', 'red'));
+    console.error(colored('[X] Claude CLI not found', 'red'));
     console.error('');
-    console.error('CCS requires Claude CLI to be installed.');
+    console.error('CCS requires Claude CLI to be installed and available in PATH.');
     console.error('');
-    console.error(colored('Fix:', 'yellow'));
+    console.error(colored('Solutions:', 'yellow'));
     console.error('  1. Install Claude CLI:');
     console.error('     https://docs.claude.com/en/docs/claude-code/installation');
     console.error('');
@@ -40,8 +49,7 @@ class ErrorManager {
     console.error('  3. Custom path (if installed elsewhere):');
     console.error('     export CCS_CLAUDE_PATH="/path/to/claude"');
     console.error('');
-    console.error('Restart terminal after installation.');
-    console.error('');
+    this.showErrorCode(ERROR_CODES.CLAUDE_NOT_FOUND);
   }
 
   /**
@@ -52,9 +60,7 @@ class ErrorManager {
     const isClaudeSettings = settingsPath.includes('.claude') && settingsPath.endsWith('settings.json');
 
     console.error('');
-    console.error(colored('╔══════════════════════════════════════════════════════════╗', 'red'));
-    console.error(colored('║  ERROR: Settings file not found                          ║', 'red'));
-    console.error(colored('╚══════════════════════════════════════════════════════════╝', 'red'));
+    console.error(colored('[X] Settings file not found', 'red'));
     console.error('');
     console.error(`File: ${settingsPath}`);
     console.error('');
@@ -62,19 +68,20 @@ class ErrorManager {
     if (isClaudeSettings) {
       console.error('This file is auto-created when you login to Claude CLI.');
       console.error('');
-      console.error(colored('Fix (copy-paste):', 'yellow'));
+      console.error(colored('Solutions:', 'yellow'));
       console.error(`  echo '{}' > ${settingsPath}`);
       console.error('  claude /login');
       console.error('');
       console.error('Why: Newer Claude CLI versions require explicit login.');
     } else {
-      console.error(colored('Fix (copy-paste):', 'yellow'));
+      console.error(colored('Solutions:', 'yellow'));
       console.error('  npm install -g @kaitranntt/ccs --force');
       console.error('');
       console.error('This will recreate missing profile settings.');
     }
 
     console.error('');
+    this.showErrorCode(ERROR_CODES.CONFIG_INVALID_PROFILE);
   }
 
   /**
@@ -84,14 +91,12 @@ class ErrorManager {
    */
   static showInvalidConfig(configPath, errorDetail) {
     console.error('');
-    console.error(colored('╔══════════════════════════════════════════════════════════╗', 'red'));
-    console.error(colored('║  ERROR: Configuration invalid                            ║', 'red'));
-    console.error(colored('╚══════════════════════════════════════════════════════════╝', 'red'));
+    console.error(colored('[X] Configuration invalid', 'red'));
     console.error('');
     console.error(`File: ${configPath}`);
     console.error(`Issue: ${errorDetail}`);
     console.error('');
-    console.error(colored('Fix (copy-paste):', 'yellow'));
+    console.error(colored('Solutions:', 'yellow'));
     console.error('  # Backup corrupted file');
     console.error(`  mv ${configPath} ${configPath}.backup`);
     console.error('');
@@ -100,35 +105,37 @@ class ErrorManager {
     console.error('');
     console.error('Your profile settings will be preserved.');
     console.error('');
+    this.showErrorCode(ERROR_CODES.CONFIG_INVALID_JSON);
   }
 
   /**
    * Show profile not found error
    * @param {string} profileName - Requested profile name
    * @param {string[]} availableProfiles - List of available profiles
-   * @param {string} suggestion - Suggested profile name (fuzzy match)
+   * @param {string[]} suggestions - Suggested profile names (fuzzy match)
    */
-  static showProfileNotFound(profileName, availableProfiles, suggestion = null) {
+  static showProfileNotFound(profileName, availableProfiles, suggestions = []) {
     console.error('');
-    console.error(colored('╔══════════════════════════════════════════════════════════╗', 'red'));
-    console.error(colored(`║  ERROR: Profile '${profileName}' not found${' '.repeat(Math.max(0, 35 - profileName.length))}║`, 'red'));
-    console.error(colored('╚══════════════════════════════════════════════════════════╝', 'red'));
+    console.error(colored(`[X] Profile '${profileName}' not found`, 'red'));
     console.error('');
+
+    if (suggestions && suggestions.length > 0) {
+      console.error(colored('Did you mean:', 'yellow'));
+      suggestions.forEach(s => console.error(`  ${s}`));
+      console.error('');
+    }
+
     console.error(colored('Available profiles:', 'cyan'));
     availableProfiles.forEach(line => console.error(`  ${line}`));
     console.error('');
-    console.error(colored('Fix:', 'yellow'));
+    console.error(colored('Solutions:', 'yellow'));
     console.error('  # Use existing profile');
     console.error('  ccs <profile> "your prompt"');
     console.error('');
     console.error('  # Create new account profile');
     console.error('  ccs auth create <name>');
     console.error('');
-
-    if (suggestion) {
-      console.error(colored(`Did you mean: ${suggestion}`, 'yellow'));
-      console.error('');
-    }
+    this.showErrorCode(ERROR_CODES.PROFILE_NOT_FOUND);
   }
 
   /**
@@ -137,13 +144,11 @@ class ErrorManager {
    */
   static showPermissionDenied(path) {
     console.error('');
-    console.error(colored('╔══════════════════════════════════════════════════════════╗', 'red'));
-    console.error(colored('║  ERROR: Permission denied                                ║', 'red'));
-    console.error(colored('╚══════════════════════════════════════════════════════════╝', 'red'));
+    console.error(colored('[X] Permission denied', 'red'));
     console.error('');
     console.error(`Cannot write to: ${path}`);
     console.error('');
-    console.error(colored('Fix (copy-paste):', 'yellow'));
+    console.error(colored('Solutions:', 'yellow'));
     console.error('  # Fix ownership');
     console.error('  sudo chown -R $USER ~/.ccs ~/.claude');
     console.error('');
@@ -153,6 +158,7 @@ class ErrorManager {
     console.error('  # Retry installation');
     console.error('  npm install -g @kaitranntt/ccs --force');
     console.error('');
+    this.showErrorCode(ERROR_CODES.FS_CANNOT_WRITE_FILE);
   }
 }
 

package/bin/utils/helpers.js

@@ -63,10 +63,74 @@ function expandPath(pathStr) {
   return path.normalize(pathStr);
 }
 
+/**
+ * Calculate Levenshtein distance between two strings
+ * @param {string} a - First string
+ * @param {string} b - Second string
+ * @returns {number} Edit distance
+ */
+function levenshteinDistance(a, b) {
+  if (a.length === 0) return b.length;
+  if (b.length === 0) return a.length;
+
+  const matrix = [];
+
+  // Initialize first row and column
+  for (let i = 0; i <= b.length; i++) {
+    matrix[i] = [i];
+  }
+
+  for (let j = 0; j <= a.length; j++) {
+    matrix[0][j] = j;
+  }
+
+  // Fill in the rest of the matrix
+  for (let i = 1; i <= b.length; i++) {
+    for (let j = 1; j <= a.length; j++) {
+      if (b.charAt(i - 1) === a.charAt(j - 1)) {
+        matrix[i][j] = matrix[i - 1][j - 1];
+      } else {
+        matrix[i][j] = Math.min(
+          matrix[i - 1][j - 1] + 1, // substitution
+          matrix[i][j - 1] + 1,     // insertion
+          matrix[i - 1][j] + 1      // deletion
+        );
+      }
+    }
+  }
+
+  return matrix[b.length][a.length];
+}
+
+/**
+ * Find similar strings using fuzzy matching
+ * @param {string} target - Target string
+ * @param {string[]} candidates - List of candidate strings
+ * @param {number} maxDistance - Maximum edit distance (default: 2)
+ * @returns {string[]} Similar strings sorted by distance
+ */
+function findSimilarStrings(target, candidates, maxDistance = 2) {
+  const targetLower = target.toLowerCase();
+
+  const matches = candidates
+    .map(candidate => ({
+      name: candidate,
+      distance: levenshteinDistance(targetLower, candidate.toLowerCase())
+    }))
+    .filter(item => item.distance <= maxDistance && item.distance > 0)
+    .sort((a, b) => a.distance - b.distance)
+    .slice(0, 3)  // Show at most 3 suggestions
+    .map(item => item.name);
+
+  return matches;
+}
+
 
 module.exports = {
   colors,
   colored,
   error,
-  expandPath
+  expandPath,
+  levenshteinDistance,
+  findSimilarStrings
 };

package/bin/utils/progress-indicator.js

@@ -0,0 +1,111 @@
+'use strict';
+
+/**
+ * Simple Progress Indicator (no external dependencies)
+ *
+ * Features:
+ * - ASCII-only spinner frames (cross-platform compatible)
+ * - TTY detection (no spinners in pipes/logs)
+ * - Elapsed time display
+ * - CI environment detection
+ */
+
+class ProgressIndicator {
+  /**
+   * Create a progress indicator
+   * @param {string} message - Message to display
+   * @param {Object} options - Options
+   * @param {string[]} options.frames - Spinner frames (default: ASCII)
+   * @param {number} options.interval - Frame interval in ms (default: 80)
+   */
+  constructor(message, options = {}) {
+    this.message = message;
+    // ASCII-only frames for cross-platform compatibility
+    this.frames = options.frames || ['|', '/', '-', '\\'];
+    this.frameIndex = 0;
+    this.interval = null;
+    this.startTime = Date.now();
+
+    // TTY detection: only animate if stderr is TTY and not in CI
+    this.isTTY = process.stderr.isTTY === true && !process.env.CI && !process.env.NO_COLOR;
+  }
+
+  /**
+   * Start the spinner
+   */
+  start() {
+    if (!this.isTTY) {
+      // Non-TTY: just print message once
+      process.stderr.write(`[i] ${this.message}...\n`);
+      return;
+    }
+
+    // TTY: animate spinner
+    this.interval = setInterval(() => {
+      const frame = this.frames[this.frameIndex];
+      const elapsed = ((Date.now() - this.startTime) / 1000).toFixed(1);
+      process.stderr.write(`\r[${frame}] ${this.message}... (${elapsed}s)`);
+      this.frameIndex = (this.frameIndex + 1) % this.frames.length;
+    }, 80); // 12.5fps for smooth animation
+  }
+
+  /**
+   * Stop spinner with success message
+   * @param {string} message - Optional success message (defaults to original message)
+   */
+  succeed(message) {
+    this.stop();
+    const finalMessage = message || this.message;
+    const elapsed = ((Date.now() - this.startTime) / 1000).toFixed(1);
+
+    if (this.isTTY) {
+      // Clear spinner line and show success
+      process.stderr.write(`\r[OK] ${finalMessage} (${elapsed}s)\n`);
+    } else {
+      // Non-TTY: just show completion
+      process.stderr.write(`[OK] ${finalMessage}\n`);
+    }
+  }
+
+  /**
+   * Stop spinner with failure message
+   * @param {string} message - Optional failure message (defaults to original message)
+   */
+  fail(message) {
+    this.stop();
+    const finalMessage = message || this.message;
+
+    if (this.isTTY) {
+      // Clear spinner line and show failure
+      process.stderr.write(`\r[X] ${finalMessage}\n`);
+    } else {
+      // Non-TTY: just show failure
+      process.stderr.write(`[X] ${finalMessage}\n`);
+    }
+  }
+
+  /**
+   * Update spinner message (while running)
+   * @param {string} newMessage - New message to display
+   */
+  update(newMessage) {
+    this.message = newMessage;
+  }
+
+  /**
+   * Stop the spinner without showing success/failure
+   */
+  stop() {
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+
+      if (this.isTTY) {
+        // Clear the spinner line
+        process.stderr.write('\r\x1b[K');
+      }
+    }
+  }
+}
+
+module.exports = { ProgressIndicator };

package/bin/utils/prompt.js

@@ -0,0 +1,134 @@
+'use strict';
+
+const readline = require('readline');
+
+/**
+ * Interactive Prompt Utilities (NO external dependencies)
+ *
+ * Features:
+ * - TTY detection (auto-confirm in non-TTY)
+ * - --yes flag support for automation
+ * - --no-input flag support for CI
+ * - Safe defaults (N for destructive actions)
+ * - Input validation with retry
+ */
+
+class InteractivePrompt {
+  /**
+   * Ask for confirmation
+   * @param {string} message - Confirmation message
+   * @param {Object} options - Options
+   * @param {boolean} options.default - Default value (true=Yes, false=No)
+   * @returns {Promise<boolean>} User confirmation
+   */
+  static async confirm(message, options = {}) {
+    const { default: defaultValue = false } = options;
+
+    // Check for --yes flag (automation) - always returns true
+    if (process.env.CCS_YES === '1' || process.argv.includes('--yes') || process.argv.includes('-y')) {
+      return true;
+    }
+
+    // Check for --no-input flag (CI)
+    if (process.env.CCS_NO_INPUT === '1' || process.argv.includes('--no-input')) {
+      throw new Error('Interactive input required but --no-input specified');
+    }
+
+    // Non-TTY: use default
+    if (!process.stdin.isTTY) {
+      return defaultValue;
+    }
+
+    // Interactive prompt
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stderr,
+      terminal: true
+    });
+
+    const promptText = defaultValue
+      ? `${message} [Y/n]: `
+      : `${message} [y/N]: `;
+
+    return new Promise((resolve) => {
+      rl.question(promptText, (answer) => {
+        rl.close();
+
+        const normalized = answer.trim().toLowerCase();
+
+        // Empty answer: use default
+        if (normalized === '') {
+          resolve(defaultValue);
+          return;
+        }
+
+        // Valid answers
+        if (normalized === 'y' || normalized === 'yes') {
+          resolve(true);
+          return;
+        }
+
+        if (normalized === 'n' || normalized === 'no') {
+          resolve(false);
+          return;
+        }
+
+        // Invalid input: retry
+        console.error('[!] Please answer y or n');
+        resolve(InteractivePrompt.confirm(message, options));
+      });
+    });
+  }
+
+  /**
+   * Get text input from user
+   * @param {string} message - Prompt message
+   * @param {Object} options - Options
+   * @param {string} options.default - Default value
+   * @param {Function} options.validate - Validation function
+   * @returns {Promise<string>} User input
+   */
+  static async input(message, options = {}) {
+    const { default: defaultValue = '', validate = null } = options;
+
+    // Non-TTY: use default or error
+    if (!process.stdin.isTTY) {
+      if (defaultValue) {
+        return defaultValue;
+      }
+      throw new Error('Interactive input required but stdin is not a TTY');
+    }
+
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stderr,
+      terminal: true
+    });
+
+    const promptText = defaultValue
+      ? `${message} [${defaultValue}]: `
+      : `${message}: `;
+
+    return new Promise((resolve) => {
+      rl.question(promptText, (answer) => {
+        rl.close();
+
+        const value = answer.trim() || defaultValue;
+
+        // Validate input if validator provided
+        if (validate) {
+          const error = validate(value);
+          if (error) {
+            console.error(`[!] ${error}`);
+            resolve(InteractivePrompt.input(message, options));
+            return;
+          }
+        }
+
+        resolve(value);
+      });
+    });
+  }
+}
+
+module.exports = { InteractivePrompt };