@kaitranntt/ccs 4.1.6 → 4.3.0

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

@@ -3,6 +3,8 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const ora = require('ora');
+const { colored } = require('./helpers');
 
 /**
  * ClaudeSymlinkManager - Manages selective symlinks from ~/.ccs/.claude/ to ~/.claude/
@@ -35,41 +37,62 @@ class ClaudeSymlinkManager {
    * Install CCS items to user's ~/.claude/ via selective symlinks
    * Safe: backs up existing files before creating symlinks
    */
-  install() {
+  install(silent = false) {
+    const spinner = silent ? null : ora('Installing CCS items to ~/.claude/').start();
+
     // Ensure ~/.ccs/.claude/ exists (should be shipped with package)
     if (!fs.existsSync(this.ccsClaudeDir)) {
-      console.log('[!] CCS .claude/ directory not found, skipping symlink installation');
+      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)) {
-      console.log('[i] Creating ~/.claude/ directory');
+      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) {
-      this._installItem(item);
+      if (!silent && spinner) {
+        spinner.text = `Installing ${item.target}...`;
+      }
+      const result = this._installItem(item, silent);
+      if (result) installed++;
     }
 
-    console.log('[OK] Delegation commands and skills installed to ~/.claude/');
+    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) {
+  _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)) {
-      console.log(`[!] Source not found: ${item.source}, skipping`);
-      return;
+      if (!silent) console.log(`[!] Source not found: ${item.source}, skipping`);
+      return false;
     }
 
     // Create target parent directory if needed
@@ -81,26 +104,30 @@ class ClaudeSymlinkManager {
     if (fs.existsSync(targetPath)) {
       // Check if it's already the correct symlink
       if (this._isOurSymlink(targetPath, sourcePath)) {
-        return; // Already correct, skip
+        return true; // Already correct, counts as success
       }
 
       // Backup existing file/directory
-      this._backupItem(targetPath);
+      this._backupItem(targetPath, silent);
     }
 
     // Create symlink
     try {
       const symlinkType = item.type === 'directory' ? 'dir' : 'file';
       fs.symlinkSync(sourcePath, targetPath, symlinkType);
-      console.log(`[OK] Symlinked ${item.target}`);
+      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') {
-        console.log(`[!] Symlink failed for ${item.target} (Windows fallback deferred to v4.2)`);
-        console.log(`[i] Enable Developer Mode or wait for next update`);
+        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 {
-        console.log(`[!] Failed to symlink ${item.target}: ${err.message}`);
+        if (!silent) console.log(`[!] Failed to symlink ${item.target}: ${err.message}`);
       }
+      return false;
     }
   }
 
