@kaitranntt/ccs 3.4.6 → 3.5.0

package/VERSION

@@ -1 +1 @@
-3.4.6
+3.5.0

package/bin/auth/auth-commands.js

@@ -1,10 +1,14 @@
 'use strict';
 
 const { spawn } = require('child_process');
+const fs = require('fs');
+const path = require('path');
 const ProfileRegistry = require('./profile-registry');
 const InstanceManager = require('../management/instance-manager');
 const { colored } = require('../utils/helpers');
 const { detectClaudeCli } = require('../utils/claude-detector');
+const { InteractivePrompt } = require('../utils/prompt');
+const CCS_VERSION = require('../../package.json').version;
 
 /**
  * Auth Commands (Simplified)
@@ -45,7 +49,10 @@ class AuthCommands {
     console.log(`  ${colored('ccs "review code"', 'yellow')}                        # Use default profile`);
     console.log('');
     console.log(colored('Options:', 'cyan'));
-    console.log(`  ${colored('--force', 'yellow')}                   Allow overwriting existing profile`);
+    console.log(`  ${colored('--force', 'yellow')}                   Allow overwriting existing profile (create)`);
+    console.log(`  ${colored('--yes, -y', 'yellow')}                 Skip confirmation prompts (remove)`);
+    console.log(`  ${colored('--json', 'yellow')}                    Output in JSON format (list, show)`);
+    console.log(`  ${colored('--verbose', 'yellow')}                 Show additional details (list)`);
     console.log('');
     console.log(colored('Note:', 'cyan'));
     console.log(`  By default, ${colored('ccs', 'yellow')} uses Claude CLI defaults from ~/.claude/`);
@@ -159,12 +166,37 @@ class AuthCommands {
    */
   async handleList(args) {
     const verbose = args.includes('--verbose');
+    const json = args.includes('--json');
 
     try {
       const profiles = this.registry.getAllProfiles();
       const defaultProfile = this.registry.getDefaultProfile();
       const profileNames = Object.keys(profiles);
 
+      // JSON output mode
+      if (json) {
+        const output = {
+          version: CCS_VERSION,
+          profiles: profileNames.map(name => {
+            const profile = profiles[name];
+            const isDefault = name === defaultProfile;
+            const instancePath = this.instanceMgr.getInstancePath(name);
+
+            return {
+              name: name,
+              type: profile.type || 'account',
+              is_default: isDefault,
+              created: profile.created,
+              last_used: profile.last_used || null,
+              instance_path: instancePath
+            };
+          })
+        };
+        console.log(JSON.stringify(output, null, 2));
+        return;
+      }
+
+      // Human-readable output
       if (profileNames.length === 0) {
         console.log(colored('No account profiles found', 'yellow'));
         console.log('');
@@ -234,11 +266,12 @@ class AuthCommands {
    */
   async handleShow(args) {
     const profileName = args.find(arg => !arg.startsWith('--'));
+    const json = args.includes('--json');
 
     if (!profileName) {
       console.error('[X] Profile name is required');
       console.log('');
-      console.log(`Usage: ${colored('ccs auth show <profile>', 'yellow')}`);
+      console.log(`Usage: ${colored('ccs auth show <profile> [--json]', 'yellow')}`);
       process.exit(1);
     }
 
@@ -246,12 +279,41 @@ class AuthCommands {
       const profile = this.registry.getProfile(profileName);
       const defaultProfile = this.registry.getDefaultProfile();
       const isDefault = profileName === defaultProfile;
+      const instancePath = this.instanceMgr.getInstancePath(profileName);
+
+      // Count sessions
+      let sessionCount = 0;
+      try {
+        const sessionsDir = path.join(instancePath, 'session-env');
+        if (fs.existsSync(sessionsDir)) {
+          const files = fs.readdirSync(sessionsDir);
+          sessionCount = files.filter(f => f.endsWith('.json')).length;
+        }
+      } catch (e) {
+        // Ignore errors counting sessions
+      }
 
+      // JSON output mode
+      if (json) {
+        const output = {
+          name: profileName,
+          type: profile.type || 'account',
+          is_default: isDefault,
+          created: profile.created,
+          last_used: profile.last_used || null,
+          instance_path: instancePath,
+          session_count: sessionCount
+        };
+        console.log(JSON.stringify(output, null, 2));
+        return;
+      }
+
+      // Human-readable output
       console.log(colored(`Profile: ${profileName}`, 'bold'));
       console.log('');
       console.log(`  Type: ${profile.type || 'account'}`);
       console.log(`  Default: ${isDefault ? 'Yes' : 'No'}`);
-      console.log(`  Instance: ${this.instanceMgr.getInstancePath(profileName)}`);
+      console.log(`  Instance: ${instancePath}`);
       console.log(`  Created: ${new Date(profile.created).toLocaleString()}`);
 
       if (profile.last_used) {
@@ -273,13 +335,12 @@ class AuthCommands {
    * @param {Array} args - Command arguments
    */
   async handleRemove(args) {
-    const profileName = args.find(arg => !arg.startsWith('--'));
-    const force = args.includes('--force');
+    const profileName = args.find(arg => !arg.startsWith('--') && !arg.startsWith('-'));
 
     if (!profileName) {
       console.error('[X] Profile name is required');
       console.log('');
-      console.log(`Usage: ${colored('ccs auth remove <profile> [--force]', 'yellow')}`);
+      console.log(`Usage: ${colored('ccs auth remove <profile> [--yes]', 'yellow')}`);
       process.exit(1);
     }
 
@@ -288,15 +349,39 @@ class AuthCommands {
       process.exit(1);
     }
 
-    // Require --force for safety
-    if (!force) {
-      console.error('[X] Removal requires --force flag for safety');
+    try {
+      // Get instance path and session count for impact display
+      const instancePath = this.instanceMgr.getInstancePath(profileName);
+      let sessionCount = 0;
+
+      try {
+        const sessionsDir = path.join(instancePath, 'session-env');
+        if (fs.existsSync(sessionsDir)) {
+          const files = fs.readdirSync(sessionsDir);
+          sessionCount = files.filter(f => f.endsWith('.json')).length;
+        }
+      } catch (e) {
+        // Ignore errors counting sessions
+      }
+
+      // Display impact
+      console.log('');
+      console.log(`Profile '${colored(profileName, 'cyan')}' will be permanently deleted.`);
+      console.log(`  Instance path: ${instancePath}`);
+      console.log(`  Sessions: ${sessionCount} conversation${sessionCount !== 1 ? 's' : ''}`);
       console.log('');
-      console.log(`Run: ${colored(`ccs auth remove ${profileName} --force`, 'yellow')}`);
-      process.exit(1);
-    }
 
-    try {
+      // Interactive confirmation (or --yes flag)
+      const confirmed = await InteractivePrompt.confirm(
+        'Delete this profile?',
+        { default: false } // Default to NO (safe)
+      );
+
+      if (!confirmed) {
+        console.log('[i] Cancelled');
+        process.exit(0);
+      }
+
       // Delete instance
       this.instanceMgr.deleteInstance(profileName);
 

package/bin/auth/profile-detector.js

@@ -3,6 +3,7 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const { findSimilarStrings } = require('../utils/helpers');
 
 /**
  * Profile Detector
@@ -85,12 +86,16 @@ class ProfileDetector {
       };
     }
 
-    // Not found
-    throw new Error(
-      `Profile not found: ${profileName}\n` +
-      `Available profiles:\n` +
-      this._listAvailableProfiles()
-    );
+    // Not found - generate suggestions
+    const allProfiles = this.getAllProfiles();
+    const allProfileNames = [...allProfiles.settings, ...allProfiles.accounts];
+    const suggestions = findSimilarStrings(profileName, allProfileNames);
+
+    const error = new Error(`Profile not found: ${profileName}`);
+    error.profileName = profileName;
+    error.suggestions = suggestions;
+    error.availableProfiles = this._listAvailableProfiles();
+    throw error;
   }
 
   /**

package/bin/ccs.js

@@ -130,6 +130,7 @@ function handleHelpCommand() {
   console.log(colored('Flags:', 'cyan'));
   console.log(`  ${colored('-h, --help', 'yellow')}                  Show this help message`);
   console.log(`  ${colored('-v, --version', 'yellow')}               Show version and installation info`);
+  console.log(`  ${colored('--shell-completion', 'yellow')}          Install shell auto-completion`);
   console.log('');
 
   // Configuration
@@ -149,6 +150,19 @@ function handleHelpCommand() {
   console.log('  Note: Commands, skills, and agents are symlinked across all profiles');
   console.log('');
 
+  // Examples
+  console.log(colored('Examples:', 'cyan'));
+  console.log('  Quick start:');
+  console.log(`    ${colored('$ ccs', 'yellow')}                        # Use default account`);
+  console.log(`    ${colored('$ ccs glm "implement API"', 'yellow')}    # Cost-optimized model`);
+  console.log('');
+  console.log('  Multi-account workflow:');
+  console.log(`    ${colored('$ ccs auth create work', 'yellow')}       # Create work profile`);
+  console.log(`    ${colored('$ ccs work "review PR"', 'yellow')}       # Use work account`);
+  console.log('');
+  console.log(`  For more: ${colored('https://github.com/kaitranntt/ccs#usage', 'cyan')}`);
+  console.log('');
+
   // Uninstall
   console.log(colored('Uninstall:', 'yellow'));
   console.log('  npm:          npm uninstall -g @kaitranntt/ccs');
@@ -241,6 +255,10 @@ async function execClaudeWithProxy(claudeCli, profileName, args) {
   });
 
   // 3. Wait for proxy ready signal (with timeout)
+  const { ProgressIndicator } = require('./utils/progress-indicator');
+  const spinner = new ProgressIndicator('Starting GLMT proxy');
+  spinner.start();
+
   let port;
   try {
     port = await new Promise((resolve, reject) => {
@@ -268,8 +286,11 @@ async function execClaudeWithProxy(claudeCli, profileName, args) {
         }
       });
     });
+
+    spinner.succeed(`GLMT proxy ready on port ${port}`);
   } catch (error) {
-    console.error('[X] Failed to start GLMT proxy:', error.message);
+    spinner.fail('Failed to start GLMT proxy');
+    console.error('[X] Error:', error.message);
     console.error('');
     console.error('Possible causes:');
     console.error('  1. Port conflict (unlikely with random port)');
@@ -341,6 +362,58 @@ async function execClaudeWithProxy(claudeCli, profileName, args) {
   });
 }
 
+/**
+ * Handle shell completion installation
+ */
+async function handleShellCompletionCommand(args) {
+  const { ShellCompletionInstaller } = require('./utils/shell-completion');
+  const { colored } = require('./utils/helpers');
+
+  console.log(colored('Shell Completion Installer', 'bold'));
+  console.log('');
+
+  // Parse flags
+  let targetShell = null;
+  if (args.includes('--bash')) targetShell = 'bash';
+  else if (args.includes('--zsh')) targetShell = 'zsh';
+  else if (args.includes('--fish')) targetShell = 'fish';
+  else if (args.includes('--powershell')) targetShell = 'powershell';
+
+  try {
+    const installer = new ShellCompletionInstaller();
+    const result = installer.install(targetShell);
+
+    if (result.alreadyInstalled) {
+      console.log(colored('[OK] Shell completion already installed', 'green'));
+      console.log('');
+      return;
+    }
+
+    console.log(colored('[OK] Shell completion installed successfully!', 'green'));
+    console.log('');
+    console.log(result.message);
+    console.log('');
+    console.log(colored('To activate:', 'cyan'));
+    console.log(`  ${result.reload}`);
+    console.log('');
+    console.log(colored('Then test:', 'cyan'));
+    console.log('  ccs <TAB>        # See available profiles');
+    console.log('  ccs auth <TAB>   # See auth subcommands');
+    console.log('');
+  } catch (error) {
+    console.error(colored('[X] Error:', 'red'), error.message);
+    console.error('');
+    console.error(colored('Usage:', 'yellow'));
+    console.error('  ccs --shell-completion           # Auto-detect shell');
+    console.error('  ccs --shell-completion --bash    # Install for bash');
+    console.error('  ccs --shell-completion --zsh     # Install for zsh');
+    console.error('  ccs --shell-completion --fish    # Install for fish');
+    console.error('  ccs --shell-completion --powershell  # Install for PowerShell');
+    console.error('');
+    process.exit(1);
+  }
+}
+
 // Main execution
 async function main() {
   const args = process.argv.slice(2);
@@ -369,6 +442,12 @@ async function main() {
     return;
   }
 
+  // Special case: shell completion installer
+  if (firstArg === '--shell-completion') {
+    await handleShellCompletionCommand(args.slice(1));
+    return;
+  }
+
   // Special case: doctor command
   if (firstArg === 'doctor' || firstArg === '--doctor') {
     await handleDoctorCommand();
@@ -443,7 +522,13 @@ async function main() {
       execClaude(claudeCli, remainingArgs);
     }
   } catch (error) {
-    console.error(`[X] ${error.message}`);
+    // Check if this is a profile not found error with suggestions
+    if (error.profileName && error.availableProfiles !== undefined) {
+      const allProfiles = error.availableProfiles.split('\n');
+      ErrorManager.showProfileNotFound(error.profileName, allProfiles, error.suggestions);
+    } else {
+      console.error(`[X] ${error.message}`);
+    }
     process.exit(1);
   }
 }

package/bin/utils/error-codes.js

@@ -0,0 +1,59 @@
+// CCS Error Codes
+// Documentation: ../../docs/errors/README.md
+
+const ERROR_CODES = {
+  // Configuration Errors (E100-E199)
+  CONFIG_MISSING: 'E101',
+  CONFIG_INVALID_JSON: 'E102',
+  CONFIG_INVALID_PROFILE: 'E103',
+
+  // Profile Management Errors (E200-E299)
+  PROFILE_NOT_FOUND: 'E104',
+  PROFILE_ALREADY_EXISTS: 'E105',
+  PROFILE_CANNOT_DELETE_DEFAULT: 'E106',
+  PROFILE_INVALID_NAME: 'E107',
+
+  // Claude CLI Detection Errors (E300-E399)
+  CLAUDE_NOT_FOUND: 'E301',
+  CLAUDE_VERSION_INCOMPATIBLE: 'E302',
+  CLAUDE_EXECUTION_FAILED: 'E303',
+
+  // Network/API Errors (E400-E499)
+  GLMT_PROXY_TIMEOUT: 'E401',
+  API_KEY_MISSING: 'E402',
+  API_AUTH_FAILED: 'E403',
+  API_RATE_LIMIT: 'E404',
+
+  // File System Errors (E500-E599)
+  FS_CANNOT_CREATE_DIR: 'E501',
+  FS_CANNOT_WRITE_FILE: 'E502',
+  FS_CANNOT_READ_FILE: 'E503',
+  FS_INSTANCE_NOT_FOUND: 'E504',
+
+  // Internal Errors (E900-E999)
+  INTERNAL_ERROR: 'E900',
+  INVALID_STATE: 'E901'
+};
+
+// Error code documentation URL generator
+function getErrorDocUrl(errorCode) {
+  return `https://github.com/kaitranntt/ccs/blob/main/docs/errors/README.md#${errorCode.toLowerCase()}`;
+}
+
+// Get error category from code
+function getErrorCategory(errorCode) {
+  const code = parseInt(errorCode.substring(1));
+  if (code >= 100 && code < 200) return 'Configuration';
+  if (code >= 200 && code < 300) return 'Profile Management';
+  if (code >= 300 && code < 400) return 'Claude CLI Detection';
+  if (code >= 400 && code < 500) return 'Network/API';
+  if (code >= 500 && code < 600) return 'File System';
+  if (code >= 900 && code < 1000) return 'Internal';
+  return 'Unknown';
+}
+
+module.exports = {
+  ERROR_CODES,
+  getErrorDocUrl,
+  getErrorCategory
+};

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
 };