@kaitranntt/ccs 3.4.6 → 3.5.0

package/bin/utils/progress-indicator.js

@@ -0,0 +1,111 @@
+'use strict';
+
+/**
+ * Simple Progress Indicator (no external dependencies)
+ *
+ * Features:
+ * - ASCII-only spinner frames (cross-platform compatible)
+ * - TTY detection (no spinners in pipes/logs)
+ * - Elapsed time display
+ * - CI environment detection
+ */
+
+class ProgressIndicator {
+  /**
+   * Create a progress indicator
+   * @param {string} message - Message to display
+   * @param {Object} options - Options
+   * @param {string[]} options.frames - Spinner frames (default: ASCII)
+   * @param {number} options.interval - Frame interval in ms (default: 80)
+   */
+  constructor(message, options = {}) {
+    this.message = message;
+    // ASCII-only frames for cross-platform compatibility
+    this.frames = options.frames || ['|', '/', '-', '\\'];
+    this.frameIndex = 0;
+    this.interval = null;
+    this.startTime = Date.now();
+
+    // TTY detection: only animate if stderr is TTY and not in CI
+    this.isTTY = process.stderr.isTTY === true && !process.env.CI && !process.env.NO_COLOR;
+  }
+
+  /**
+   * Start the spinner
+   */
+  start() {
+    if (!this.isTTY) {
+      // Non-TTY: just print message once
+      process.stderr.write(`[i] ${this.message}...\n`);
+      return;
+    }
+
+    // TTY: animate spinner
+    this.interval = setInterval(() => {
+      const frame = this.frames[this.frameIndex];
+      const elapsed = ((Date.now() - this.startTime) / 1000).toFixed(1);
+      process.stderr.write(`\r[${frame}] ${this.message}... (${elapsed}s)`);
+      this.frameIndex = (this.frameIndex + 1) % this.frames.length;
+    }, 80); // 12.5fps for smooth animation
+  }
+
+  /**
+   * Stop spinner with success message
+   * @param {string} message - Optional success message (defaults to original message)
+   */
+  succeed(message) {
+    this.stop();
+    const finalMessage = message || this.message;
+    const elapsed = ((Date.now() - this.startTime) / 1000).toFixed(1);
+
+    if (this.isTTY) {
+      // Clear spinner line and show success
+      process.stderr.write(`\r[OK] ${finalMessage} (${elapsed}s)\n`);
+    } else {
+      // Non-TTY: just show completion
+      process.stderr.write(`[OK] ${finalMessage}\n`);
+    }
+  }
+
+  /**
+   * Stop spinner with failure message
+   * @param {string} message - Optional failure message (defaults to original message)
+   */
+  fail(message) {
+    this.stop();
+    const finalMessage = message || this.message;
+
+    if (this.isTTY) {
+      // Clear spinner line and show failure
+      process.stderr.write(`\r[X] ${finalMessage}\n`);
+    } else {
+      // Non-TTY: just show failure
+      process.stderr.write(`[X] ${finalMessage}\n`);
+    }
+  }
+
+  /**
+   * Update spinner message (while running)
+   * @param {string} newMessage - New message to display
+   */
+  update(newMessage) {
+    this.message = newMessage;
+  }
+
+  /**
+   * Stop the spinner without showing success/failure
+   */
+  stop() {
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+
+      if (this.isTTY) {
+        // Clear the spinner line
+        process.stderr.write('\r\x1b[K');
+      }
+    }
+  }
+}
+
+module.exports = { ProgressIndicator };

package/bin/utils/prompt.js

