@kaitranntt/ccs 3.4.6 → 4.1.0

package/VERSION

@@ -1 +1 @@
-3.4.6
+4.1.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

@@ -73,6 +73,33 @@ function handleVersionCommand() {
   // Config path
   const configPath = getConfigPath();
   console.log(`  ${colored('Config:', 'cyan')} ${configPath}`);
+
+  // Delegation status
+  const delegationRulesPath = path.join(os.homedir(), '.ccs', 'delegation-rules.json');
+  const delegationEnabled = fs.existsSync(delegationRulesPath);
+
+  if (delegationEnabled) {
+    console.log(`  ${colored('Delegation:', 'cyan')} Enabled`);
+
+    // Check which profiles are delegation-ready
+    const readyProfiles = [];
+    const { DelegationValidator } = require('./utils/delegation-validator');
+
+    for (const profile of ['glm', 'kimi']) {
+      const validation = DelegationValidator.validate(profile);
+      if (validation.valid) {
+        readyProfiles.push(profile);
+      }
+    }
+
+    if (readyProfiles.length > 0) {
+      console.log(`  ${colored('Ready:', 'cyan')} ${readyProfiles.join(', ')}`);
+    } else {
+      console.log(`  ${colored('Ready:', 'cyan')} None (configure profiles first)`);
+    }
+  } else {
+    console.log(`  ${colored('Delegation:', 'cyan')} Not configured`);
+  }
   console.log('');
 
   // Documentation
@@ -121,15 +148,26 @@ function handleHelpCommand() {
   console.log(`  ${colored('ccs personal', 'yellow')}                Switch to personal account`);
   console.log('');
 
+  // Delegation (NEW)
+  console.log(colored('Delegation (Token Optimization):', 'cyan'));
+  console.log(`  ${colored('/ccs:glm "task"', 'yellow')}             Delegate to GLM-4.6 within Claude session`);
+  console.log(`  ${colored('/ccs:kimi "task"', 'yellow')}            Delegate to Kimi for long context`);
+  console.log(`  ${colored('/ccs:create m2', 'yellow')}              Create custom delegation command`);
+  console.log('  Use delegation to save tokens on simple tasks');
+  console.log('  Commands work inside Claude Code sessions only');
+  console.log('');
+
   // Diagnostics
   console.log(colored('Diagnostics:', 'cyan'));
   console.log(`  ${colored('ccs doctor', 'yellow')}                  Run health check and diagnostics`);
+  console.log(`  ${colored('ccs update', 'yellow')}                  Re-install CCS items to ~/.claude/`);
   console.log('');
 
   // Flags
   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 +187,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');
@@ -203,6 +254,16 @@ async function handleDoctorCommand() {
   process.exit(doctor.results.isHealthy() ? 0 : 1);
 }
 
+async function handleUpdateCommand() {
+  const ClaudeSymlinkManager = require('./utils/claude-symlink-manager');
+  const manager = new ClaudeSymlinkManager();
+
+  console.log('[i] Updating CCS items in ~/.claude/...');
+  manager.update();
+
+  process.exit(0);
+}
+
 // Smart profile detection
 function detectProfile(args) {
   if (args.length === 0 || args[0].startsWith('-')) {
@@ -241,6 +302,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 +333,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 +409,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,12 +489,24 @@ 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();
     return;
   }
 
+  // Special case: update command (re-install CCS symlinks)
+  if (firstArg === 'update' || firstArg === '--update') {
+    await handleUpdateCommand();
+    return;
+  }
+
   // Special case: auth command (multi-account management)
   if (firstArg === 'auth') {
     const AuthCommands = require('./auth/auth-commands');
@@ -383,6 +515,14 @@ async function main() {
     return;
   }
 
+  // Special case: headless delegation (-p flag)
+  if (args.includes('-p') || args.includes('--prompt')) {
+    const DelegationHandler = require('./delegation/delegation-handler');
+    const handler = new DelegationHandler();
+    await handler.route(args);
+    return;
+  }
+
   // Auto-recovery for missing configuration
   const recovery = new RecoveryManager();
   const recovered = recovery.recoverAll();
@@ -443,7 +583,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/delegation/README.md

@@ -0,0 +1,189 @@
+# CCS Delegation Module
+
+Enhanced Claude Code delegation system for multi-model task delegation.
+
+## Files
+
+### Core Components
+- **headless-executor.js** (405 lines) - Main executor, spawns `claude -p` with enhanced features
+- **session-manager.js** (156 lines) - Session persistence and cost tracking
+- **settings-parser.js** (88 lines) - Parse tool restrictions from settings
+- **result-formatter.js** (326 lines) - Terminal output formatting
+
+**Total**: 975 lines (down from 1,755 lines - 44% reduction)
+
+## Features
+
+### Enhanced Headless Execution
+- Stream-JSON output parsing (`--output-format stream-json`)
+- Real-time tool use visibility in TTY
+- Permission mode acceptEdits (`--permission-mode acceptEdits`)
+- Tool restrictions from `.claude/settings.local.json`
+- Multi-turn session management (`--resume <session-id>`)
+- Time-based limits (10 min default timeout with graceful termination)
+- Cost tracking and aggregation
+
+### Session Management
+- Persistence: `~/.ccs/delegation-sessions.json`
+- Resume via `/ccs:glm:continue` and `/ccs:kimi:continue`
+- Auto-cleanup expired sessions (>30 days)
+- Cost aggregation across turns
+
+### Settings
+- Profile location: `~/.ccs/{profile}.settings.json`
+- Examples: `glm.settings.json`, `kimi.settings.json`, `glmt.settings.json`
+- Tool restrictions from `.claude/settings.local.json`
+
+## Usage
+
+### Basic Delegation
+```javascript
+const { HeadlessExecutor } = require('./headless-executor');
+
+const result = await HeadlessExecutor.execute('glm', 'Refactor auth.js', {
+  cwd: '/path/to/project',
+  outputFormat: 'stream-json',
+  permissionMode: 'acceptEdits',
+  timeout: 600000  // 10 minutes
+});
+
+console.log(result.sessionId);  // For multi-turn
+console.log(result.totalCost);  // Cost in USD
+console.log(result.content);    // Result text
+```
+
+### Multi-Turn Sessions
+```javascript
+// Start session
+const result1 = await HeadlessExecutor.execute('glm', 'Implement feature');
+const sessionId = result1.sessionId;
+
+// Continue session
+const result2 = await HeadlessExecutor.execute('glm', 'Add tests', {
+  resumeSession: true
+});
+
+// Or with specific session ID
+const result3 = await HeadlessExecutor.execute('glm', 'Run tests', {
+  sessionId: sessionId
+});
+```
+
+### Tool Restrictions
+Create `.claude/settings.local.json`:
+```json
+{
+  "permissions": {
+    "allow": ["Bash(git:*)", "Read", "Edit"],
+    "deny": ["Bash(rm:*)", "Bash(sudo:*)"]
+  }
+}
+```
+
+Automatically applied as CLI flags:
+```bash
+--allowedTools "Bash(git:*)" "Read" "Edit" \
+--disallowedTools "Bash(rm:*)" "Bash(sudo:*)"
+```
+
+## Slash Commands
+
+The delegation system is invoked via simple slash commands in `.claude/commands/ccs/`:
+
+### Basic Commands
+- `/ccs:glm "task"` - Delegate to GLM-4.6
+- `/ccs:kimi "task"` - Delegate to Kimi (long-context)
+
+### Multi-Turn Commands
+- `/ccs:glm:continue "follow-up"` - Resume last GLM session
+- `/ccs:kimi:continue "follow-up"` - Resume last Kimi session
+
+Each command directly invokes:
+```bash
+claude -p "$ARGUMENTS" \
+  --settings ~/.ccs/{profile}.settings.json \
+  --output-format stream-json \
+  --permission-mode acceptEdits
+```
+
+## Debug Mode
+
+```bash
+export CCS_DEBUG=1
+```
+
+Enables verbose logging:
+- Permission mode selection
+- Session resumption details
+- Tool restrictions parsing
+- CLI args construction
+- Session persistence events
+
+## Testing
+
+```bash
+# Run all delegation tests
+node tests/unit/delegation/json-output.test.js
+node tests/unit/delegation/permission-mode.test.js
+node tests/unit/delegation/session-manager.test.js
+node tests/unit/delegation/settings-parser.test.js
+node tests/unit/delegation/max-turns.test.js
+node tests/unit/delegation/result-formatter.test.js
+```
+
+**Test Coverage:**
+- JSON output parsing (6 tests)
+- Permission modes (11 tests)
+- Session management (7 tests)
+- Settings parser (6 tests)
+- Auto max-turns (14 tests)
+- Result formatting (14 tests)
+- **Total: 58 tests**
+
+## Architecture
+
+```
+User → SlashCommand (/ccs:glm)
+  → Directly invokes: claude -p
+    → HeadlessExecutor (monitors execution)
+      → SessionManager (load last session)
+      → SettingsParser (tool restrictions)
+      → Parse JSON response
+      → SessionManager (store/update)
+      → ResultFormatter.format()
+  → Display to user
+```
+
+**Key Simplification**: Slash commands invoke `claude -p` directly. No intermediate delegation engine or rule system - just direct headless execution with enhanced features.
+
+## File Permissions
+
+All files should be `644` (rw-r--r--):
+```bash
+chmod 644 bin/delegation/*.js
+```
+
+## Dependencies
+
+- Node.js 14+
+- Claude CLI installed and in PATH
+- Profile settings configured in `~/.ccs/{profile}.settings.json`
+
+## Migration from Legacy System
+
+**Removed components** (as of 2025-11-15):
+- ~~delegation-engine.js~~ - Rule-based decision engine (unused)
+- ~~cwd-resolver.js~~ - Working directory resolution (unused)
+- ~~rules-schema.js~~ - Schema validation (unused)
+- ~~delegation-rules.json~~ - Configuration file (not created)
+
+**Why removed**: Current slash commands directly invoke `claude -p` without intermediate orchestration. The delegation engine, CWD resolver, and rules schema were designed for a more complex system that was never fully integrated.
+
+**Result**: 44% code reduction (1,755 → 975 lines) with same functionality.
+
+## References
+
+- Official docs: https://code.claude.com/docs/en/headless.md
+- Skill: `.claude/skills/ccs-delegation/`
+- Commands: `.claude/commands/ccs/`
+- Tests: `tests/unit/delegation/`