zuppaclaude 1.0.0

package/lib/components/superclaude.js

@@ -0,0 +1,130 @@
+/**
+ * SuperClaude component installer
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { Logger } = require('../utils/logger');
+const { Platform } = require('../utils/platform');
+
+const SUPERCLAUDE_REPO = 'https://github.com/SuperClaude-Org/SuperClaude_Framework.git';
+const SUPERCLAUDE_ZIP = 'https://github.com/SuperClaude-Org/SuperClaude_Framework/archive/refs/heads/master.zip';
+
+class SuperClaudeInstaller {
+  constructor() {
+    this.platform = new Platform();
+    this.logger = new Logger();
+    this.installPath = path.join(this.platform.commandsDir, 'sc');
+  }
+
+  /**
+   * Check if SuperClaude is already installed
+   */
+  isInstalled() {
+    return fs.existsSync(this.installPath);
+  }
+
+  /**
+   * Install SuperClaude
+   */
+  async install() {
+    this.logger.step('Step 2/7: Installing SuperClaude Framework');
+
+    // Ensure directories exist
+    this.platform.ensureDir(this.platform.commandsDir);
+
+    // Backup existing installation
+    if (this.isInstalled()) {
+      const backupPath = `${this.installPath}.backup.${Date.now()}`;
+      fs.renameSync(this.installPath, backupPath);
+      this.logger.info(`Existing installation backed up to: ${backupPath}`);
+    }
+
+    // Try git clone first
+    if (this.platform.commandExists('git')) {
+      try {
+        this.logger.info('Cloning SuperClaude repository...');
+        this.platform.exec(`git clone --depth 1 ${SUPERCLAUDE_REPO} "${this.installPath}"`, { silent: true });
+
+        // Remove .git folder to save space
+        const gitDir = path.join(this.installPath, '.git');
+        if (fs.existsSync(gitDir)) {
+          fs.rmSync(gitDir, { recursive: true });
+        }
+
+        this.logger.success('SuperClaude installed via git');
+        return true;
+      } catch (error) {
+        this.logger.warning('Git clone failed, trying ZIP download...');
+      }
+    }
+
+    // Fallback to ZIP download
+    try {
+      const tempZip = path.join(require('os').tmpdir(), 'superclaude.zip');
+      const tempDir = path.join(require('os').tmpdir(), 'superclaude-extract');
+
+      this.logger.info('Downloading SuperClaude ZIP...');
+      await this.platform.download(SUPERCLAUDE_ZIP, tempZip);
+
+      // Extract ZIP
+      this.logger.info('Extracting...');
+      if (this.platform.isWindows) {
+        this.platform.exec(`powershell -Command "Expand-Archive -Path '${tempZip}' -DestinationPath '${tempDir}' -Force"`, { silent: true });
+      } else {
+        this.platform.exec(`unzip -q -o "${tempZip}" -d "${tempDir}"`, { silent: true });
+      }
+
+      // Move extracted content to install path
+      const extracted = fs.readdirSync(tempDir)[0];
+      const extractedPath = path.join(tempDir, extracted);
+
+      this.platform.ensureDir(path.dirname(this.installPath));
+      fs.renameSync(extractedPath, this.installPath);
+
+      // Cleanup
+      fs.rmSync(tempZip, { force: true });
+      fs.rmSync(tempDir, { recursive: true, force: true });
+
+      this.logger.success('SuperClaude installed via ZIP');
+      return true;
+    } catch (error) {
+      this.logger.error(`Failed to install SuperClaude: ${error.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * Uninstall SuperClaude
+   */
+  uninstall() {
+    if (!this.isInstalled()) {
+      this.logger.warning('SuperClaude not found');
+      return true;
+    }
+
+    try {
+      fs.rmSync(this.installPath, { recursive: true });
+      this.logger.success('SuperClaude removed');
+      return true;
+    } catch (error) {
+      this.logger.error(`Failed to remove SuperClaude: ${error.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * Verify installation
+   */
+  verify() {
+    if (this.isInstalled()) {
+      this.logger.success('SuperClaude: Installed');
+      return true;
+    } else {
+      this.logger.error('SuperClaude: Not installed');
+      return false;
+    }
+  }
+}
+
+module.exports = { SuperClaudeInstaller };

package/lib/index.js

@@ -0,0 +1,17 @@
+/**
+ * ZuppaClaude - Claude Code Enhancement Installer
+ */
+
+const { Installer } = require('./installer');
+const { Uninstaller } = require('./uninstaller');
+const { Settings } = require('./settings');
+const { Logger } = require('./utils/logger');
+const { Platform } = require('./utils/platform');
+
+module.exports = {
+  Installer,
+  Uninstaller,
+  Settings,
+  Logger,
+  Platform
+};

package/lib/installer.js

@@ -0,0 +1,241 @@
+/**
+ * ZuppaClaude Main Installer
+ */
+
+const { Logger } = require('./utils/logger');
+const { Platform } = require('./utils/platform');
+const { Prompts } = require('./utils/prompts');
+const { Settings } = require('./settings');
+const {
+  SuperClaudeInstaller,
+  SpecKitInstaller,
+  ConfigInstaller,
+  ClaudeZInstaller,
+  ClaudeHUDInstaller
+} = require('./components');
+
+class Installer {
+  constructor() {
+    this.logger = new Logger();
+    this.platform = new Platform();
+    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 installer
+   */
+  async run() {
+    this.logger.banner();
+
+    // Step 1: Check dependencies
+    this.logger.step('Step 1/7: Checking Dependencies');
+    const depsOk = await this.checkDependencies();
+    if (!depsOk) {
+      this.logger.error('Dependency check failed. Please install required dependencies.');
+      return false;
+    }
+
+    // Load existing settings
+    const existingSettings = this.settings.load();
+    let useExisting = false;
+
+    if (existingSettings) {
+      this.logger.info('Found existing settings from previous installation');
+      useExisting = await this.prompts.confirm('Use previous settings?', true);
+    }
+
+    // Step 2: Install SuperClaude
+    const scInstalled = await this.superClaude.install();
+
+    // Step 3: Install Spec Kit
+    let installSpecKit = true;
+    if (useExisting && existingSettings.specKit !== undefined) {
+      installSpecKit = existingSettings.specKit;
+    } else {
+      installSpecKit = await this.prompts.confirm('Install Spec Kit (specify-cli)?', true);
+    }
+
+    let skInstalled = false;
+    if (installSpecKit) {
+      skInstalled = await this.specKit.install();
+    } else {
+      this.logger.info('Skipping Spec Kit installation');
+    }
+
+    // Step 4: Install Configuration
+    const cfgInstalled = await this.config.install();
+
+    // Step 5: Install Claude-Z (optional)
+    let installClaudeZ = false;
+    let zaiApiKey = null;
+
+    if (useExisting && existingSettings.claudeZ) {
+      installClaudeZ = true;
+      zaiApiKey = this.settings.decodeApiKey(existingSettings.zaiApiKey);
+      this.logger.info('Using saved Z.AI API key');
+    } else {
+      installClaudeZ = await this.prompts.confirm('Install Claude-Z (z.ai backend)?', false);
+      if (installClaudeZ) {
+        zaiApiKey = await this.prompts.password('Enter your Z.AI API key:');
+      }
+    }
+
+    let czInstalled = false;
+    if (installClaudeZ && zaiApiKey) {
+      czInstalled = await this.claudeZ.install(zaiApiKey);
+    } else {
+      this.logger.info('Skipping Claude-Z installation');
+    }
+
+    // Step 6: Install Claude HUD (optional)
+    let installClaudeHUD = true;
+    if (useExisting && existingSettings.claudeHUD !== undefined) {
+      installClaudeHUD = existingSettings.claudeHUD;
+    } else {
+      installClaudeHUD = await this.prompts.confirm('Install Claude HUD (status display)?', true);
+    }
+
+    let hudInstalled = false;
+    if (installClaudeHUD) {
+      hudInstalled = await this.claudeHUD.install();
+    } else {
+      this.logger.info('Skipping Claude HUD installation');
+    }
+
+    // Step 7: Verification
+    this.logger.step('Step 7/7: Verifying Installation');
+    console.log('');
+
+    this.superClaude.verify();
+    if (installSpecKit) this.specKit.verify();
+    this.config.verify();
+    if (installClaudeZ) this.claudeZ.verify();
+    if (installClaudeHUD) this.claudeHUD.verify();
+
+    // Save settings
+    const newSettings = {
+      specKit: installSpecKit,
+      claudeZ: installClaudeZ,
+      claudeHUD: installClaudeHUD,
+      zaiApiKey: zaiApiKey ? this.settings.encodeApiKey(zaiApiKey) : null,
+      installedAt: new Date().toISOString(),
+      version: require('../package.json').version
+    };
+
+    this.settings.save(newSettings);
+    this.logger.success('Settings saved');
+
+    // Print summary
+    this.printSummary({
+      superClaude: scInstalled,
+      specKit: skInstalled,
+      config: cfgInstalled,
+      claudeZ: czInstalled,
+      claudeHUD: hudInstalled
+    });
+
+    return true;
+  }
+
+  /**
+   * Check dependencies
+   */
+  async checkDependencies() {
+    let allOk = true;
+
+    // Check Node.js version
+    const nodeVersion = process.version;
+    const major = parseInt(nodeVersion.slice(1).split('.')[0]);
+    if (major >= 16) {
+      this.logger.success(`Node.js: ${nodeVersion}`);
+    } else {
+      this.logger.error(`Node.js: ${nodeVersion} (requires 16+)`);
+      allOk = false;
+    }
+
+    // Check Claude Code
+    if (this.platform.commandExists('claude')) {
+      const version = this.platform.exec('claude --version', { silent: true });
+      this.logger.success(`Claude Code: ${version?.trim() || 'installed'}`);
+    } else {
+      this.logger.error('Claude Code: Not found');
+      this.logger.info('Install with: npm install -g @anthropic-ai/claude-code');
+      allOk = false;
+    }
+
+    // Check git (optional but recommended)
+    if (this.platform.commandExists('git')) {
+      this.logger.success('Git: Available');
+    } else {
+      this.logger.warning('Git: Not found (will use ZIP fallback)');
+    }
+
+    // Check Python (for Spec Kit)
+    const pipCmd = this.platform.getPipCommand();
+    if (pipCmd) {
+      this.logger.success(`Python: Available (${pipCmd.split(' ')[0]})`);
+    } else {
+      this.logger.warning('Python: Not found (Spec Kit will be skipped)');
+    }
+
+    console.log('');
+    return allOk;
+  }
+
+  /**
+   * Print installation summary
+   */
+  printSummary(results) {
+    console.log('');
+    console.log('═══════════════════════════════════════════════════════════════════');
+    console.log('                    Installation Complete');
+    console.log('═══════════════════════════════════════════════════════════════════');
+    console.log('');
+
+    const components = [
+      { name: 'SuperClaude', installed: results.superClaude },
+      { name: 'Spec Kit', installed: results.specKit },
+      { name: 'CLAUDE.md', installed: results.config },
+      { name: 'Claude-Z', installed: results.claudeZ },
+      { name: 'Claude HUD', installed: results.claudeHUD }
+    ];
+
+    let installed = 0;
+    for (const comp of components) {
+      const status = comp.installed ? '✓' : '✗';
+      const color = comp.installed ? '\x1b[32m' : '\x1b[31m';
+      console.log(`  ${color}[${status}]\x1b[0m ${comp.name}`);
+      if (comp.installed) installed++;
+    }
+
+    console.log('');
+    console.log(`  Components installed: ${installed}/${components.length}`);
+    console.log('');
+
+    console.log('  Next steps:');
+    console.log('  1. Restart your terminal or run: source ~/.bashrc');
+    console.log('  2. Start Claude Code: claude');
+    console.log('  3. Try: /sc:help');
+    console.log('');
+
+    if (results.claudeZ) {
+      console.log('  For z.ai backend: claude-z');
+      console.log('');
+    }
+
+    if (results.claudeHUD) {
+      console.log('  For Claude HUD: run setup-claude-hud');
+      console.log('');
+    }
+  }
+}
+
+module.exports = { Installer };

package/lib/settings.js

@@ -0,0 +1,243 @@
+/**
+ * Settings management for ZuppaClaude
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { Logger } = require('./utils/logger');
+const { Platform } = require('./utils/platform');
+const { Prompts } = require('./utils/prompts');
+
+const SETTINGS_VERSION = '1.0';
+
+class Settings {
+  constructor() {
+    this.platform = new Platform();
+    this.logger = new Logger();
+    this.prompts = new Prompts();
+    this.configDir = this.platform.zuppaconfigDir;
+    this.filePath = path.join(this.configDir, 'zc-settings.json');
+  }
+
+  /**
+   * Check if settings file exists
+   */
+  exists() {
+    return fs.existsSync(this.filePath);
+  }
+
+  /**
+   * Load settings from file
+   */
+  load() {
+    if (!this.exists()) {
+      return null;
+    }
+
+    try {
+      const content = fs.readFileSync(this.filePath, 'utf8');
+      return JSON.parse(content);
+    } catch (error) {
+      this.logger.warning(`Could not parse settings file: ${error.message}`);
+      return null;
+    }
+  }
+
+  /**
+   * Save settings to file
+   */
+  save(settings) {
+    this.platform.ensureDir(this.configDir);
+
+    const timestamp = new Date().toISOString();
+    const existing = this.load();
+
+    const data = {
+      version: SETTINGS_VERSION,
+      created: existing?.created || timestamp,
+      updated: timestamp,
+      components: settings.components || {},
+      preferences: settings.preferences || {
+        auto_update_check: true,
+        backup_configs: true,
+      },
+    };
+
+    fs.writeFileSync(this.filePath, JSON.stringify(data, null, 2), 'utf8');
+    fs.chmodSync(this.filePath, 0o600);
+
+    this.logger.success(`Settings saved to ${this.filePath}`);
+    return data;
+  }
+
+  /**
+   * Get component settings
+   */
+  getComponents() {
+    const settings = this.load();
+    return settings?.components || {};
+  }
+
+  /**
+   * Update component settings
+   */
+  updateComponents(components) {
+    const settings = this.load() || { components: {}, preferences: {} };
+    settings.components = { ...settings.components, ...components };
+    return this.save(settings);
+  }
+
+  /**
+   * Encode API key to base64
+   */
+  encodeApiKey(key) {
+    return Buffer.from(key).toString('base64');
+  }
+
+  /**
+   * Decode API key from base64
+   */
+  decodeApiKey(encoded) {
+    try {
+      return Buffer.from(encoded, 'base64').toString('utf8');
+    } catch {
+      return '';
+    }
+  }
+
+  /**
+   * Show current settings
+   */
+  show() {
+    if (!this.exists()) {
+      this.logger.warning(`No settings file found at: ${this.filePath}`);
+      console.log('\nRun the installer first to create settings.');
+      return;
+    }
+
+    const settings = this.load();
+    if (!settings) return;
+
+    const c = settings.components || {};
+
+    console.log(`\nSettings file: ${this.filePath}\n`);
+    console.log(`Version: ${settings.version}`);
+    console.log(`Created: ${settings.created}`);
+    console.log(`Updated: ${settings.updated}`);
+    console.log('\nComponents:');
+    console.log(`  SuperClaude: ${c.superclaude?.installed ? 'Yes' : 'No'}`);
+    console.log(`  Spec Kit: ${c.speckit?.installed ? 'Yes' : 'No'}`);
+    console.log(`  Claude-Z: ${c.claude_z?.installed ? 'Yes' : 'No'}`);
+    if (c.claude_z?.api_key_encoded) {
+      console.log('    API Key: [configured]');
+    }
+    console.log(`  Claude HUD: ${c.claude_hud?.installed ? 'Yes' : 'No'}`);
+
+    const p = settings.preferences || {};
+    console.log('\nPreferences:');
+    console.log(`  Auto-update check: ${p.auto_update_check ? 'Yes' : 'No'}`);
+    console.log(`  Backup configs: ${p.backup_configs ? 'Yes' : 'No'}`);
+    console.log('');
+  }
+
+  /**
+   * Export settings to file
+   */
+  export(exportPath) {
+    if (!this.exists()) {
+      this.logger.error(`No settings file found at: ${this.filePath}`);
+      return false;
+    }
+
+    const settings = this.load();
+    if (!settings) return false;
+
+    // Add export metadata
+    settings._export = {
+      exported_at: new Date().toISOString(),
+      hostname: require('os').hostname(),
+      source_path: this.filePath,
+    };
+
+    const resolvedPath = path.resolve(exportPath.replace(/^~/, this.platform.homedir));
+    fs.writeFileSync(resolvedPath, JSON.stringify(settings, null, 2), 'utf8');
+
+    this.logger.success(`Settings exported to: ${resolvedPath}`);
+    return true;
+  }
+
+  /**
+   * Import settings from file
+   */
+  import(importPath) {
+    const resolvedPath = path.resolve(importPath.replace(/^~/, this.platform.homedir));
+
+    if (!fs.existsSync(resolvedPath)) {
+      this.logger.error(`Import file not found: ${resolvedPath}`);
+      return false;
+    }
+
+    let settings;
+    try {
+      const content = fs.readFileSync(resolvedPath, 'utf8');
+      settings = JSON.parse(content);
+    } catch (error) {
+      this.logger.error(`Invalid JSON file: ${error.message}`);
+      return false;
+    }
+
+    // Backup existing settings
+    if (this.exists()) {
+      const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+      const backupPath = `${this.filePath}.backup.${timestamp}`;
+      fs.copyFileSync(this.filePath, backupPath);
+      this.logger.info(`Existing settings backed up to: ${backupPath}`);
+    }
+
+    // Remove export metadata
+    delete settings._export;
+
+    // Update timestamp
+    settings.updated = new Date().toISOString();
+
+    this.platform.ensureDir(this.configDir);
+    fs.writeFileSync(this.filePath, JSON.stringify(settings, null, 2), 'utf8');
+    fs.chmodSync(this.filePath, 0o600);
+
+    this.logger.success(`Settings imported from: ${resolvedPath}`);
+    this.logger.info('Run the installer again to apply imported settings');
+    return true;
+  }
+
+  /**
+   * Reset settings
+   */
+  async reset() {
+    if (!this.exists()) {
+      this.logger.warning('No settings file found');
+      return true;
+    }
+
+    const confirmed = await this.prompts.confirm('Are you sure you want to reset all settings?', false);
+    this.prompts.close();
+
+    if (!confirmed) {
+      this.logger.info('Reset cancelled');
+      return false;
+    }
+
+    // Backup before reset
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const backupPath = `${this.filePath}.backup.${timestamp}`;
+    fs.copyFileSync(this.filePath, backupPath);
+    this.logger.info(`Settings backed up to: ${backupPath}`);
+
+    // Remove settings
+    fs.unlinkSync(this.filePath);
+    this.logger.success('Settings reset complete');
+    this.logger.info('Run the installer again to create new settings');
+    return true;
+  }
+}
+
+module.exports = { Settings, SETTINGS_VERSION };