@kaitranntt/ccs 4.4.0 → 5.0.1

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

@@ -1,283 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-
-// Make ora optional (might not be available during npm install postinstall)
-// ora v9+ is an ES module, need to use .default for CommonJS
-let ora = null;
-try {
-  const oraModule = require('ora');
-  ora = oraModule.default || oraModule;
-} catch (e) {
-  // ora not available, create fallback spinner that uses console.log
-  ora = function(text) {
-    return {
-      start: () => ({
-        succeed: (msg) => console.log(msg || `[OK] ${text}`),
-        fail: (msg) => console.log(msg || `[X] ${text}`),
-        warn: (msg) => console.log(msg || `[!] ${text}`),
-        info: (msg) => console.log(msg || `[i] ${text}`),
-        text: ''
-      })
-    };
-  };
-}
-
-const { colored } = require('./helpers');
-
-/**
- * ClaudeDirInstaller - Manages copying .claude/ directory from package to ~/.ccs/.claude/
- * v4.1.1: Fix for npm install not copying .claude/ directory
- */
-class ClaudeDirInstaller {
-  constructor() {
-    this.homeDir = os.homedir();
-    this.ccsClaudeDir = path.join(this.homeDir, '.ccs', '.claude');
-  }
-
-  /**
-   * Copy .claude/ directory from package to ~/.ccs/.claude/
-   * @param {string} packageDir - Package installation directory (default: auto-detect)
-   * @param {boolean} silent - Suppress spinner output
-   */
-  install(packageDir, silent = false) {
-    const spinner = (silent || !ora) ? null : ora('Copying .claude/ items to ~/.ccs/.claude/').start();
-
-    try {
-      // Auto-detect package directory if not provided
-      if (!packageDir) {
-        // Try to find package root by going up from this file
-        packageDir = path.join(__dirname, '..', '..');
-      }
-
-      const packageClaudeDir = path.join(packageDir, '.claude');
-
-      if (!fs.existsSync(packageClaudeDir)) {
-        const msg = 'Package .claude/ directory not found';
-        if (spinner) {
-          spinner.warn(`[!] ${msg}`);
-          console.log(`    Searched in: ${packageClaudeDir}`);
-          console.log('    This may be a development installation');
-        } else {
-          console.log(`[!] ${msg}`);
-          console.log(`    Searched in: ${packageClaudeDir}`);
-          console.log('    This may be a development installation');
-        }
-        return false;
-      }
-
-      // Remove old version before copying new one
-      if (fs.existsSync(this.ccsClaudeDir)) {
-        if (spinner) spinner.text = 'Removing old .claude/ items...';
-        fs.rmSync(this.ccsClaudeDir, { recursive: true, force: true });
-      }
-
-      // Use fs.cpSync for recursive copy (Node.js 16.7.0+)
-      // Fallback to manual copy for older Node.js versions
-      if (spinner) spinner.text = 'Copying .claude/ items...';
-
-      if (fs.cpSync) {
-        fs.cpSync(packageClaudeDir, this.ccsClaudeDir, { recursive: true });
-      } else {
-        // Fallback for Node.js < 16.7.0
-        this._copyDirRecursive(packageClaudeDir, this.ccsClaudeDir);
-      }
-
-      // Count files and directories
-      const itemCount = this._countItems(this.ccsClaudeDir);
-      const msg = `Copied .claude/ items (${itemCount.files} files, ${itemCount.dirs} directories)`;
-
-      if (spinner) {
-        spinner.succeed(colored('[OK]', 'green') + ` ${msg}`);
-      } else {
-        console.log(`[OK] ${msg}`);
-      }
-      return true;
-    } catch (err) {
-      const msg = `Failed to copy .claude/ directory: ${err.message}`;
-      if (spinner) {
-        spinner.fail(colored('[!]', 'yellow') + ` ${msg}`);
-        console.warn('    CCS items may not be available');
-      } else {
-        console.warn(`[!] ${msg}`);
-        console.warn('    CCS items may not be available');
-      }
-      return false;
-    }
-  }
-
-  /**
-   * Recursively copy directory (fallback for Node.js < 16.7.0)
-   * @param {string} src - Source directory
-   * @param {string} dest - Destination directory
-   * @private
-   */
-  _copyDirRecursive(src, dest) {
-    // Create destination directory
-    if (!fs.existsSync(dest)) {
-      fs.mkdirSync(dest, { recursive: true });
-    }
-
-    // Read source directory
-    const entries = fs.readdirSync(src, { withFileTypes: true });
-
-    for (const entry of entries) {
-      const srcPath = path.join(src, entry.name);
-      const destPath = path.join(dest, entry.name);
-
-      if (entry.isDirectory()) {
-        // Recursively copy subdirectory
-        this._copyDirRecursive(srcPath, destPath);
-      } else {
-        // Copy file
-        fs.copyFileSync(srcPath, destPath);
-      }
-    }
-  }
-
-  /**
-   * Count files and directories in a path
-   * @param {string} dirPath - Directory to count
-   * @returns {Object} { files: number, dirs: number }
-   * @private
-   */
-  _countItems(dirPath) {
-    let files = 0;
-    let dirs = 0;
-
-    const countRecursive = (p) => {
-      const entries = fs.readdirSync(p, { withFileTypes: true });
-      for (const entry of entries) {
-        if (entry.isDirectory()) {
-          dirs++;
-          countRecursive(path.join(p, entry.name));
-        } else {
-          files++;
-        }
-      }
-    };
-
-    try {
-      countRecursive(dirPath);
-    } catch (e) {
-      // Ignore errors
-    }
-
-    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
-   */
-  isInstalled() {
-    return fs.existsSync(this.ccsClaudeDir);
-  }
-}
-
-module.exports = ClaudeDirInstaller;

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

@@ -1,289 +0,0 @@
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-
-// Make ora optional (might not be available during npm install postinstall)
-// ora v9+ is an ES module, need to use .default for CommonJS
-let ora = null;
-try {
-  const oraModule = require('ora');
-  ora = oraModule.default || oraModule;
-} catch (e) {
-  // ora not available, create fallback spinner that uses console.log
-  ora = function(text) {
-    return {
-      start: () => ({
-        succeed: (msg) => console.log(msg || `[OK] ${text}`),
-        fail: (msg) => console.log(msg || `[X] ${text}`),
-        warn: (msg) => console.log(msg || `[!] ${text}`),
-        info: (msg) => console.log(msg || `[i] ${text}`),
-        text: ''
-      })
-    };
-  };
-}
-
-const { colored } = require('./helpers');
-
-/**
- * ClaudeSymlinkManager - Manages selective symlinks from ~/.ccs/.claude/ to ~/.claude/
- * v4.1.0: Selective symlinking for CCS items
- *
- * Purpose: Ship CCS items (.claude/) with package and symlink them to user's ~/.claude/
- * Architecture:
- *   - ~/.ccs/.claude/* (source, ships with CCS)
- *   - ~/.claude/* (target, gets selective symlinks)
- *   - ~/.ccs/shared/ (UNTOUCHED, existing profile mechanism)
- *
- * Symlink Chain:
- *   profile -> ~/.ccs/shared/ -> ~/.claude/ (which has symlinks to ~/.ccs/.claude/)
- */
-class ClaudeSymlinkManager {
-  constructor() {
-    this.homeDir = os.homedir();
-    this.ccsClaudeDir = path.join(this.homeDir, '.ccs', '.claude');
-    this.userClaudeDir = path.join(this.homeDir, '.claude');
-
-    // CCS items to symlink (selective, item-level)
-    this.ccsItems = [
-      { source: 'commands/ccs.md', target: 'commands/ccs.md', type: 'file' },
-      { source: 'commands/ccs', target: 'commands/ccs', type: 'directory' },
-      { source: 'skills/ccs-delegation', target: 'skills/ccs-delegation', type: 'directory' }
-    ];
-  }
-
-  /**
-   * Install CCS items to user's ~/.claude/ via selective symlinks
-   * Safe: backs up existing files before creating symlinks
-   */
-  install(silent = false) {
-    const spinner = (silent || !ora) ? null : ora('Installing CCS items to ~/.claude/').start();
-
-    // Ensure ~/.ccs/.claude/ exists (should be shipped with package)
-    if (!fs.existsSync(this.ccsClaudeDir)) {
-      const msg = 'CCS .claude/ directory not found, skipping symlink installation';
-      if (spinner) {
-        spinner.warn(`[!] ${msg}`);
-      } else {
-        console.log(`[!] ${msg}`);
-      }
-      return;
-    }
-
-    // Create ~/.claude/ if missing
-    if (!fs.existsSync(this.userClaudeDir)) {
-      if (!silent) {
-        if (spinner) spinner.text = 'Creating ~/.claude/ directory';
-      }
-      fs.mkdirSync(this.userClaudeDir, { recursive: true, mode: 0o700 });
-    }
-
-    // Install each CCS item
-    let installed = 0;
-    for (const item of this.ccsItems) {
-      if (!silent && spinner) {
-        spinner.text = `Installing ${item.target}...`;
-      }
-      const result = this._installItem(item, silent);
-      if (result) installed++;
-    }
-
-    const msg = `${installed}/${this.ccsItems.length} items installed to ~/.claude/`;
-    if (spinner) {
-      spinner.succeed(colored('[OK]', 'green') + ` ${msg}`);
-    } else {
-      console.log(`[OK] ${msg}`);
-    }
-  }
-
-  /**
-   * Install a single CCS item with conflict handling
-   * @param {Object} item - Item descriptor {source, target, type}
-   * @param {boolean} silent - Suppress individual item messages
-   * @returns {boolean} True if installed successfully
-   * @private
-   */
-  _installItem(item, silent = false) {
-    const sourcePath = path.join(this.ccsClaudeDir, item.source);
-    const targetPath = path.join(this.userClaudeDir, item.target);
-    const targetDir = path.dirname(targetPath);
-
-    // Ensure source exists
-    if (!fs.existsSync(sourcePath)) {
-      if (!silent) console.log(`[!] Source not found: ${item.source}, skipping`);
-      return false;
-    }
-
-    // Create target parent directory if needed
-    if (!fs.existsSync(targetDir)) {
-      fs.mkdirSync(targetDir, { recursive: true, mode: 0o700 });
-    }
-
-    // Check if target already exists
-    if (fs.existsSync(targetPath)) {
-      // Check if it's already the correct symlink
-      if (this._isOurSymlink(targetPath, sourcePath)) {
-        return true; // Already correct, counts as success
-      }
-
-      // Backup existing file/directory
-      this._backupItem(targetPath, silent);
-    }
-
-    // Create symlink
-    try {
-      const symlinkType = item.type === 'directory' ? 'dir' : 'file';
-      fs.symlinkSync(sourcePath, targetPath, symlinkType);
-      if (!silent) console.log(`[OK] Symlinked ${item.target}`);
-      return true;
-    } catch (err) {
-      // Windows fallback: stub for now, full implementation in v4.2
-      if (process.platform === 'win32') {
-        if (!silent) {
-          console.log(`[!] Symlink failed for ${item.target} (Windows fallback deferred to v4.2)`);
-          console.log(`[i] Enable Developer Mode or wait for next update`);
-        }
-      } else {
-        if (!silent) console.log(`[!] Failed to symlink ${item.target}: ${err.message}`);
-      }
-      return false;
-    }
-  }
-
-  /**
-   * Check if target is already the correct symlink pointing to source
-   * @param {string} targetPath - Target path to check
-   * @param {string} expectedSource - Expected source path
-   * @returns {boolean} True if target is correct symlink
-   * @private
-   */
-  _isOurSymlink(targetPath, expectedSource) {
-    try {
-      const stats = fs.lstatSync(targetPath);
-
-      if (!stats.isSymbolicLink()) {
-        return false;
-      }
-
-      const actualTarget = fs.readlinkSync(targetPath);
-      const resolvedTarget = path.resolve(path.dirname(targetPath), actualTarget);
-
-      return resolvedTarget === expectedSource;
-    } catch (err) {
-      return false;
-    }
-  }
-
-  /**
-   * Backup existing item before replacing with symlink
-   * @param {string} itemPath - Path to item to backup
-   * @param {boolean} silent - Suppress backup messages
-   * @private
-   */
-  _backupItem(itemPath, silent = false) {
-    const timestamp = new Date().toISOString().replace(/[:.]/g, '-').split('T')[0];
-    const backupPath = `${itemPath}.backup-${timestamp}`;
-
-    try {
-      // If backup already exists, use counter
-      let finalBackupPath = backupPath;
-      let counter = 1;
-      while (fs.existsSync(finalBackupPath)) {
-        finalBackupPath = `${backupPath}-${counter}`;
-        counter++;
-      }
-
-      fs.renameSync(itemPath, finalBackupPath);
-      if (!silent) console.log(`[i] Backed up existing item to ${path.basename(finalBackupPath)}`);
-    } catch (err) {
-      if (!silent) console.log(`[!] Failed to backup ${itemPath}: ${err.message}`);
-      throw err; // Don't proceed if backup fails
-    }
-  }
-
-  /**
-   * Uninstall CCS items from ~/.claude/ (remove symlinks only)
-   * Safe: only removes items that are CCS symlinks
-   */
-  uninstall() {
-    let removed = 0;
-
-    for (const item of this.ccsItems) {
-      const targetPath = path.join(this.userClaudeDir, item.target);
-      const sourcePath = path.join(this.ccsClaudeDir, item.source);
-
-      // Only remove if it's our symlink
-      if (fs.existsSync(targetPath) && this._isOurSymlink(targetPath, sourcePath)) {
-        try {
-          fs.unlinkSync(targetPath);
-          console.log(`[OK] Removed ${item.target}`);
-          removed++;
-        } catch (err) {
-          console.log(`[!] Failed to remove ${item.target}: ${err.message}`);
-        }
-      }
-    }
-
-    if (removed > 0) {
-      console.log(`[OK] Removed ${removed} delegation commands and skills from ~/.claude/`);
-    } else {
-      console.log('[i] No delegation commands or skills to remove');
-    }
-  }
-
-  /**
-   * Check symlink health and report issues
-   * Used by 'ccs doctor' command
-   * @returns {Object} Health check results {healthy: boolean, issues: string[]}
-   */
-  checkHealth() {
-    const issues = [];
-    let healthy = true;
-
-    // Check if ~/.ccs/.claude/ exists
-    if (!fs.existsSync(this.ccsClaudeDir)) {
-      issues.push('CCS .claude/ directory missing (reinstall CCS)');
-      healthy = false;
-      return { healthy, issues };
-    }
-
-    // Check each item
-    for (const item of this.ccsItems) {
-      const sourcePath = path.join(this.ccsClaudeDir, item.source);
-      const targetPath = path.join(this.userClaudeDir, item.target);
-
-      // Check source exists
-      if (!fs.existsSync(sourcePath)) {
-        issues.push(`Source missing: ${item.source}`);
-        healthy = false;
-        continue;
-      }
-
-      // Check target
-      if (!fs.existsSync(targetPath)) {
-        issues.push(`Not installed: ${item.target} (run 'ccs sync' to install)`);
-        healthy = false;
-      } else if (!this._isOurSymlink(targetPath, sourcePath)) {
-        issues.push(`Not a CCS symlink: ${item.target} (run 'ccs sync' to fix)`);
-        healthy = false;
-      }
-    }
-
-    return { healthy, issues };
-  }
-
-  /**
-   * Sync delegation commands and skills to ~/.claude/ (used by 'ccs sync' command)
-   * Same as install() but with explicit sync message
-   */
-  sync() {
-    console.log('');
-    console.log(colored('Syncing CCS Components...', 'cyan'));
-    console.log('');
-    this.install(false);
-  }
-}
-
-module.exports = ClaudeSymlinkManager;

package/bin/utils/config-manager.js

@@ -1,103 +0,0 @@
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-const { error, expandPath } = require('./helpers');
-const { ErrorManager } = require('./error-manager');
-
-// Get config file path
-function getConfigPath() {
-  return process.env.CCS_CONFIG || path.join(os.homedir(), '.ccs', 'config.json');
-}
-
-// Read and parse config
-function readConfig() {
-  const configPath = getConfigPath();
-
-  // Check config exists
-  if (!fs.existsSync(configPath)) {
-    // Attempt recovery
-    const RecoveryManager = require('./recovery-manager');
-    const recovery = new RecoveryManager();
-    recovery.ensureConfigJson();
-
-    if (!fs.existsSync(configPath)) {
-      ErrorManager.showInvalidConfig(configPath, 'File not found');
-      process.exit(1);
-    }
-  }
-
-  // Read and parse JSON
-  let config;
-  try {
-    const configContent = fs.readFileSync(configPath, 'utf8');
-    config = JSON.parse(configContent);
-  } catch (e) {
-    ErrorManager.showInvalidConfig(configPath, `Invalid JSON: ${e.message}`);
-    process.exit(1);
-  }
-
-  // Validate config has profiles object
-  if (!config.profiles || typeof config.profiles !== 'object') {
-    ErrorManager.showInvalidConfig(configPath, "Missing 'profiles' object");
-    process.exit(1);
-  }
-
-  return config;
-}
-
-// Get settings path for profile
-function getSettingsPath(profile) {
-  const config = readConfig();
-
-  // Get settings path
-  const settingsPath = config.profiles[profile];
-
-  if (!settingsPath) {
-    const availableProfiles = Object.keys(config.profiles);
-    const profileList = availableProfiles.map(p => `  - ${p}`);
-    ErrorManager.showProfileNotFound(profile, profileList);
-    process.exit(1);
-  }
-
-  // Expand path
-  const expandedPath = expandPath(settingsPath);
-
-  // Validate settings file exists
-  if (!fs.existsSync(expandedPath)) {
-    // Auto-create if it's ~/.claude/settings.json
-    if (expandedPath.includes('.claude') && expandedPath.endsWith('settings.json')) {
-      const RecoveryManager = require('./recovery-manager');
-      const recovery = new RecoveryManager();
-      recovery.ensureClaudeSettings();
-
-      if (!fs.existsSync(expandedPath)) {
-        ErrorManager.showSettingsNotFound(expandedPath);
-        process.exit(1);
-      }
-
-      console.log('[i] Auto-created missing settings file');
-    } else {
-      ErrorManager.showSettingsNotFound(expandedPath);
-      process.exit(1);
-    }
-  }
-
-  // Validate settings file is valid JSON
-  try {
-    const settingsContent = fs.readFileSync(expandedPath, 'utf8');
-    JSON.parse(settingsContent);
-  } catch (e) {
-    ErrorManager.showInvalidConfig(expandedPath, `Invalid JSON: ${e.message}`);
-    process.exit(1);
-  }
-
-  return expandedPath;
-}
-
-module.exports = {
-  getConfigPath,
-  readConfig,
-  getSettingsPath
-};