@kaitranntt/ccs 3.4.5 → 3.5.0

package/VERSION

@@ -1 +1 @@
-3.4.5
+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/glmt/glmt-transformer.js

@@ -8,6 +8,7 @@ const os = require('os');
 const SSEParser = require('./sse-parser');
 const DeltaAccumulator = require('./delta-accumulator');
 const LocaleEnforcer = require('./locale-enforcer');
+const ReasoningEnforcer = require('./reasoning-enforcer');
 
 /**
  * GlmtTransformer - Convert between Anthropic and OpenAI formats with thinking and tool support
@@ -54,6 +55,11 @@ class GlmtTransformer {
 
     // Initialize locale enforcer (always enforce English)
     this.localeEnforcer = new LocaleEnforcer();
+
+    // Initialize reasoning enforcer (enabled by default for all GLMT usage)
+    this.reasoningEnforcer = new ReasoningEnforcer({
+      enabled: config.explicitReasoning ?? true
+    });
   }
 
   /**
@@ -104,10 +110,16 @@ class GlmtTransformer {
         anthropicRequest.messages || []
       );
 
+      // 4.5. Inject reasoning instruction (if enabled or thinking requested)
+      const messagesWithReasoning = this.reasoningEnforcer.injectInstruction(
+        messagesWithLocale,
+        thinkingConfig
+      );
+
       // 5. Convert to OpenAI format
       const openaiRequest = {
         model: glmModel,
-        messages: this._sanitizeMessages(messagesWithLocale),
+        messages: this._sanitizeMessages(messagesWithReasoning),
         max_tokens: this._getMaxTokens(glmModel),
         stream: anthropicRequest.stream ?? false
       };

package/bin/glmt/reasoning-enforcer.js

@@ -0,0 +1,173 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * ReasoningEnforcer - Inject explicit reasoning instructions into prompts
+ *
+ * Purpose: Force GLM models to use structured reasoning output format (<reasoning_content>)
+ * This complements API parameters (reasoning: true) with explicit prompt instructions.
+ *
+ * Usage:
+ *   const enforcer = new ReasoningEnforcer({ enabled: true });
+ *   const modifiedMessages = enforcer.injectInstruction(messages, thinkingConfig);
+ *
+ * Strategy:
+ *   1. If system prompt exists: Prepend reasoning instruction
+ *   2. If no system prompt: Prepend to first user message
+ *   3. Select prompt template based on effort level (low/medium/high/max)
+ *   4. Preserve message structure (string vs array content)
+ */
+
+class ReasoningEnforcer {
+  constructor(options = {}) {
+    this.enabled = options.enabled ?? false; // Opt-in by default
+    this.prompts = options.prompts || this._getDefaultPrompts();
+  }
+
+  /**
+   * Inject reasoning instruction into messages
+   * @param {Array} messages - Messages array to modify
+   * @param {Object} thinkingConfig - { thinking: boolean, effort: string }
+   * @returns {Array} Modified messages array
+   */
+  injectInstruction(messages, thinkingConfig = {}) {
+    // Only inject if enabled or thinking explicitly requested
+    if (!this.enabled && !thinkingConfig.thinking) {
+      return messages;
+    }
+
+    // Clone messages to avoid mutation
+    const modifiedMessages = JSON.parse(JSON.stringify(messages));
+
+    // Select prompt based on effort level
+    const prompt = this._selectPrompt(thinkingConfig.effort || 'medium');
+
+    // Strategy 1: Inject into system prompt (preferred)
+    const systemIndex = modifiedMessages.findIndex(m => m.role === 'system');
+    if (systemIndex >= 0) {
+      const systemMsg = modifiedMessages[systemIndex];
+
+      if (typeof systemMsg.content === 'string') {
+        systemMsg.content = `${prompt}\n\n${systemMsg.content}`;
+      } else if (Array.isArray(systemMsg.content)) {
+        systemMsg.content.unshift({
+          type: 'text',
+          text: prompt
+        });
+      }
+
+      return modifiedMessages;
+    }
+
+    // Strategy 2: Prepend to first user message
+    const userIndex = modifiedMessages.findIndex(m => m.role === 'user');
+    if (userIndex >= 0) {
+      const userMsg = modifiedMessages[userIndex];
+
+      if (typeof userMsg.content === 'string') {
+        userMsg.content = `${prompt}\n\n${userMsg.content}`;
+      } else if (Array.isArray(userMsg.content)) {
+        userMsg.content.unshift({
+          type: 'text',
+          text: prompt
+        });
+      }
+
+      return modifiedMessages;
+    }
+
+    // No system or user messages found (edge case)
+    return modifiedMessages;
+  }
+
+  /**
+   * Select prompt template based on effort level
+   * @param {string} effort - 'low', 'medium', 'high', or 'max'
+   * @returns {string} Prompt template
+   * @private
+   */
+  _selectPrompt(effort) {
+    const normalizedEffort = effort.toLowerCase();
+    return this.prompts[normalizedEffort] || this.prompts.medium;
+  }
+
+  /**
+   * Get default prompt templates
+   * @returns {Object} Map of effort levels to prompts
+   * @private
+   */
+  _getDefaultPrompts() {
+    return {
+      low: `You are an expert reasoning model using GLM-4.6 architecture.
+
+CRITICAL: Before answering, write 2-3 sentences of reasoning in <reasoning_content> tags.
+
+OUTPUT FORMAT:
+<reasoning_content>
+(Brief analysis: what is the problem? what's the approach?)
+</reasoning_content>
+
+(Write your final answer here)`,
+
+      medium: `You are an expert reasoning model using GLM-4.6 architecture.
+
+CRITICAL REQUIREMENTS:
+1. Always think step-by-step before answering
+2. Write your reasoning process explicitly in <reasoning_content> tags
+3. Never skip your chain of thought, even for simple problems
+
+OUTPUT FORMAT:
+<reasoning_content>
+(Write your detailed thinking here: analyze the problem, explore approaches,
+evaluate trade-offs, and arrive at a conclusion)
+</reasoning_content>
+
+(Write your final answer here based on your reasoning above)`,
+
+      high: `You are an expert reasoning model using GLM-4.6 architecture.
+
+CRITICAL REQUIREMENTS:
+1. Think deeply and systematically before answering
+2. Write comprehensive reasoning in <reasoning_content> tags
+3. Explore multiple approaches and evaluate trade-offs
+4. Show all steps in your problem-solving process
+
+OUTPUT FORMAT:
+<reasoning_content>
+(Write exhaustive analysis here:
+ - Problem decomposition
+ - Multiple approach exploration
+ - Trade-off analysis for each approach
+ - Edge case consideration
+ - Final conclusion with justification)
+</reasoning_content>
+
+(Write your final answer here based on your systematic reasoning above)`,
+
+      max: `You are an expert reasoning model using GLM-4.6 architecture.
+
+CRITICAL REQUIREMENTS:
+1. Think exhaustively from first principles
+2. Write extremely detailed reasoning in <reasoning_content> tags
+3. Analyze ALL possible angles, approaches, and edge cases
+4. Challenge your own assumptions and explore alternatives
+5. Provide rigorous justification for every claim
+
+OUTPUT FORMAT:
+<reasoning_content>
+(Write comprehensive analysis here:
+ - First principles breakdown
+ - Exhaustive approach enumeration
+ - Comparative analysis of all approaches
+ - Edge case and failure mode analysis
+ - Assumption validation
+ - Counter-argument consideration
+ - Final conclusion with rigorous justification)
+</reasoning_content>
+
+(Write your final answer here based on your exhaustive reasoning above)`
+    };
+  }
+}
+
+module.exports = ReasoningEnforcer;

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