zuppaclaude 1.0.0

package/lib/uninstaller.js

@@ -0,0 +1,119 @@
+/**
+ * ZuppaClaude Uninstaller
+ */
+
+const { Logger } = require('./utils/logger');
+const { Prompts } = require('./utils/prompts');
+const { Settings } = require('./settings');
+const {
+  SuperClaudeInstaller,
+  SpecKitInstaller,
+  ConfigInstaller,
+  ClaudeZInstaller,
+  ClaudeHUDInstaller
+} = require('./components');
+
+class Uninstaller {
+  constructor() {
+    this.logger = new Logger();
+    this.prompts = new Prompts();
+    this.settings = new Settings();
+
+    // Component installers
+    this.superClaude = new SuperClaudeInstaller();
+    this.specKit = new SpecKitInstaller();
+    this.config = new ConfigInstaller();
+    this.claudeZ = new ClaudeZInstaller();
+    this.claudeHUD = new ClaudeHUDInstaller();
+  }
+
+  /**
+   * Run the uninstaller
+   */
+  async run() {
+    console.log('');
+    console.log('\x1b[35m╔═══════════════════════════════════════════════════════════════════╗\x1b[0m');
+    console.log('\x1b[35m║   ZuppaClaude Uninstaller                                         ║\x1b[0m');
+    console.log('\x1b[35m╚═══════════════════════════════════════════════════════════════════╝\x1b[0m');
+    console.log('');
+
+    // Confirm uninstallation
+    const confirm = await this.prompts.confirm('Are you sure you want to uninstall ZuppaClaude?', false);
+    if (!confirm) {
+      this.logger.info('Uninstallation cancelled');
+      return false;
+    }
+
+    // Ask about settings preservation
+    const preserveSettings = await this.prompts.confirm('Preserve settings for future reinstall?', true);
+
+    console.log('');
+    this.logger.info('Removing components...');
+    console.log('');
+
+    // Uninstall components
+    const results = {
+      superClaude: this.superClaude.uninstall(),
+      specKit: this.specKit.uninstall(),
+      config: this.config.uninstall(),
+      claudeZ: this.claudeZ.uninstall(),
+      claudeHUD: this.claudeHUD.uninstall()
+    };
+
+    // Handle settings
+    if (!preserveSettings) {
+      this.settings.reset();
+      this.logger.success('Settings removed');
+    } else {
+      this.logger.info('Settings preserved for future reinstall');
+    }
+
+    // Print summary
+    this.printSummary(results, preserveSettings);
+
+    return true;
+  }
+
+  /**
+   * Print uninstallation summary
+   */
+  printSummary(results, settingsPreserved) {
+    console.log('');
+    console.log('═══════════════════════════════════════════════════════════════════');
+    console.log('                    Uninstallation Complete');
+    console.log('═══════════════════════════════════════════════════════════════════');
+    console.log('');
+
+    const components = [
+      { name: 'SuperClaude', removed: results.superClaude },
+      { name: 'Spec Kit', removed: results.specKit },
+      { name: 'CLAUDE.md', removed: results.config },
+      { name: 'Claude-Z', removed: results.claudeZ },
+      { name: 'Claude HUD', removed: results.claudeHUD }
+    ];
+
+    let removed = 0;
+    for (const comp of components) {
+      const status = comp.removed ? '✓' : '○';
+      const color = comp.removed ? '\x1b[32m' : '\x1b[33m';
+      console.log(`  ${color}[${status}]\x1b[0m ${comp.name}`);
+      if (comp.removed) removed++;
+    }
+
+    console.log('');
+    console.log(`  Components removed: ${removed}/${components.length}`);
+    console.log('');
+
+    if (settingsPreserved) {
+      console.log('  Settings preserved. Run "zuppaclaude install" to restore.');
+    } else {
+      console.log('  All settings have been removed.');
+    }
+
+    console.log('');
+    console.log('  To reinstall: npx zuppaclaude install');
+    console.log('');
+  }
+}
+
+module.exports = { Uninstaller };

package/lib/utils/index.js

