@accelerationguy/accel 1.0.0

package/bin/install.js

@@ -0,0 +1,661 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const readline = require('readline');
+const { execFileSync } = require('child_process');
+
+// ─── Branding ───────────────────────────────────────────────
+const BRAND = 'Accelerate';
+const AUTHOR = 'Acceleration Guy';
+const WEBSITE = 'accelerationguy.com';
+
+// ─── Colors ─────────────────────────────────────────────────
+const c = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  green: '\x1b[32m',
+  cyan: '\x1b[36m',
+  yellow: '\x1b[33m',
+  red: '\x1b[31m',
+  magenta: '\x1b[35m',
+};
+
+// ─── Module Registry ────────────────────────────────────────
+const MODULES = [
+  {
+    id: 'vector',
+    name: 'Vector',
+    desc: 'Rules engine — steers Claude behavior per context',
+    recommended: true,
+    dependencies: [],
+    requiresPython: true,
+    hasMcp: true,
+    hasHooks: true,
+  },
+  {
+    id: 'momentum',
+    name: 'Momentum',
+    desc: 'Workspace state — tracks tasks, backlog, project health',
+    recommended: true,
+    dependencies: ['vector'],
+    requiresPython: true,
+    hasMcp: true,
+    hasHooks: true,
+  },
+  {
+    id: 'drive',
+    name: 'Drive',
+    desc: 'Dev workflow — plan, apply, unify loop',
+    recommended: true,
+    dependencies: [],
+    enhancedBy: ['momentum'],
+    requiresPython: false,
+    hasMcp: false,
+    hasHooks: false,
+  },
+  {
+    id: 'ignition',
+    name: 'Ignition',
+    desc: 'Project incubation — guided ideation to planning docs',
+    recommended: false,
+    dependencies: [],
+    enhancedBy: ['drive'],
+    requiresPython: false,
+    hasMcp: false,
+    hasHooks: false,
+  },
+  {
+    id: 'radar',
+    name: 'Radar',
+    desc: 'Security auditing — 12 personas, 14 audit domains',
+    recommended: false,
+    dependencies: [],
+    enhancedBy: ['momentum'],
+    requiresPython: false,
+    hasMcp: false,
+    hasHooks: false,
+  },
+  {
+    id: 'forge',
+    name: 'Forge',
+    desc: 'Skill builder — create custom Claude Code extensions',
+    recommended: false,
+    dependencies: [],
+    requiresPython: false,
+    hasMcp: false,
+    hasHooks: false,
+  },
+  {
+    id: 'mission-control',
+    name: 'Mission Control',
+    desc: 'Orchestrator — manages all modules',
+    recommended: false,
+    dependencies: [],
+    requiresPython: false,
+    hasMcp: false,
+    hasHooks: false,
+  },
+];
+
+// ─── Paths ──────────────────────────────────────────────────
+const ACCEL_HOME = path.join(os.homedir(), '.accel');
+const CLAUDE_HOME = process.env.CLAUDE_CONFIG_DIR
+  ? expandTilde(process.env.CLAUDE_CONFIG_DIR)
+  : path.join(os.homedir(), '.claude');
+const MANIFEST_PATH = path.join(ACCEL_HOME, 'manifest.json');
+const PACKAGE_DIR = path.resolve(__dirname, '..');
+
+function expandTilde(p) {
+  if (p.startsWith('~/')) return path.join(os.homedir(), p.slice(2));
+  return p;
+}
+
+// ─── Prerequisite Checks ────────────────────────────────────
+function checkPrerequisites(selectedModules) {
+  const issues = [];
+
+  const nodeVersion = parseInt(process.version.slice(1).split('.')[0]);
+  if (nodeVersion < 16) {
+    issues.push(`Node.js >= 16 required (you have ${process.version})`);
+  }
+
+  const needsPython = selectedModules.some(
+    (m) => MODULES.find((mod) => mod.id === m)?.requiresPython
+  );
+  if (needsPython) {
+    try {
+      const pyVersion = execFileSync('python3', ['--version'], { encoding: 'utf8' }).trim();
+      const match = pyVersion.match(/(\d+)\.(\d+)/);
+      if (match && (parseInt(match[1]) < 3 || (parseInt(match[1]) === 3 && parseInt(match[2]) < 9))) {
+        issues.push(`Python >= 3.9 required for Vector/Momentum hooks (you have ${pyVersion})`);
+      }
+    } catch {
+      issues.push('Python 3.9+ required for Vector/Momentum hooks. Install: brew install python@3.12');
+    }
+  }
+
+  return issues;
+}
+
+// ─── Dependency Resolution ──────────────────────────────────
+function resolveDependencies(selected) {
+  const resolved = new Set(selected);
+  let changed = true;
+  const autoAdded = [];
+
+  while (changed) {
+    changed = false;
+    for (const modId of [...resolved]) {
+      const mod = MODULES.find((m) => m.id === modId);
+      if (!mod) continue;
+      for (const dep of mod.dependencies) {
+        if (!resolved.has(dep)) {
+          resolved.add(dep);
+          autoAdded.push({ module: modId, dependency: dep });
+          changed = true;
+        }
+      }
+    }
+  }
+
+  return { resolved: [...resolved], autoAdded };
+}
+
+// ─── Install Module ─────────────────────────────────────────
+function installModule(moduleId) {
+  const mod = MODULES.find((m) => m.id === moduleId);
+  if (!mod) throw new Error(`Unknown module: ${moduleId}`);
+
+  const srcDir = path.join(PACKAGE_DIR, 'modules', moduleId);
+  const destDir = path.join(ACCEL_HOME, 'modules', moduleId);
+  const commandsDir = path.join(CLAUDE_HOME, 'commands', moduleId);
+
+  fs.mkdirSync(destDir, { recursive: true });
+  fs.mkdirSync(commandsDir, { recursive: true });
+
+  copyRecursive(srcDir, destDir);
+
+  // Module-specific command paths (each module has different structure)
+  const cmdSrcDirs = [
+    'commands', 'tasks', 'src/commands', 'src/tasks',
+    // Forge: commands live in skillsmith/ subdir
+    'skillsmith/tasks', 'skillsmith',
+    // Mission Control: commands live in mission-control/ subdir
+    'mission-control/tasks', 'mission-control',
+  ];
+  for (const cmdDir of cmdSrcDirs) {
+    const cmdSrc = path.join(srcDir, cmdDir);
+    if (fs.existsSync(cmdSrc)) {
+      // Only copy .md files from top-level of dir (not recursing into subdirs for entry points)
+      const entries = fs.readdirSync(cmdSrc);
+      for (const entry of entries) {
+        const entryPath = path.join(cmdSrc, entry);
+        if (entry.endsWith('.md') && fs.statSync(entryPath).isFile()) {
+          fs.copyFileSync(entryPath, path.join(commandsDir, entry));
+        }
+      }
+    }
+  }
+
+  if (mod.hasHooks) {
+    const hooksSrc = path.join(srcDir, 'hooks');
+    const srcHooks = path.join(srcDir, 'src', 'hooks');
+    const hooksDir = fs.existsSync(hooksSrc) ? hooksSrc : fs.existsSync(srcHooks) ? srcHooks : null;
+    if (hooksDir) {
+      const hooksDest = path.join(CLAUDE_HOME, 'hooks');
+      fs.mkdirSync(hooksDest, { recursive: true });
+      copyRecursive(hooksDir, hooksDest);
+    }
+  }
+
+  if (mod.hasMcp) {
+    const mcpSrc = path.join(srcDir, 'mcp');
+    const pkgMcp = path.join(srcDir, 'src', 'packages', `${moduleId}-mcp`);
+    const mcpDir = fs.existsSync(mcpSrc) ? mcpSrc : fs.existsSync(pkgMcp) ? pkgMcp : null;
+    if (mcpDir) {
+      const mcpDest = path.join(ACCEL_HOME, 'mcp', moduleId);
+      fs.mkdirSync(mcpDest, { recursive: true });
+      copyRecursive(mcpDir, mcpDest);
+      if (fs.existsSync(path.join(mcpDest, 'package.json'))) {
+        try {
+          execFileSync('npm', ['install', '--production', '--silent'], { cwd: mcpDest, stdio: 'pipe' });
+        } catch (e) {
+          console.log(`  ${c.yellow}Warning: MCP dependencies for ${mod.name} failed to install${c.reset}`);
+        }
+      }
+    }
+  }
+
+  return true;
+}
+
+function copyRecursive(src, dest) {
+  if (!fs.existsSync(src)) return;
+  const stat = fs.statSync(src);
+  if (stat.isDirectory()) {
+    fs.mkdirSync(dest, { recursive: true });
+    for (const item of fs.readdirSync(src)) {
+      if (item === '.git' || item === 'node_modules') continue;
+      copyRecursive(path.join(src, item), path.join(dest, item));
+    }
+  } else {
+    fs.copyFileSync(src, dest);
+  }
+}
+
+// ─── Manifest ───────────────────────────────────────────────
+function writeManifest(installedModules) {
+  const manifest = {
+    schemaVersion: 1,
+    version: '1.0.0',
+    brand: BRAND,
+    author: AUTHOR,
+    installedAt: new Date().toISOString(),
+    modules: {},
+  };
+
+  for (const modId of installedModules) {
+    const mod = MODULES.find((m) => m.id === modId);
+    manifest.modules[modId] = {
+      name: mod.name,
+      installed: true,
+      installedAt: new Date().toISOString(),
+    };
+  }
+
+  fs.mkdirSync(path.dirname(MANIFEST_PATH), { recursive: true });
+  fs.writeFileSync(MANIFEST_PATH, JSON.stringify(manifest, null, 2));
+}
+
+// ─── CLAUDE.md Block ────────────────────────────────────────
+function installClaudeMdBlock() {
+  const claudeMdPath = path.join(process.cwd(), 'CLAUDE.md');
+  const START_MARKER = '<!-- ACCELERATE START -->';
+  const END_MARKER = '<!-- ACCELERATE END -->';
+
+  const block = `${START_MARKER}
+## Accelerate by ${AUTHOR}
+
+This project uses **Accelerate** — a unified Claude Code agent framework.
+
+Available module commands:
+- \`/vector:help\` — Rules engine
+- \`/momentum:pulse\` — Workspace health check
+- \`/momentum:scaffold\` — Setup workspace
+- \`/drive:progress\` — Check plan progress
+- \`/drive:resume\` — Resume where you left off
+- \`/ignition\` — Start a new project
+- \`/radar:audit\` — Run security audit
+- \`/forge\` — Build custom skills
+- \`/accel status\` — See what's installed
+- \`/accel help\` — See all commands
+
+Learn more: https://${WEBSITE}/accelerate
+${END_MARKER}`;
+
+  if (fs.existsSync(claudeMdPath)) {
+    let content = fs.readFileSync(claudeMdPath, 'utf8');
+    if (content.includes(START_MARKER)) {
+      const regex = new RegExp(`${START_MARKER}[\\s\\S]*?${END_MARKER}`, 'g');
+      content = content.replace(regex, block);
+    } else {
+      content += '\n\n' + block;
+    }
+    fs.writeFileSync(claudeMdPath, content);
+  } else {
+    fs.writeFileSync(claudeMdPath, block + '\n');
+  }
+}
+
+// ─── MCP Server Registration ────────────────────────────────
+const MCP_CONFIG_PATH = path.join(os.homedir(), '.mcp.json');
+
+const MCP_SERVERS = {
+  vector: {
+    name: 'vector-mcp',
+    command: 'node',
+    args: [path.join(ACCEL_HOME, 'mcp', 'vector', 'index.js')],
+    type: 'stdio',
+  },
+  momentum: {
+    name: 'momentum-mcp',
+    command: 'node',
+    args: [path.join(ACCEL_HOME, 'mcp', 'momentum', 'index.js')],
+    type: 'stdio',
+  },
+};
+
+function registerMcpServers(installedModules) {
+  let mcpConfig = { mcpServers: {} };
+
+  // Read existing config if present
+  if (fs.existsSync(MCP_CONFIG_PATH)) {
+    try {
+      mcpConfig = JSON.parse(fs.readFileSync(MCP_CONFIG_PATH, 'utf8'));
+      if (!mcpConfig.mcpServers) mcpConfig.mcpServers = {};
+    } catch {
+      // If the file is malformed, start fresh but preserve it
+      console.log(`  ${c.yellow}Warning: ~/.mcp.json was malformed, merging cautiously${c.reset}`);
+      mcpConfig = { mcpServers: {} };
+    }
+  }
+
+  let registered = 0;
+  for (const modId of installedModules) {
+    const serverDef = MCP_SERVERS[modId];
+    if (!serverDef) continue;
+
+    mcpConfig.mcpServers[serverDef.name] = {
+      command: serverDef.command,
+      args: serverDef.args,
+      type: serverDef.type,
+    };
+    registered++;
+    console.log(`  ${c.green}\u2713${c.reset} MCP server registered: ${serverDef.name}`);
+  }
+
+  if (registered > 0) {
+    fs.writeFileSync(MCP_CONFIG_PATH, JSON.stringify(mcpConfig, null, 2));
+  }
+
+  return registered;
+}
+
+// ─── Hook Registration ──────────────────────────────────────
+const SETTINGS_PATH = path.join(CLAUDE_HOME, 'settings.json');
+
+// Marker used to identify hooks managed by Accelerate
+const ACCEL_HOOK_MARKER = '__accelerate';
+
+const HOOK_DEFINITIONS = {
+  vector: [
+    { event: 'UserPromptSubmit', script: 'vector-hook.py' },
+  ],
+  momentum: [
+    { event: 'UserPromptSubmit', script: 'active-hook.py' },
+    { event: 'UserPromptSubmit', script: 'backlog-hook.py' },
+    { event: 'UserPromptSubmit', script: 'momentum-pulse-check.py' },
+    { event: 'UserPromptSubmit', script: 'psmm-injector.py' },
+    { event: 'UserPromptSubmit', script: 'satellite-detection.py' },
+    { event: 'UserPromptSubmit', script: 'operator.py' },
+    { event: 'UserPromptSubmit', script: 'apex-insights.py' },
+  ],
+};
+
+function registerHooks(installedModules) {
+  let settings = {};
+
+  // Read existing settings.json or start fresh
+  if (fs.existsSync(SETTINGS_PATH)) {
+    try {
+      settings = JSON.parse(fs.readFileSync(SETTINGS_PATH, 'utf8'));
+    } catch {
+      console.log(`  ${c.yellow}Warning: ${SETTINGS_PATH} was malformed, merging cautiously${c.reset}`);
+      settings = {};
+    }
+  }
+
+  if (!settings.hooks) settings.hooks = {};
+
+  // First, remove any existing Accelerate hooks (to avoid duplicates on reinstall)
+  for (const eventName of Object.keys(settings.hooks)) {
+    if (Array.isArray(settings.hooks[eventName])) {
+      settings.hooks[eventName] = settings.hooks[eventName].filter(
+        (h) => !h[ACCEL_HOOK_MARKER]
+      );
+    }
+  }
+
+  let registered = 0;
+  const hooksDir = path.join(CLAUDE_HOME, 'hooks');
+
+  for (const modId of installedModules) {
+    const hookDefs = HOOK_DEFINITIONS[modId];
+    if (!hookDefs) continue;
+
+    for (const def of hookDefs) {
+      const hookPath = path.join(hooksDir, def.script);
+      const hookEntry = {
+        type: 'command',
+        command: `python3 ${hookPath}`,
+        [ACCEL_HOOK_MARKER]: true,
+      };
+
+      if (!Array.isArray(settings.hooks[def.event])) {
+        settings.hooks[def.event] = [];
+      }
+      settings.hooks[def.event].push(hookEntry);
+      registered++;
+      console.log(`  ${c.green}\u2713${c.reset} Hook registered: ${def.script} (${def.event})`);
+    }
+  }
+
+  if (registered > 0) {
+    fs.mkdirSync(path.dirname(SETTINGS_PATH), { recursive: true });
+    fs.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
+  }
+
+  return registered;
+}
+
+function deregisterHooks() {
+  if (!fs.existsSync(SETTINGS_PATH)) return;
+
+  let settings;
+  try {
+    settings = JSON.parse(fs.readFileSync(SETTINGS_PATH, 'utf8'));
+  } catch {
+    return; // Can't parse, nothing to clean
+  }
+
+  if (!settings.hooks) return;
+
+  let changed = false;
+  for (const eventName of Object.keys(settings.hooks)) {
+    if (!Array.isArray(settings.hooks[eventName])) continue;
+    const before = settings.hooks[eventName].length;
+    settings.hooks[eventName] = settings.hooks[eventName].filter(
+      (h) => !h[ACCEL_HOOK_MARKER]
+    );
+    if (settings.hooks[eventName].length !== before) changed = true;
+    // Remove empty arrays to keep settings tidy
+    if (settings.hooks[eventName].length === 0) {
+      delete settings.hooks[eventName];
+    }
+  }
+  // Remove empty hooks object
+  if (Object.keys(settings.hooks).length === 0) {
+    delete settings.hooks;
+  }
+
+  if (changed) {
+    fs.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
+    console.log(`  ${c.green}\u2713${c.reset} Accelerate hooks removed from settings.json`);
+  }
+}
+
+// ─── Event Bus Setup ────────────────────────────────────────
+function setupEventBus() {
+  const eventsDir = path.join(ACCEL_HOME, 'events');
+  fs.mkdirSync(path.join(eventsDir, 'archive'), { recursive: true });
+  fs.mkdirSync(path.join(eventsDir, 'errors'), { recursive: true });
+  fs.mkdirSync(path.join(eventsDir, 'schemas'), { recursive: true });
+
+  const schemasSrc = path.join(PACKAGE_DIR, 'shared', 'events', 'schemas');
+  if (fs.existsSync(schemasSrc)) {
+    copyRecursive(schemasSrc, path.join(eventsDir, 'schemas'));
+  }
+}
+
+// ─── Interactive Module Selector ────────────────────────────
+async function selectModules() {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const question = (q) => new Promise((resolve) => rl.question(q, resolve));
+
+  console.log(`\n  ${c.cyan}${c.bold}Welcome to ${BRAND} by ${AUTHOR}!${c.reset}\n`);
+  console.log(`  Select modules to install:\n`);
+
+  for (const mod of MODULES) {
+    const tag = mod.recommended ? ` ${c.green}RECOMMENDED${c.reset}` : '';
+    const deps = mod.dependencies.length
+      ? ` ${c.dim}(requires: ${mod.dependencies.join(', ')})${c.reset}`
+      : '';
+    console.log(`  [x] ${c.bold}${mod.name}${c.reset} — ${mod.desc}${tag}${deps}`);
+  }
+
+  console.log(`\n  ${c.dim}Press Enter to install all (recommended), or type module names to toggle${c.reset}`);
+
+  const answer = await question(`\n  ${c.cyan}>${c.reset} `);
+  rl.close();
+
+  if (answer.trim() === '') {
+    return MODULES.map((m) => m.id);
+  }
+
+  const selected = new Set(MODULES.map((m) => m.id));
+  const toggles = answer.toLowerCase().split(/[,\s]+/).filter(Boolean);
+  for (const toggle of toggles) {
+    const mod = MODULES.find(
+      (m) => m.id === toggle || m.name.toLowerCase() === toggle
+    );
+    if (mod) {
+      if (selected.has(mod.id)) selected.delete(mod.id);
+      else selected.add(mod.id);
+    }
+  }
+
+  return [...selected];
+}
+
+// ─── Main ───────────────────────────────────────────────────
+async function main() {
+  const args = process.argv.slice(2);
+  const nonInteractive = args.includes('--all') || args.includes('--non-interactive');
+  const isStatus = args.includes('status');
+  const isUninstall = args.includes('uninstall');
+  const isUpdate = args.includes('update');
+
+  if (isStatus) {
+    if (!fs.existsSync(MANIFEST_PATH)) {
+      console.log(`\n  ${c.yellow}No modules installed. Run \`npx @accel/cli\` to get started.${c.reset}\n`);
+      process.exit(0);
+    }
+    const manifest = JSON.parse(fs.readFileSync(MANIFEST_PATH, 'utf8'));
+    console.log(`\n  ${c.cyan}${c.bold}${BRAND} v${manifest.version}${c.reset}\n`);
+    for (const [id, info] of Object.entries(manifest.modules)) {
+      console.log(`  ${c.green}\u2713${c.reset} ${info.name} (${id})`);
+    }
+    console.log(`\n  ${c.dim}Installed: ${manifest.installedAt}${c.reset}\n`);
+    process.exit(0);
+  }
+
+  if (isUninstall) {
+    console.log(`\n  ${c.yellow}Uninstalling ${BRAND}...${c.reset}`);
+    if (fs.existsSync(ACCEL_HOME)) fs.rmSync(ACCEL_HOME, { recursive: true, force: true });
+    for (const mod of MODULES) {
+      const cmdDir = path.join(CLAUDE_HOME, 'commands', mod.id);
+      if (fs.existsSync(cmdDir)) fs.rmSync(cmdDir, { recursive: true, force: true });
+    }
+    deregisterHooks();
+    console.log(`  ${c.green}\u2713${c.reset} ${BRAND} uninstalled.\n`);
+    process.exit(0);
+  }
+
+  if (fs.existsSync(MANIFEST_PATH) && !isUpdate && !nonInteractive) {
+    const manifest = JSON.parse(fs.readFileSync(MANIFEST_PATH, 'utf8'));
+    const modCount = Object.keys(manifest.modules).length;
+    console.log(`\n  ${c.yellow}${BRAND} is already installed (v${manifest.version}, ${modCount} modules).${c.reset}`);
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const answer = await new Promise((resolve) =>
+      rl.question(`  Update / Reinstall / Cancel? [u/r/C] `, resolve)
+    );
+    rl.close();
+    if (answer.toLowerCase() === 'c' || answer.trim() === '') {
+      console.log('  Cancelled.\n');
+      process.exit(0);
+    }
+  }
+
+  let selectedModules;
+  if (nonInteractive) {
+    selectedModules = MODULES.map((m) => m.id);
+  } else {
+    selectedModules = await selectModules();
+  }
+
+  const { resolved, autoAdded } = resolveDependencies(selectedModules);
+  for (const { module: mod, dependency: dep } of autoAdded) {
+    const modName = MODULES.find((m) => m.id === mod)?.name;
+    const depName = MODULES.find((m) => m.id === dep)?.name;
+    console.log(`  ${c.cyan}${modName} requires ${depName} \u2014 adding automatically${c.reset}`);
+  }
+
+  const issues = checkPrerequisites(resolved);
+  if (issues.length > 0) {
+    console.log(`\n  ${c.red}${c.bold}Prerequisites not met:${c.reset}`);
+    for (const issue of issues) {
+      console.log(`  ${c.red}\u2717${c.reset} ${issue}`);
+    }
+    process.exit(1);
+  }
+
+  console.log(`\n  ${c.bold}Installing ${BRAND}...${c.reset}\n`);
+
+  const installed = [];
+  const failed = [];
+
+  const installOrder = [];
+  const added = new Set();
+  function addWithDeps(modId) {
+    if (added.has(modId)) return;
+    const mod = MODULES.find((m) => m.id === modId);
+    if (!mod) return;
+    for (const dep of mod.dependencies) addWithDeps(dep);
+    installOrder.push(modId);
+    added.add(modId);
+  }
+  for (const modId of resolved) addWithDeps(modId);
+
+  for (const modId of installOrder) {
+    const mod = MODULES.find((m) => m.id === modId);
+    try {
+      installModule(modId);
+      installed.push(modId);
+      console.log(`  ${c.green}\u2713${c.reset} ${mod.name} installed (${mod.desc.split('\u2014')[0].trim()})`);
+    } catch (e) {
+      failed.push({ id: modId, error: e.message });
+      console.log(`  ${c.red}\u2717${c.reset} ${mod.name} failed: ${e.message}`);
+    }
+  }
+
+  setupEventBus();
+
+  if (installed.length > 0) {
+    writeManifest(installed);
+    installClaudeMdBlock();
+    registerMcpServers(installed);
+    registerHooks(installed);
+  }
+
+  console.log('');
+  if (failed.length > 0) {
+    console.log(`  ${c.yellow}${installed.length}/${installOrder.length} modules installed. Run \`npx @accel/cli repair\` to retry.${c.reset}`);
+    for (const f of failed) {
+      console.log(`  ${c.red}\u2717${c.reset} ${f.id}: ${f.error}`);
+    }
+  } else {
+    console.log(`  ${c.green}${c.bold}${BRAND} is ready!${c.reset} Restart Claude Code and try:`);
+    console.log(`    ${c.cyan}/accel status${c.reset}     \u2014 see what's installed`);
+    console.log(`    ${c.cyan}/accel help${c.reset}       \u2014 see all commands`);
+    console.log(`    ${c.cyan}/ignition${c.reset}         \u2014 start a new project`);
+  }
+  console.log('');
+}
+
+main().catch((e) => {
+  console.error(`${c.red}Error: ${e.message}${c.reset}`);
+  process.exit(1);
+});