@@ -0,0 +1,134 @@
+'use strict';
+
+const readline = require('readline');
+
+/**
+ * Interactive Prompt Utilities (NO external dependencies)
+ *
+ * Features:
+ * - TTY detection (auto-confirm in non-TTY)
+ * - --yes flag support for automation
+ * - --no-input flag support for CI
+ * - Safe defaults (N for destructive actions)
+ * - Input validation with retry
+ */
+
+class InteractivePrompt {
+  /**
+   * Ask for confirmation
+   * @param {string} message - Confirmation message
+   * @param {Object} options - Options
+   * @param {boolean} options.default - Default value (true=Yes, false=No)
+   * @returns {Promise<boolean>} User confirmation
+   */
+  static async confirm(message, options = {}) {
+    const { default: defaultValue = false } = options;
+
+    // Check for --yes flag (automation) - always returns true
+    if (process.env.CCS_YES === '1' || process.argv.includes('--yes') || process.argv.includes('-y')) {
+      return true;
+    }
+
+    // Check for --no-input flag (CI)
+    if (process.env.CCS_NO_INPUT === '1' || process.argv.includes('--no-input')) {
+      throw new Error('Interactive input required but --no-input specified');
+    }
+
+    // Non-TTY: use default
+    if (!process.stdin.isTTY) {
+      return defaultValue;
+    }
+
+    // Interactive prompt
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stderr,
+      terminal: true
+    });
+
+    const promptText = defaultValue
+      ? `${message} [Y/n]: `
+      : `${message} [y/N]: `;
+
+    return new Promise((resolve) => {
+      rl.question(promptText, (answer) => {
+        rl.close();
+
+        const normalized = answer.trim().toLowerCase();
+
+        // Empty answer: use default
+        if (normalized === '') {
+          resolve(defaultValue);
+          return;
+        }
+
+        // Valid answers
+        if (normalized === 'y' || normalized === 'yes') {
+          resolve(true);
+          return;
+        }
+
+        if (normalized === 'n' || normalized === 'no') {
+          resolve(false);
+          return;
+        }
+
+        // Invalid input: retry
+        console.error('[!] Please answer y or n');
+        resolve(InteractivePrompt.confirm(message, options));
+      });
+    });
+  }
+
+  /**
+   * Get text input from user
+   * @param {string} message - Prompt message
+   * @param {Object} options - Options
+   * @param {string} options.default - Default value
+   * @param {Function} options.validate - Validation function
+   * @returns {Promise<string>} User input
+   */
+  static async input(message, options = {}) {
+    const { default: defaultValue = '', validate = null } = options;
+
+    // Non-TTY: use default or error
+    if (!process.stdin.isTTY) {
+      if (defaultValue) {
+        return defaultValue;
+      }
+      throw new Error('Interactive input required but stdin is not a TTY');
+    }
+
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stderr,
+      terminal: true
+    });
+
+    const promptText = defaultValue
+      ? `${message} [${defaultValue}]: `
+      : `${message}: `;
+
+    return new Promise((resolve) => {
+      rl.question(promptText, (answer) => {
+        rl.close();
+
+        const value = answer.trim() || defaultValue;
+
+        // Validate input if validator provided
+        if (validate) {
+          const error = validate(value);
+          if (error) {
+            console.error(`[!] ${error}`);
+            resolve(InteractivePrompt.input(message, options));
+            return;
+          }
+        }
+
+        resolve(value);
+      });
+    });
+  }
+}
+
+module.exports = { InteractivePrompt };

package/bin/utils/shell-completion.js