@@ -0,0 +1,14 @@
+/**
+ * Utils index
+ */
+
+const { Logger, colors } = require('./logger');
+const { Platform } = require('./platform');
+const { Prompts } = require('./prompts');
+
+module.exports = {
+  Logger,
+  colors,
+  Platform,
+  Prompts,
+};

package/lib/utils/logger.js

@@ -0,0 +1,79 @@
+/**
+ * Logger utility with colored output
+ */
+
+const colors = {
+  reset: '\x1b[0m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  cyan: '\x1b[36m',
+  white: '\x1b[37m',
+};
+
+class Logger {
+  constructor() {
+    this.colors = colors;
+  }
+
+  banner() {
+    console.log(`${colors.magenta}
+╔═══════════════════════════════════════════════════════════════════╗
+║                                                                   ║
+║   ███████╗██╗   ██╗██████╗ ██████╗  █████╗                        ║
+║   ╚══███╔╝██║   ██║██╔══██╗██╔══██╗██╔══██╗                       ║
+║     ███╔╝ ██║   ██║██████╔╝██████╔╝███████║                       ║
+║    ███╔╝  ██║   ██║██╔═══╝ ██╔═══╝ ██╔══██║                       ║
+║   ███████╗╚██████╔╝██║     ██║     ██║  ██║                       ║
+║   ╚══════╝ ╚═════╝ ╚═╝     ╚═╝     ╚═╝  ╚═╝  CLAUDE              ║
+║                                                                   ║
+║   Claude Code Power-Up Installer                                  ║
+║                                                                   ║
+╚═══════════════════════════════════════════════════════════════════╝
+${colors.reset}`);
+  }
+
+  step(message) {
+    console.log(`\n${colors.cyan}══════════════════════════════════════════════════════════════${colors.reset}`);
+    console.log(`${colors.cyan}  ${message}${colors.reset}`);
+    console.log(`${colors.cyan}══════════════════════════════════════════════════════════════${colors.reset}\n`);
+  }
+
+  success(message) {
+    console.log(`${colors.green}[✓]${colors.reset} ${message}`);
+  }
+
+  error(message) {
+    console.log(`${colors.red}[✗]${colors.reset} ${message}`);
+  }
+
+  warning(message) {
+    console.log(`${colors.yellow}[!]${colors.reset} ${message}`);
+  }
+
+  info(message) {
+    console.log(`${colors.blue}[i]${colors.reset} ${message}`);
+  }
+
+  log(message) {
+    console.log(message);
+  }
+
+  newline() {
+    console.log('');
+  }
+
+  box(lines, color = 'green') {
+    const c = colors[color] || colors.green;
+    console.log(`${c}╔═══════════════════════════════════════════════════════════════════╗${colors.reset}`);
+    for (const line of lines) {
+      const paddedLine = line.padEnd(67);
+      console.log(`${c}║${colors.reset}   ${paddedLine}${c}║${colors.reset}`);
+    }
+    console.log(`${c}╚═══════════════════════════════════════════════════════════════════╝${colors.reset}`);
+  }
+}
+
+module.exports = { Logger, colors };

package/lib/utils/platform.js

@@ -0,0 +1,217 @@
+/**
+ * Platform detection and utilities
+ */
+
+const os = require('os');
+const path = require('path');
+const { execSync, spawn } = require('child_process');
+const fs = require('fs');
+
+class Platform {
+  constructor() {
+    this.platform = os.platform();
+    this.homedir = os.homedir();
+  }
+
+  get isWindows() {
+    return this.platform === 'win32';
+  }
+
+  get isMac() {
+    return this.platform === 'darwin';
+  }
+
+  get isLinux() {
+    return this.platform === 'linux';
+  }
+
+  get claudeDir() {
+    return path.join(this.homedir, '.claude');
+  }
+
+  get commandsDir() {
+    return path.join(this.claudeDir, 'commands');
+  }
+
+  get localBin() {
+    return path.join(this.homedir, '.local', 'bin');
+  }
+
+  get configDir() {
+    return path.join(this.homedir, '.config');
+  }
+
+  get zaiConfigDir() {
+    return path.join(this.configDir, 'zai');
+  }
+
+  get zuppaconfigDir() {
+    return path.join(this.configDir, 'zuppaclaude');
+  }
+
+  /**
+   * Check if a command exists
+   */
+  commandExists(command) {
+    try {
+      if (this.isWindows) {
+        execSync(`where ${command}`, { stdio: 'ignore' });
+      } else {
+        execSync(`which ${command}`, { stdio: 'ignore' });
+      }
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Execute a command and return output
+   */
+  exec(command, options = {}) {
+    try {
+      return execSync(command, {
+        encoding: 'utf8',
+        stdio: options.silent ? 'pipe' : 'inherit',
+        ...options,
+      });
+    } catch (error) {
+      if (options.throwOnError !== false) {
+        throw error;
+      }
+      return null;
+    }
+  }
+
+  /**
+   * Execute a command asynchronously
+   */
+  execAsync(command, args = [], options = {}) {
+    return new Promise((resolve, reject) => {
+      const proc = spawn(command, args, {
+        stdio: options.silent ? 'pipe' : 'inherit',
+        shell: true,
+        ...options,
+      });
+
+      let stdout = '';
+      let stderr = '';
+
+      if (proc.stdout) {
+        proc.stdout.on('data', (data) => {
+          stdout += data.toString();
+        });
+      }
+
+      if (proc.stderr) {
+        proc.stderr.on('data', (data) => {
+          stderr += data.toString();
+        });
+      }
+
+      proc.on('close', (code) => {
+        if (code === 0) {
+          resolve({ stdout, stderr, code });
+        } else {
+          reject(new Error(`Command failed with code ${code}: ${stderr || stdout}`));
+        }
+      });
+
+      proc.on('error', reject);
+    });
+  }
+
+  /**
+   * Ensure directory exists
+   */
+  ensureDir(dirPath) {
+    if (!fs.existsSync(dirPath)) {
+      fs.mkdirSync(dirPath, { recursive: true });
+    }
+  }
+
+  /**
+   * Get Python command (python3 or python)
+   */
+  getPythonCommand() {
+    if (this.commandExists('python3')) return 'python3';
+    if (this.commandExists('python')) return 'python';
+    return null;
+  }
+
+  /**
+   * Get pip command (pip3, pip, or via python -m pip)
+   */
+  getPipCommand() {
+    if (this.commandExists('uv')) return 'uv tool install';
+    if (this.commandExists('pipx')) return 'pipx install';
+    if (this.commandExists('pip3')) return 'pip3 install --user';
+    if (this.commandExists('pip')) return 'pip install --user';
+    const python = this.getPythonCommand();
+    if (python) return `${python} -m pip install --user`;
+    return null;
+  }
+
+  /**
+   * Get pip uninstall command
+   */
+  getPipUninstallCommand() {
+    if (this.commandExists('uv')) return 'uv tool uninstall';
+    if (this.commandExists('pipx')) return 'pipx uninstall';
+    if (this.commandExists('pip3')) return 'pip3 uninstall -y';
+    if (this.commandExists('pip')) return 'pip uninstall -y';
+    const python = this.getPythonCommand();
+    if (python) return `${python} -m pip uninstall -y`;
+    return null;
+  }
+
+  /**
+   * Download a file
+   */
+  async download(url, destPath) {
+    const https = require('https');
+    const http = require('http');
+
+    return new Promise((resolve, reject) => {
+      const protocol = url.startsWith('https') ? https : http;
+      const file = fs.createWriteStream(destPath);
+
+      const request = protocol.get(url, (response) => {
+        // Handle redirects
+        if (response.statusCode === 301 || response.statusCode === 302) {
+          file.close();
+          fs.unlinkSync(destPath);
+          this.download(response.headers.location, destPath)
+            .then(resolve)
+            .catch(reject);
+          return;
+        }
+
+        if (response.statusCode !== 200) {
+          file.close();
+          fs.unlinkSync(destPath);
+          reject(new Error(`Failed to download: ${response.statusCode}`));
+          return;
+        }
+
+        response.pipe(file);
+        file.on('finish', () => {
+          file.close();
+          resolve(destPath);
+        });
+      });
+
+      request.on('error', (err) => {
+        fs.unlink(destPath, () => {});
+        reject(err);
+      });
+
+      file.on('error', (err) => {
+        fs.unlink(destPath, () => {});
+        reject(err);
+      });
+    });
+  }
+}
+
+module.exports = { Platform };

package/lib/utils/prompts.js

@@ -0,0 +1,134 @@
+/**
+ * User prompts utility
+ */
+
+const readline = require('readline');
+
+class Prompts {
+  constructor() {
+    this.rl = null;
+  }
+
+  createInterface() {
+    if (!this.rl) {
+      this.rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+      });
+    }
+    return this.rl;
+  }
+
+  close() {
+    if (this.rl) {
+      this.rl.close();
+      this.rl = null;
+    }
+  }
+
+  /**
+   * Ask a yes/no question
+   */
+  async confirm(question, defaultYes = true) {
+    const rl = this.createInterface();
+    const suffix = defaultYes ? '[Y/n]' : '[y/N]';
+
+    return new Promise((resolve) => {
+      rl.question(`${question} ${suffix} `, (answer) => {
+        const normalized = answer.trim().toLowerCase();
+        if (normalized === '') {
+          resolve(defaultYes);
+        } else {
+          resolve(normalized === 'y' || normalized === 'yes');
+        }
+      });
+    });
+  }
+
+  /**
+   * Ask for text input
+   */
+  async input(question, defaultValue = '') {
+    const rl = this.createInterface();
+    const suffix = defaultValue ? ` [${defaultValue}]` : '';
+
+    return new Promise((resolve) => {
+      rl.question(`${question}${suffix}: `, (answer) => {
+        resolve(answer.trim() || defaultValue);
+      });
+    });
+  }
+
+  /**
+   * Ask for password (hidden input)
+   */
+  async password(question) {
+    const rl = this.createInterface();
+
+    return new Promise((resolve) => {
+      // Disable echo
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(true);
+      }
+
+      let password = '';
+      process.stdout.write(`${question}: `);
+
+      const onData = (char) => {
+        char = char.toString();
+
+        switch (char) {
+          case '\n':
+          case '\r':
+          case '\u0004': // Ctrl+D
+            if (process.stdin.isTTY) {
+              process.stdin.setRawMode(false);
+            }
+            process.stdin.removeListener('data', onData);
+            console.log('');
+            resolve(password);
+            break;
+          case '\u0003': // Ctrl+C
+            if (process.stdin.isTTY) {
+              process.stdin.setRawMode(false);
+            }
+            process.exit();
+            break;
+          case '\u007F': // Backspace
+            password = password.slice(0, -1);
+            break;
+          default:
+            password += char;
+        }
+      };
+
+      process.stdin.on('data', onData);
+      process.stdin.resume();
+    });
+  }
+
+  /**
+   * Ask a multiple choice question
+   */
+  async select(question, options) {
+    const rl = this.createInterface();
+
+    console.log(`\n${question}`);
+    options.forEach((opt, i) => {
+      console.log(`  ${i + 1}) ${opt}`);
+    });
+
+    return new Promise((resolve) => {
+      rl.question('Select option: ', (answer) => {
+        const index = parseInt(answer, 10) - 1;
+        if (index >= 0 && index < options.length) {
+          resolve(index);
+        } else {
+          resolve(0); // Default to first option
+        }
+      });
+    });
+  }
+}
+
+module.exports = { Prompts };

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "zuppaclaude",
+  "version": "1.0.0",
+  "description": "Claude Code power-up installer - SuperClaude + Spec Kit + Claude-Z + Claude HUD",
+  "main": "lib/index.js",
+  "bin": {
+    "zuppaclaude": "bin/zuppaclaude.js"
+  },
+  "scripts": {
+    "start": "node bin/zuppaclaude.js",
+    "test": "node bin/zuppaclaude.js --help"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "anthropic",
+    "ai",
+    "cli",
+    "superclaude",
+    "spec-kit",
+    "claude-z",
+    "mcp"
+  ],
+  "author": "Hasan Kaan Tan",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hasankaantan/zuppaclaude.git"
+  },
+  "bugs": {
+    "url": "https://github.com/hasankaantan/zuppaclaude/issues"
+  },
+  "homepage": "https://github.com/hasankaantan/zuppaclaude#readme",
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "assets"
+  ],
+  "dependencies": {}
+}