@@ -131,9 +158,10 @@ class ClaudeSymlinkManager {
   /**
    * Backup existing item before replacing with symlink
    * @param {string} itemPath - Path to item to backup
+   * @param {boolean} silent - Suppress backup messages
    * @private
    */
-  _backupItem(itemPath) {
+  _backupItem(itemPath, silent = false) {
     const timestamp = new Date().toISOString().replace(/[:.]/g, '-').split('T')[0];
     const backupPath = `${itemPath}.backup-${timestamp}`;
 
@@ -147,9 +175,9 @@ class ClaudeSymlinkManager {
       }
 
       fs.renameSync(itemPath, finalBackupPath);
-      console.log(`[i] Backed up existing item to ${path.basename(finalBackupPath)}`);
+      if (!silent) console.log(`[i] Backed up existing item to ${path.basename(finalBackupPath)}`);
     } catch (err) {
-      console.log(`[!] Failed to backup ${itemPath}: ${err.message}`);
+      if (!silent) console.log(`[!] Failed to backup ${itemPath}: ${err.message}`);
       throw err; // Don't proceed if backup fails
     }
   }
@@ -230,8 +258,10 @@ class ClaudeSymlinkManager {
    * Same as install() but with explicit sync message
    */
   sync() {
-    console.log('[i] Syncing delegation commands and skills to ~/.claude/...');
-    this.install();
+    console.log('');
+    console.log(colored('Syncing CCS Components...', 'cyan'));
+    console.log('');
+    this.install(false);
   }
 }
 

package/bin/utils/update-checker.js

@@ -0,0 +1,243 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const https = require('https');
+const { colored } = require('./helpers');
+
+const UPDATE_CHECK_FILE = path.join(os.homedir(), '.ccs', 'update-check.json');
+const CHECK_INTERVAL = 24 * 60 * 60 * 1000; // 24 hours
+const GITHUB_API_URL = 'https://api.github.com/repos/kaitranntt/ccs/releases/latest';
+const NPM_REGISTRY_URL = 'https://registry.npmjs.org/@kaitranntt/ccs/latest';
+const REQUEST_TIMEOUT = 5000; // 5 seconds
+
+/**
+ * Compare semantic versions
+ * @param {string} v1 - First version (e.g., "4.1.6")
+ * @param {string} v2 - Second version
+ * @returns {number} - 1 if v1 > v2, -1 if v1 < v2, 0 if equal
+ */
+function compareVersions(v1, v2) {
+  const parts1 = v1.replace(/^v/, '').split('.').map(Number);
+  const parts2 = v2.replace(/^v/, '').split('.').map(Number);
+
+  for (let i = 0; i < 3; i++) {
+    const p1 = parts1[i] || 0;
+    const p2 = parts2[i] || 0;
+    if (p1 > p2) return 1;
+    if (p1 < p2) return -1;
+  }
+  return 0;
+}
+
+/**
+ * Fetch latest version from GitHub releases
+ * @returns {Promise<string|null>} - Latest version or null on error
+ */
+function fetchLatestVersionFromGitHub() {
+  return new Promise((resolve) => {
+    const req = https.get(GITHUB_API_URL, {
+      headers: { 'User-Agent': 'CCS-Update-Checker' },
+      timeout: REQUEST_TIMEOUT
+    }, (res) => {
+      let data = '';
+
+      res.on('data', (chunk) => {
+        data += chunk;
+      });
+
+      res.on('end', () => {
+        try {
+          if (res.statusCode !== 200) {
+            resolve(null);
+            return;
+          }
+
+          const release = JSON.parse(data);
+          const version = release.tag_name?.replace(/^v/, '') || null;
+          resolve(version);
+        } catch (err) {
+          resolve(null);
+        }
+      });
+    });
+
+    req.on('error', () => resolve(null));
+    req.on('timeout', () => {
+      req.destroy();
+      resolve(null);
+    });
+  });
+}
+
+/**
+ * Fetch latest version from npm registry
+ * @returns {Promise<string|null>} - Latest version or null on error
+ */
+function fetchLatestVersionFromNpm() {
+  return new Promise((resolve) => {
+    const req = https.get(NPM_REGISTRY_URL, {
+      headers: { 'User-Agent': 'CCS-Update-Checker' },
+      timeout: REQUEST_TIMEOUT
+    }, (res) => {
+      let data = '';
+
+      res.on('data', (chunk) => {
+        data += chunk;
+      });
+
+      res.on('end', () => {
+        try {
+          if (res.statusCode !== 200) {
+            resolve(null);
+            return;
+          }
+
+          const packageData = JSON.parse(data);
+          const version = packageData.version || null;
+          resolve(version);
+        } catch (err) {
+          resolve(null);
+        }
+      });
+    });
+
+    req.on('error', () => resolve(null));
+    req.on('timeout', () => {
+      req.destroy();
+      resolve(null);
+    });
+  });
+}
+
+/**
+ * Read update check cache
+ * @returns {Object} - Cache object
+ */
+function readCache() {
+  try {
+    if (!fs.existsSync(UPDATE_CHECK_FILE)) {
+      return { last_check: 0, latest_version: null, dismissed_version: null };
+    }
+
+    const data = fs.readFileSync(UPDATE_CHECK_FILE, 'utf8');
+    return JSON.parse(data);
+  } catch (err) {
+    return { last_check: 0, latest_version: null, dismissed_version: null };
+  }
+}
+
+/**
+ * Write update check cache
+ * @param {Object} cache - Cache object to write
+ */
+function writeCache(cache) {
+  try {
+    const ccsDir = path.join(os.homedir(), '.ccs');
+    if (!fs.existsSync(ccsDir)) {
+      fs.mkdirSync(ccsDir, { recursive: true, mode: 0o700 });
+    }
+
+    fs.writeFileSync(UPDATE_CHECK_FILE, JSON.stringify(cache, null, 2), 'utf8');
+  } catch (err) {
+    // Silently fail - not critical
+  }
+}
+
+/**
+ * Check for updates (async, non-blocking)
+ * @param {string} currentVersion - Current CCS version
+ * @param {boolean} force - Force check even if within interval
+ * @param {string} installMethod - Installation method ('npm' or 'direct')
+ * @returns {Promise<Object>} - Update result object with status and data
+ */
+async function checkForUpdates(currentVersion, force = false, installMethod = 'direct') {
+  const cache = readCache();
+  const now = Date.now();
+
+  // Check if we should check for updates
+  if (!force && (now - cache.last_check < CHECK_INTERVAL)) {
+    // Use cached result if available
+    if (cache.latest_version && compareVersions(cache.latest_version, currentVersion) > 0) {
+      // Don't show if user dismissed this version
+      if (cache.dismissed_version === cache.latest_version) {
+        return { status: 'no_update', reason: 'dismissed' };
+      }
+      return { status: 'update_available', latest: cache.latest_version, current: currentVersion };
+    }
+    return { status: 'no_update', reason: 'cached' };
+  }
+
+  // Fetch latest version from appropriate source
+  let latestVersion;
+  let fetchError = null;
+
+  if (installMethod === 'npm') {
+    latestVersion = await fetchLatestVersionFromNpm();
+    if (!latestVersion) fetchError = 'npm_registry_error';
+  } else {
+    latestVersion = await fetchLatestVersionFromGitHub();
+    if (!latestVersion) fetchError = 'github_api_error';
+  }
+
+  // Update cache
+  cache.last_check = now;
+  if (latestVersion) {
+    cache.latest_version = latestVersion;
+  }
+  writeCache(cache);
+
+  // Handle fetch errors
+  if (fetchError) {
+    return {
+      status: 'check_failed',
+      reason: fetchError,
+      message: `Failed to check for updates: ${fetchError.replace(/_/g, ' ')}`
+    };
+  }
+
+  // Check if update available
+  if (latestVersion && compareVersions(latestVersion, currentVersion) > 0) {
+    // Don't show if user dismissed this version
+    if (cache.dismissed_version === latestVersion) {
+      return { status: 'no_update', reason: 'dismissed' };
+    }
+    return { status: 'update_available', latest: latestVersion, current: currentVersion };
+  }
+
+  return { status: 'no_update', reason: 'latest' };
+}
+
+/**
+ * Show update notification
+ * @param {Object} updateInfo - Update information
+ */
+function showUpdateNotification(updateInfo) {
+  console.log('');
+  console.log(colored('═══════════════════════════════════════════════════════', 'cyan'));
+  console.log(colored(`  Update available: ${updateInfo.current} → ${updateInfo.latest}`, 'yellow'));
+  console.log(colored('═══════════════════════════════════════════════════════', 'cyan'));
+  console.log('');
+  console.log(`  Run ${colored('ccs update', 'yellow')} to update`);
+  console.log('');
+}
+
+/**
+ * Dismiss update notification for a specific version
+ * @param {string} version - Version to dismiss
+ */
+function dismissUpdate(version) {
+  const cache = readCache();
+  cache.dismissed_version = version;
+  writeCache(cache);
+}
+
+module.exports = {
+  compareVersions,
+  checkForUpdates,
+  showUpdateNotification,
+  dismissUpdate,
+  readCache,
+  writeCache
+};

package/lib/ccs

@@ -2,7 +2,7 @@
 set -euo pipefail
 
 # Version (updated by scripts/bump-version.sh)
-CCS_VERSION="4.1.6"
+CCS_VERSION="4.3.0"
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 readonly CONFIG_FILE="${CCS_CONFIG:-$HOME/.ccs/config.json}"
 readonly PROFILES_JSON="$HOME/.ccs/profiles.json"
@@ -199,6 +199,7 @@ show_help() {
   echo -e "${CYAN}Diagnostics:${RESET}"
   echo -e "  ${YELLOW}ccs doctor${RESET}                  Run health check and diagnostics"
   echo -e "  ${YELLOW}ccs sync${RESET}                    Sync delegation commands and skills"
+  echo -e "  ${YELLOW}ccs update${RESET}                  Update CCS to latest version"
   echo ""
 
   echo -e "${CYAN}Flags:${RESET}"
@@ -591,6 +592,124 @@ sync_run() {
   echo ""
 }
 
+# --- Update Command ---
+
+update_run() {
+  echo ""
+  echo -e "${CYAN}Checking for updates...${RESET}"
+  echo ""
+
+  # Detect installation method
+  local install_method="direct"
+  if command -v npm &>/dev/null && npm list -g @kaitranntt/ccs &>/dev/null 2>&1; then
+    install_method="npm"
+  fi
+
+  # Fetch latest version from appropriate source
+  local latest_version=""
+  if command -v curl &>/dev/null; then
+    if [[ "$install_method" == "npm" ]]; then
+      # Check npm registry for npm installations
+      latest_version=$(curl -fsSL https://registry.npmjs.org/@kaitranntt/ccs/latest 2>/dev/null | \
+        grep '"version"' | head -1 | sed -E 's/.*"version"[[:space:]]*:[[:space:]]*"([0-9.]+)".*/\1/')
+    else
+      # Check GitHub releases for direct installations
+      latest_version=$(curl -fsSL https://api.github.com/repos/kaitranntt/ccs/releases/latest 2>/dev/null | \
+        grep '"tag_name"' | sed -E 's/.*"v?([0-9.]+)".*/\1/')
+    fi
+  fi
+
+  if [[ -z "$latest_version" ]]; then
+    echo -e "${YELLOW}[!] Unable to check for updates${RESET}"
+    echo ""
+    echo "Try manually:"
+    if [[ "$install_method" == "npm" ]]; then
+      echo -e "  ${YELLOW}npm install -g @kaitranntt/ccs@latest${RESET}"
+    else
+      echo -e "  ${YELLOW}curl -fsSL ccs.kaitran.ca/install | bash${RESET}"
+    fi
+    echo ""
+    exit 1
+  fi
+
+  # Compare versions
+  if [[ "$latest_version" == "$CCS_VERSION" ]]; then
+    echo -e "${GREEN}[OK] You are already on the latest version (${CCS_VERSION})${RESET}"
+    echo ""
+    exit 0
+  fi
+
+  # Check if update available
+  local current_major=$(echo "$CCS_VERSION" | cut -d. -f1)
+  local current_minor=$(echo "$CCS_VERSION" | cut -d. -f2)
+  local current_patch=$(echo "$CCS_VERSION" | cut -d. -f3)
+
+  local latest_major=$(echo "$latest_version" | cut -d. -f1)
+  local latest_minor=$(echo "$latest_version" | cut -d. -f2)
+  local latest_patch=$(echo "$latest_version" | cut -d. -f3)
+
+  local is_newer=0
+  if [[ $latest_major -gt $current_major ]]; then
+    is_newer=1
+  elif [[ $latest_major -eq $current_major ]] && [[ $latest_minor -gt $current_minor ]]; then
+    is_newer=1
+  elif [[ $latest_major -eq $current_major ]] && [[ $latest_minor -eq $current_minor ]] && [[ $latest_patch -gt $current_patch ]]; then
+    is_newer=1
+  fi
+
+  if [[ $is_newer -eq 0 ]]; then
+    echo -e "${GREEN}[OK] You are on version ${CCS_VERSION} (latest is ${latest_version})${RESET}"
+    echo ""
+    exit 0
+  fi
+
+  echo -e "${YELLOW}[i] Update available: ${CCS_VERSION} → ${latest_version}${RESET}"
+  echo ""
+
+  # Perform update based on installation method
+  if [[ "$install_method" == "npm" ]]; then
+    echo -e "${CYAN}Updating via npm...${RESET}"
+    echo ""
+
+    if npm install -g @kaitranntt/ccs@latest; then
+      echo ""
+      echo -e "${GREEN}[OK] Update successful!${RESET}"
+      echo ""
+      echo -e "Run ${YELLOW}ccs --version${RESET} to verify"
+      echo ""
+      exit 0
+    else
+      echo ""
+      echo -e "${RED}[X] Update failed${RESET}"
+      echo ""
+      echo "Try manually:"
+      echo -e "  ${YELLOW}npm install -g @kaitranntt/ccs@latest${RESET}"
+      echo ""
+      exit 1
+    fi
+  else
+    echo -e "${CYAN}Updating via installer...${RESET}"
+    echo ""
+
+    if curl -fsSL ccs.kaitran.ca/install | bash; then
+      echo ""
+      echo -e "${GREEN}[OK] Update successful!${RESET}"
+      echo ""
+      echo -e "Run ${YELLOW}ccs --version${RESET} to verify"
+      echo ""
+      exit 0
+    else
+      echo ""
+      echo -e "${RED}[X] Update failed${RESET}"
+      echo ""
+      echo "Try manually:"
+      echo -e "  ${YELLOW}curl -fsSL ccs.kaitran.ca/install | bash${RESET}"
+      echo ""
+      exit 1
+    fi
+  fi
+}
+
 # --- Claude CLI Detection Logic ---
 
 detect_claude_cli() {
@@ -1669,6 +1788,12 @@ if [[ $# -gt 0 ]] && [[ "${1}" == "sync" || "${1}" == "--sync" ]]; then
   exit $?
 fi
 
+# Special case: update command
+if [[ $# -gt 0 ]] && [[ "${1}" == "update" || "${1}" == "--update" ]]; then
+  update_run
+  exit $?
+fi
+
 # Run auto-recovery before main logic
 auto_recover || {
   msg_error "Auto-recovery failed. Check permissions."