@@ -0,0 +1,234 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { execSync } = require('child_process');
+
+/**
+ * Shell Completion Installer
+ * Auto-configures shell completion for bash, zsh, fish, PowerShell
+ */
+
+class ShellCompletionInstaller {
+  constructor() {
+    this.homeDir = os.homedir();
+    this.ccsDir = path.join(this.homeDir, '.ccs');
+    this.completionDir = path.join(this.ccsDir, 'completions');
+    this.scriptsDir = path.join(__dirname, '../../scripts/completion');
+  }
+
+  /**
+   * Detect current shell
+   */
+  detectShell() {
+    const shell = process.env.SHELL || '';
+
+    if (shell.includes('bash')) return 'bash';
+    if (shell.includes('zsh')) return 'zsh';
+    if (shell.includes('fish')) return 'fish';
+    if (process.platform === 'win32') return 'powershell';
+
+    return null;
+  }
+
+  /**
+   * Ensure completion files are in ~/.ccs/completions/
+   */
+  ensureCompletionFiles() {
+    if (!fs.existsSync(this.completionDir)) {
+      fs.mkdirSync(this.completionDir, { recursive: true });
+    }
+
+    // Copy completion scripts
+    const files = ['ccs.bash', 'ccs.zsh', 'ccs.fish', 'ccs.ps1'];
+    files.forEach(file => {
+      const src = path.join(this.scriptsDir, file);
+      const dest = path.join(this.completionDir, file);
+
+      if (fs.existsSync(src)) {
+        fs.copyFileSync(src, dest);
+      }
+    });
+  }
+
+  /**
+   * Install bash completion
+   */
+  installBash() {
+    const rcFile = path.join(this.homeDir, '.bashrc');
+    const completionPath = path.join(this.completionDir, 'ccs.bash');
+
+    if (!fs.existsSync(completionPath)) {
+      throw new Error('Completion file not found. Please reinstall CCS.');
+    }
+
+    const marker = '# CCS shell completion';
+    const sourceCmd = `source "${completionPath}"`;
+    const block = `\n${marker}\n${sourceCmd}\n`;
+
+    // Check if already installed
+    if (fs.existsSync(rcFile)) {
+      const content = fs.readFileSync(rcFile, 'utf8');
+      if (content.includes(marker)) {
+        return { success: true, alreadyInstalled: true };
+      }
+    }
+
+    // Append to .bashrc
+    fs.appendFileSync(rcFile, block);
+
+    return {
+      success: true,
+      message: `Added to ${rcFile}`,
+      reload: 'source ~/.bashrc'
+    };
+  }
+
+  /**
+   * Install zsh completion
+   */
+  installZsh() {
+    const rcFile = path.join(this.homeDir, '.zshrc');
+    const completionPath = path.join(this.completionDir, 'ccs.zsh');
+    const zshCompDir = path.join(this.homeDir, '.zsh', 'completion');
+
+    if (!fs.existsSync(completionPath)) {
+      throw new Error('Completion file not found. Please reinstall CCS.');
+    }
+
+    // Create zsh completion directory
+    if (!fs.existsSync(zshCompDir)) {
+      fs.mkdirSync(zshCompDir, { recursive: true });
+    }
+
+    // Copy to zsh completion directory
+    const destFile = path.join(zshCompDir, '_ccs');
+    fs.copyFileSync(completionPath, destFile);
+
+    const marker = '# CCS shell completion';
+    const setupCmds = [
+      'fpath=(~/.zsh/completion $fpath)',
+      'autoload -Uz compinit && compinit'
+    ];
+    const block = `\n${marker}\n${setupCmds.join('\n')}\n`;
+
+    // Check if already installed
+    if (fs.existsSync(rcFile)) {
+      const content = fs.readFileSync(rcFile, 'utf8');
+      if (content.includes(marker)) {
+        return { success: true, alreadyInstalled: true };
+      }
+    }
+
+    // Append to .zshrc
+    fs.appendFileSync(rcFile, block);
+
+    return {
+      success: true,
+      message: `Added to ${rcFile}`,
+      reload: 'source ~/.zshrc'
+    };
+  }
+
+  /**
+   * Install fish completion
+   */
+  installFish() {
+    const completionPath = path.join(this.completionDir, 'ccs.fish');
+    const fishCompDir = path.join(this.homeDir, '.config', 'fish', 'completions');
+
+    if (!fs.existsSync(completionPath)) {
+      throw new Error('Completion file not found. Please reinstall CCS.');
+    }
+
+    // Create fish completion directory
+    if (!fs.existsSync(fishCompDir)) {
+      fs.mkdirSync(fishCompDir, { recursive: true });
+    }
+
+    // Copy to fish completion directory (fish auto-loads from here)
+    const destFile = path.join(fishCompDir, 'ccs.fish');
+    fs.copyFileSync(completionPath, destFile);
+
+    return {
+      success: true,
+      message: `Installed to ${destFile}`,
+      reload: 'Fish auto-loads completions (no reload needed)'
+    };
+  }
+
+  /**
+   * Install PowerShell completion
+   */
+  installPowerShell() {
+    const profilePath = process.env.PROFILE || path.join(
+      this.homeDir,
+      'Documents',
+      'PowerShell',
+      'Microsoft.PowerShell_profile.ps1'
+    );
+    const completionPath = path.join(this.completionDir, 'ccs.ps1');
+
+    if (!fs.existsSync(completionPath)) {
+      throw new Error('Completion file not found. Please reinstall CCS.');
+    }
+
+    const marker = '# CCS shell completion';
+    const sourceCmd = `. "${completionPath.replace(/\\/g, '\\\\')}"`;
+    const block = `\n${marker}\n${sourceCmd}\n`;
+
+    // Create profile directory if needed
+    const profileDir = path.dirname(profilePath);
+    if (!fs.existsSync(profileDir)) {
+      fs.mkdirSync(profileDir, { recursive: true });
+    }
+
+    // Check if already installed
+    if (fs.existsSync(profilePath)) {
+      const content = fs.readFileSync(profilePath, 'utf8');
+      if (content.includes(marker)) {
+        return { success: true, alreadyInstalled: true };
+      }
+    }
+
+    // Append to PowerShell profile
+    fs.appendFileSync(profilePath, block);
+
+    return {
+      success: true,
+      message: `Added to ${profilePath}`,
+      reload: '. $PROFILE'
+    };
+  }
+
+  /**
+   * Install for detected or specified shell
+   */
+  install(shell = null) {
+    const targetShell = shell || this.detectShell();
+
+    if (!targetShell) {
+      throw new Error('Could not detect shell. Please specify: --bash, --zsh, --fish, or --powershell');
+    }
+
+    // Ensure completion files exist
+    this.ensureCompletionFiles();
+
+    // Install for target shell
+    switch (targetShell) {
+      case 'bash':
+        return this.installBash();
+      case 'zsh':
+        return this.installZsh();
+      case 'fish':
+        return this.installFish();
+      case 'powershell':
+        return this.installPowerShell();
+      default:
+        throw new Error(`Unsupported shell: ${targetShell}`);
+    }
+  }
+}
+
+module.exports = { ShellCompletionInstaller };