@kaitranntt/ccs 4.3.3 → 4.3.5

package/README.md

@@ -323,8 +323,7 @@ graph LR
 ~/.ccs/
 ├── .claude/                 # CCS items (ships with package, v4.1)
 │   ├── commands/ccs/        # Delegation commands (/ccs, /ccs:continue)
-│   ├── skills/ccs-delegation/  # AI decision framework
-│   └── agents/ccs-delegator.md # Proactive delegation agent
+│   └── skills/ccs-delegation/  # AI decision framework (replaces deprecated agents)
 ├── shared/                  # Symlinks to ~/.claude/ (for profiles)
 │   ├── agents@ → ~/.claude/agents/
 │   ├── commands@ → ~/.claude/commands/
@@ -341,7 +340,7 @@ graph LR
 ~/.claude/                   # User's Claude directory
 ├── commands/ccs@ → ~/.ccs/.claude/commands/ccs/  # Selective symlink
 ├── skills/ccs-delegation@ → ~/.ccs/.claude/skills/ccs-delegation/
-└── agents/ccs-delegator.md@ → ~/.ccs/.claude/agents/ccs-delegator.md
+# agents/ccs-delegator.md@ → ~/.ccs/.claude/agents/ccs-delegator.md  # Deprecated in v4.3.2
 ```
 
 **Symlink Chain**: `work profile → ~/.ccs/shared/ → ~/.claude/ → ~/.ccs/.claude/` (CCS items)
@@ -507,8 +506,8 @@ Savings:                        $0.0275 (86% reduction)
 ### Documentation
 
 - **Workflow Diagrams**: See [docs/ccs-delegation-diagrams.md](docs/ccs-delegation-diagrams.md) for visual architecture
-- **Skill Reference**: `.claude/skills/ccs-delegation/` for AI decision framework
-- **Agent Docs**: `.claude/agents/ccs-delegator.md` for orchestration patterns
+- **Skill Reference**: `.claude/skills/ccs-delegation/` for AI decision framework (replaces deprecated agents)
+- **Agent Docs**: `.claude/agents/ccs-delegator.md` was deprecated in v4.3.2, functionality moved to ccs-delegation skill
 
 <br>
 

package/VERSION

@@ -1 +1 @@
-4.3.3
+4.3.5

package/bin/ccs.js

@@ -286,6 +286,11 @@ async function handleSyncCommand() {
 
   console.log('');
 
+  const cleanupResult = installer.cleanupDeprecated();
+  if (cleanupResult.success && cleanupResult.cleanedFiles.length > 0) {
+    console.log('');
+  }
+
   // Then, create symlinks from ~/.ccs/.claude/ to ~/.claude/
   const ClaudeSymlinkManager = require('./utils/claude-symlink-manager');
   const manager = new ClaudeSymlinkManager();
@@ -298,6 +303,150 @@ async function handleSyncCommand() {
   process.exit(0);
 }
 
+/**
+ * Detect installation method
+ * @returns {'npm'|'direct'} - Installation method
+ */
+function detectInstallationMethod() {
+  const scriptPath = process.argv[1];
+
+  // Method 1: Check if script is inside node_modules
+  if (scriptPath.includes('node_modules')) {
+    return 'npm';
+  }
+
+  // Method 2: Check if script is in npm global bin directory
+  // Common patterns for npm global installations
+  const npmGlobalBinPatterns = [
+    /\.npm\/global\/bin\//,           // ~/.npm/global/bin/ccs
+    /\/\.nvm\/versions\/node\/[^\/]+\/bin\//,  // ~/.nvm/versions/node/v22.19.0/bin/ccs
+    /\/usr\/local\/bin\//,           // /usr/local/bin/ccs (if npm global prefix is /usr/local)
+    /\/usr\/bin\//                   // /usr/bin/ccs (if npm global prefix is /usr)
+  ];
+
+  for (const pattern of npmGlobalBinPatterns) {
+    if (pattern.test(scriptPath)) {
+      // Verify this is actually CCS by checking the linked target
+      try {
+        const binDir = path.dirname(scriptPath);
+        const nodeModulesDir = path.join(binDir, '..', 'lib', 'node_modules', '@kaitranntt', 'ccs');
+        const globalModulesDir = path.join(binDir, '..', 'node_modules', '@kaitranntt', 'ccs');
+
+        if (fs.existsSync(nodeModulesDir) || fs.existsSync(globalModulesDir)) {
+          return 'npm';
+        }
+      } catch (err) {
+        // Continue checking other patterns
+      }
+    }
+  }
+
+  // Method 3: Check if package.json exists in parent directory (development mode)
+  const packageJsonPath = path.join(__dirname, '..', 'package.json');
+
+  if (fs.existsSync(packageJsonPath)) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+      // If package.json has name "@kaitranntt/ccs", it's npm install
+      if (pkg.name === '@kaitranntt/ccs') {
+        return 'npm';
+      }
+    } catch (err) {
+      // Ignore parse errors
+    }
+  }
+
+  // Method 4: Check if script is a symlink pointing to node_modules
+  try {
+    const stats = fs.lstatSync(scriptPath);
+    if (stats.isSymbolicLink()) {
+      const targetPath = fs.readlinkSync(scriptPath);
+      if (targetPath.includes('node_modules') || targetPath.includes('@kaitranntt/ccs')) {
+        return 'npm';
+      }
+    }
+  } catch (err) {
+    // Continue to default
+  }
+
+  // Default to direct installation
+  return 'direct';
+}
+
+/**
+ * Detect which package manager was used for installation
+ * @returns {'npm'|'yarn'|'pnpm'|'bun'|'unknown'}
+ */
+function detectPackageManager() {
+  const scriptPath = process.argv[1];
+
+  // Check if script path contains package manager indicators
+  if (scriptPath.includes('.pnpm')) return 'pnpm';
+  if (scriptPath.includes('yarn')) return 'yarn';
+  if (scriptPath.includes('bun')) return 'bun';
+
+  // Check parent directories for lock files
+  const binDir = path.dirname(scriptPath);
+  const fs = require('fs');
+
+  // Check global node_modules parent for lock files
+  let checkDir = binDir;
+  for (let i = 0; i < 5; i++) {
+    if (fs.existsSync(path.join(checkDir, 'pnpm-lock.yaml'))) return 'pnpm';
+    if (fs.existsSync(path.join(checkDir, 'yarn.lock'))) return 'yarn';
+    if (fs.existsSync(path.join(checkDir, 'bun.lockb'))) return 'bun';
+    checkDir = path.dirname(checkDir);
+  }
+
+  // Check if package managers are available on the system
+  const { spawnSync } = require('child_process');
+
+  // Try yarn global list to see if CCS is installed via yarn
+  try {
+    const yarnResult = spawnSync('yarn', ['global', 'list', '--pattern', '@kaitranntt/ccs'], {
+      encoding: 'utf8',
+      shell: true,
+      timeout: 5000
+    });
+    if (yarnResult.status === 0 && yarnResult.stdout.includes('@kaitranntt/ccs')) {
+      return 'yarn';
+    }
+  } catch (err) {
+    // Continue to next check
+  }
+
+  // Try pnpm list -g to see if CCS is installed via pnpm
+  try {
+    const pnpmResult = spawnSync('pnpm', ['list', '-g', '--pattern', '@kaitranntt/ccs'], {
+      encoding: 'utf8',
+      shell: true,
+      timeout: 5000
+    });
+    if (pnpmResult.status === 0 && pnpmResult.stdout.includes('@kaitranntt/ccs')) {
+      return 'pnpm';
+    }
+  } catch (err) {
+    // Continue to next check
+  }
+
+  // Try bun pm ls -g to see if CCS is installed via bun
+  try {
+    const bunResult = spawnSync('bun', ['pm', 'ls', '-g', '--pattern', '@kaitranntt/ccs'], {
+      encoding: 'utf8',
+      shell: true,
+      timeout: 5000
+    });
+    if (bunResult.status === 0 && bunResult.stdout.includes('@kaitranntt/ccs')) {
+      return 'bun';
+    }
+  } catch (err) {
+    // Continue to default
+  }
+
+  // Default to npm
+  return 'npm';
+}
+
 async function handleUpdateCommand() {
   const { checkForUpdates } = require('./utils/update-checker');
   const { spawn } = require('child_process');
@@ -307,8 +456,8 @@ async function handleUpdateCommand() {
   console.log('');
 
   // Detect installation method for proper update source
-  const isNpmInstall = process.argv[1].includes('node_modules');
-  const installMethod = isNpmInstall ? 'npm' : 'direct';
+  const installMethod = detectInstallationMethod();
+  const isNpmInstall = installMethod === 'npm';
 
   // Check for updates (force check)
   const updateResult = await checkForUpdates(CCS_VERSION, true, installMethod);
@@ -323,7 +472,27 @@ async function handleUpdateCommand() {
     console.log('');
     console.log('Try again later or update manually:');
     if (isNpmInstall) {
-      console.log(colored('  npm install -g @kaitranntt/ccs@latest', 'yellow'));
+      const packageManager = detectPackageManager();
+      let manualCommand;
+
+      switch (packageManager) {
+        case 'npm':
+          manualCommand = 'npm install -g @kaitranntt/ccs@latest';
+          break;
+        case 'yarn':
+          manualCommand = 'yarn global add @kaitranntt/ccs@latest';
+          break;
+        case 'pnpm':
+          manualCommand = 'pnpm add -g @kaitranntt/ccs@latest';
+          break;
+        case 'bun':
+          manualCommand = 'bun add -g @kaitranntt/ccs@latest';
+          break;
+        default:
+          manualCommand = 'npm install -g @kaitranntt/ccs@latest';
+      }
+
+      console.log(colored(`  ${manualCommand}`, 'yellow'));
     } else {
       const isWindows = process.platform === 'win32';
       if (isWindows) {
@@ -361,13 +530,38 @@ async function handleUpdateCommand() {
   console.log('');
 
   if (isNpmInstall) {
-    // npm installation - use npm update
-    console.log(colored('Updating via npm...', 'cyan'));
+    // npm installation - detect package manager and update
+    const packageManager = detectPackageManager();
+    let updateCommand, updateArgs;
+
+    switch (packageManager) {
+      case 'npm':
+        updateCommand = 'npm';
+        updateArgs = ['install', '-g', '@kaitranntt/ccs@latest'];
+        break;
+      case 'yarn':
+        updateCommand = 'yarn';
+        updateArgs = ['global', 'add', '@kaitranntt/ccs@latest'];
+        break;
+      case 'pnpm':
+        updateCommand = 'pnpm';
+        updateArgs = ['add', '-g', '@kaitranntt/ccs@latest'];
+        break;
+      case 'bun':
+        updateCommand = 'bun';
+        updateArgs = ['add', '-g', '@kaitranntt/ccs@latest'];
+        break;
+      default:
+        updateCommand = 'npm';
+        updateArgs = ['install', '-g', '@kaitranntt/ccs@latest'];
+    }
+
+    console.log(colored(`Updating via ${packageManager}...`, 'cyan'));
     console.log('');
 
-    const child = spawn('npm', ['install', '-g', '@kaitranntt/ccs@latest'], {
-      stdio: 'inherit',
-      shell: true
+    const child = spawn(updateCommand, updateArgs, {
+      stdio: 'inherit'
+      // No shell needed for direct commands
     });
 
     child.on('exit', (code) => {
@@ -382,7 +576,7 @@ async function handleUpdateCommand() {
         console.log(colored('[X] Update failed', 'red'));
         console.log('');
         console.log('Try manually:');
-        console.log(colored('  npm install -g @kaitranntt/ccs@latest', 'yellow'));
+        console.log(colored(`  ${updateCommand} ${updateArgs.join(' ')}`, 'yellow'));
         console.log('');
       }
       process.exit(code || 0);
@@ -390,10 +584,10 @@ async function handleUpdateCommand() {
 
     child.on('error', (err) => {
       console.log('');
-      console.log(colored('[X] Failed to run npm update', 'red'));
+      console.log(colored(`[X] Failed to run ${packageManager} update`, 'red'));
       console.log('');
       console.log('Try manually:');
-      console.log(colored('  npm install -g @kaitranntt/ccs@latest', 'yellow'));
+      console.log(colored(`  ${updateCommand} ${updateArgs.join(' ')}`, 'yellow'));
       console.log('');
       process.exit(1);
     });
@@ -406,16 +600,19 @@ async function handleUpdateCommand() {
     let command, args;
 
     if (isWindows) {
+      // PowerShell
       command = 'powershell.exe';
-      args = ['-Command', 'irm ccs.kaitran.ca/install | iex'];
+      args = ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-Command',
+              'irm ccs.kaitran.ca/install | iex'];
     } else {
-      command = 'bash';
+      // Unix (bash with proper shell invocation)
+      command = '/bin/bash';
       args = ['-c', 'curl -fsSL ccs.kaitran.ca/install | bash'];
     }
 
     const child = spawn(command, args, {
-      stdio: 'inherit',
-      shell: true
+      stdio: 'inherit'
+      // Do NOT use shell: true
     });
 
     child.on('exit', (code) => {

package/bin/utils/claude-dir-installer.js

@@ -148,6 +148,108 @@ class ClaudeDirInstaller {
     return { files, dirs };
   }
 
+  /**
+   * Clean up deprecated files from previous installations
+   * Removes ccs-delegator.md that was deprecated in v4.3.2
+   * @param {boolean} silent - Suppress console output
+   */
+  cleanupDeprecated(silent = false) {
+    const deprecatedFile = path.join(this.ccsClaudeDir, 'agents', 'ccs-delegator.md');
+    const userSymlinkFile = path.join(this.homeDir, '.claude', 'agents', 'ccs-delegator.md');
+    const migrationMarker = path.join(this.homeDir, '.ccs', '.migrations', 'v435-delegator-cleanup');
+
+    let cleanedFiles = [];
+
+    try {
+      // Check if cleanup already done
+      if (fs.existsSync(migrationMarker)) {
+        return { success: true, cleanedFiles: [] }; // Already cleaned
+      }
+
+      // Clean up user symlink in ~/.claude/agents/ccs-delegator.md FIRST
+      // This ensures we can detect broken symlinks before deleting the target
+      try {
+        const userStats = fs.lstatSync(userSymlinkFile);
+        if (userStats.isSymbolicLink()) {
+          fs.unlinkSync(userSymlinkFile);
+          cleanedFiles.push('user symlink');
+        } else {
+          // It's not a symlink (user created their own file), backup it
+          const timestamp = new Date().toISOString().replace(/[:.]/g, '-').split('T')[0];
+          const backupPath = `${userSymlinkFile}.backup-${timestamp}`;
+          fs.renameSync(userSymlinkFile, backupPath);
+          if (!silent) console.log(`[i] Backed up user file to ${path.basename(backupPath)}`);
+          cleanedFiles.push('user file (backed up)');
+        }
+      } catch (err) {
+        // File doesn't exist or other error - that's okay
+        if (err.code !== 'ENOENT' && !silent) {
+          console.log(`[!] Failed to remove user symlink: ${err.message}`);
+        }
+      }
+
+      // Clean up package copy in ~/.ccs/.claude/agents/ccs-delegator.md
+      if (fs.existsSync(deprecatedFile)) {
+        try {
+          // Check if file was modified by user (compare with expected content)
+          const shouldBackup = this._shouldBackupDeprecatedFile(deprecatedFile);
+
+          if (shouldBackup) {
+            const timestamp = new Date().toISOString().replace(/[:.]/g, '-').split('T')[0];
+            const backupPath = `${deprecatedFile}.backup-${timestamp}`;
+            fs.renameSync(deprecatedFile, backupPath);
+            if (!silent) console.log(`[i] Backed up modified deprecated file to ${path.basename(backupPath)}`);
+          } else {
+            fs.rmSync(deprecatedFile, { force: true });
+          }
+          cleanedFiles.push('package copy');
+        } catch (err) {
+          if (!silent) console.log(`[!] Failed to remove package copy: ${err.message}`);
+        }
+      }
+
+      // Create migration marker
+      if (cleanedFiles.length > 0) {
+        const migrationsDir = path.dirname(migrationMarker);
+        if (!fs.existsSync(migrationsDir)) {
+          fs.mkdirSync(migrationsDir, { recursive: true, mode: 0o700 });
+        }
+        fs.writeFileSync(migrationMarker, new Date().toISOString());
+
+        if (!silent) {
+          console.log(`[OK] Cleaned up deprecated agent files: ${cleanedFiles.join(', ')}`);
+        }
+      }
+
+      return { success: true, cleanedFiles };
+    } catch (err) {
+      if (!silent) console.log(`[!] Cleanup failed: ${err.message}`);
+      return { success: false, error: err.message, cleanedFiles };
+    }
+  }
+
+  /**
+   * Check if deprecated file should be backed up (user modified)
+   * @param {string} filePath - Path to check
+   * @returns {boolean} True if file should be backed up
+   * @private
+   */
+  _shouldBackupDeprecatedFile(filePath) {
+    try {
+      // Simple heuristic: if file size differs significantly from expected, assume user modified
+      // Expected size for ccs-delegator.md was around 2-3KB
+      const stats = fs.statSync(filePath);
+      const expectedMinSize = 1000; // 1KB minimum
+      const expectedMaxSize = 10000; // 10KB maximum
+
+      // If size is outside expected range, likely user modified
+      return stats.size < expectedMinSize || stats.size > expectedMaxSize;
+    } catch (err) {
+      // If we can't determine, err on side of caution and backup
+      return true;
+    }
+  }
+
   /**
    * Check if ~/.ccs/.claude/ exists and is valid
    * @returns {boolean} True if directory exists

package/bin/utils/claude-symlink-manager.js

@@ -28,8 +28,7 @@ class ClaudeSymlinkManager {
     // CCS items to symlink (selective, item-level)
     this.ccsItems = [
       { source: 'commands/ccs', target: 'commands/ccs', type: 'directory' },
-      { source: 'skills/ccs-delegation', target: 'skills/ccs-delegation', type: 'directory' },
-      { source: 'agents/ccs-delegator.md', target: 'agents/ccs-delegator.md', type: 'file' }
+      { source: 'skills/ccs-delegation', target: 'skills/ccs-delegation', type: 'directory' }
     ];
   }
 

package/lib/ccs

@@ -2,7 +2,7 @@
 set -euo pipefail
 
 # Version (updated by scripts/bump-version.sh)
-CCS_VERSION="4.3.3"
+CCS_VERSION="4.3.5"
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 readonly CONFIG_FILE="${CCS_CONFIG:-$HOME/.ccs/config.json}"
 readonly PROFILES_JSON="$HOME/.ccs/profiles.json"

package/lib/ccs.ps1

@@ -12,7 +12,7 @@ param(
 $ErrorActionPreference = "Stop"
 
 # Version (updated by scripts/bump-version.sh)
-$CcsVersion = "4.3.3"
+$CcsVersion = "4.3.5"
 $ScriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path
 $ConfigFile = if ($env:CCS_CONFIG) { $env:CCS_CONFIG } else { "$env:USERPROFILE\.ccs\config.json" }
 $ProfilesJson = "$env:USERPROFILE\.ccs\profiles.json"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kaitranntt/ccs",
-  "version": "4.3.3",
+  "version": "4.3.5",
   "description": "Claude Code Switch - Instant profile switching between Claude Sonnet 4.5 and GLM 4.6",
   "keywords": [
     "cli",
@@ -59,7 +59,7 @@
   },
   "dependencies": {
     "cli-table3": "^0.6.5",
-    "ora": "^5.4.1"
+    "ora": "^9.0.0"
   },
   "devDependencies": {
     "mocha": "^11.7.5"

package/scripts/postinstall.js

@@ -109,6 +109,9 @@ function createConfigFiles() {
       const installer = new ClaudeDirInstaller();
       const packageDir = path.join(__dirname, '..');
       installer.install(packageDir);
+
+      // Clean up deprecated files (v4.3.2)
+      installer.cleanupDeprecated();
     } catch (err) {
       console.warn('[!] Failed to install .claude/ directory:', err.message);
       console.warn('    CCS items may not be available');