legion-cc 0.1.0

package/bin/install.js

@@ -0,0 +1,898 @@
+#!/usr/bin/env node
+
+// Legion Installer — bin/install.js
+// Entry point for `npx legion-cc@latest`
+// Copies Legion framework files into ~/.claude/ (or custom config dir)
+//
+// CommonJS, no external dependencies — only Node.js built-ins.
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const crypto = require('crypto');
+
+// ─── Colors ──────────────────────────────────────────────────────────────────
+
+const bold = '\x1b[1m';
+const dim = '\x1b[2m';
+const red = '\x1b[31m';
+const green = '\x1b[32m';
+const yellow = '\x1b[33m';
+const cyan = '\x1b[36m';
+const reset = '\x1b[0m';
+
+// Disable colors when not a TTY
+const isTTY = process.stdout.isTTY;
+function c(color, text) {
+  return isTTY ? `${color}${text}${reset}` : text;
+}
+
+// ─── Read version ────────────────────────────────────────────────────────────
+
+const srcDir = path.resolve(__dirname, '..');
+const versionFile = path.join(srcDir, 'VERSION');
+let version = '0.0.0';
+try {
+  version = fs.readFileSync(versionFile, 'utf8').trim();
+} catch (_) {
+  // Try package.json as fallback
+  try {
+    const pkg = require(path.join(srcDir, 'package.json'));
+    version = pkg.version || '0.0.0';
+  } catch (_2) {
+    // Keep default
+  }
+}
+
+// ─── Parse CLI flags ─────────────────────────────────────────────────────────
+
+const args = process.argv.slice(2);
+
+function hasFlag(name) {
+  return args.includes(name);
+}
+
+function getFlagValue(name) {
+  const idx = args.indexOf(name);
+  if (idx !== -1 && idx + 1 < args.length) {
+    const val = args[idx + 1];
+    if (!val.startsWith('-')) return val;
+  }
+  // Also handle --flag=value
+  const eqArg = args.find(a => a.startsWith(name + '='));
+  if (eqArg) {
+    const val = eqArg.split('=').slice(1).join('=');
+    if (val) return val;
+  }
+  return null;
+}
+
+const flagForce = hasFlag('--force');
+const flagDryRun = hasFlag('--dry-run');
+const flagUninstall = hasFlag('--uninstall');
+const flagHelp = hasFlag('--help') || hasFlag('-h');
+const flagConfigDir = getFlagValue('--config-dir');
+
+// ─── Help ────────────────────────────────────────────────────────────────────
+
+if (flagHelp) {
+  console.log(`
+${c(bold + cyan, 'Legion')} ${c(dim, 'v' + version)} — Installer
+
+${c(yellow, 'Usage:')} npx legion-cc [options]
+
+${c(yellow, 'Options:')}
+  ${c(cyan, '--force')}              Overwrite existing agent files
+  ${c(cyan, '--dry-run')}            Show what would happen without doing it
+  ${c(cyan, '--uninstall')}          Remove Legion from ~/.claude/
+  ${c(cyan, '--config-dir <path>')}  Custom config directory (default: ~/.claude)
+  ${c(cyan, '--help, -h')}           Show this help message
+
+${c(yellow, 'Examples:')}
+  ${c(dim, '# Install Legion')}
+  npx legion-cc
+
+  ${c(dim, '# Install with force-overwrite of agents')}
+  npx legion-cc --force
+
+  ${c(dim, '# Preview without changes')}
+  npx legion-cc --dry-run
+
+  ${c(dim, '# Uninstall')}
+  npx legion-cc --uninstall
+
+${c(yellow, 'Environment:')}
+  CLAUDE_CONFIG_DIR    Override config directory (same as --config-dir)
+`);
+  process.exit(0);
+}
+
+// ─── Determine paths ─────────────────────────────────────────────────────────
+
+const configDir = process.env.CLAUDE_CONFIG_DIR
+  || flagConfigDir
+  || path.join(os.homedir(), '.claude');
+
+// ─── Banner ──────────────────────────────────────────────────────────────────
+
+function printBanner() {
+  console.log('');
+  console.log(c(bold + cyan, '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+  console.log(c(bold + cyan, ' LEGION') + ' ' + c(dim, 'v' + version) + c(bold + cyan, ' — Installer'));
+  console.log(c(bold + cyan, '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+  console.log('');
+}
+
+printBanner();
+
+if (flagDryRun) {
+  console.log(c(yellow, '  [DRY RUN] No files will be written.'));
+  console.log('');
+}
+
+// ─── Logging helpers ─────────────────────────────────────────────────────────
+
+function logStep(msg) {
+  console.log(`  ${c(bold + cyan, '==>') } ${msg}`);
+}
+
+function logOk(msg) {
+  console.log(`  ${c(green, '+')} ${msg}`);
+}
+
+function logSkip(msg) {
+  console.log(`  ${c(dim, '-')} ${msg} ${c(dim, '(skipped)')}`);
+}
+
+function logWarn(msg) {
+  console.log(`  ${c(yellow, '!')} ${msg}`);
+}
+
+function logErr(msg) {
+  console.error(`  ${c(red, 'ERROR:')} ${msg}`);
+}
+
+// ─── Counters ────────────────────────────────────────────────────────────────
+
+const counts = {
+  commands: 0,
+  workflows: 0,
+  templates: 0,
+  references: 0,
+  hooks: 0,
+  agents: 0,
+  bin: 0,
+  other: 0,
+};
+let totalFiles = 0;
+let skippedFiles = 0;
+
+// ─── File utility helpers ────────────────────────────────────────────────────
+
+/**
+ * Recursively count files in a directory.
+ */
+function countFilesInDir(dir) {
+  let count = 0;
+  if (!fs.existsSync(dir)) return 0;
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      count += countFilesInDir(full);
+    } else if (entry.isFile()) {
+      count++;
+    }
+  }
+  return count;
+}
+
+/**
+ * Compute SHA256 hex digest of a file.
+ */
+function sha256File(filePath) {
+  const data = fs.readFileSync(filePath);
+  return crypto.createHash('sha256').update(data).digest('hex');
+}
+
+/**
+ * Recursively walk a directory and return all file paths.
+ */
+function walkDir(dir, fileList) {
+  fileList = fileList || [];
+  if (!fs.existsSync(dir)) return fileList;
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      walkDir(full, fileList);
+    } else if (entry.isFile()) {
+      fileList.push(full);
+    }
+  }
+  return fileList;
+}
+
+/**
+ * Ensure a directory exists (create recursively if needed).
+ */
+function ensureDir(dir) {
+  if (flagDryRun) return;
+  try {
+    fs.mkdirSync(dir, { recursive: true });
+  } catch (err) {
+    if (err.code !== 'EEXIST') {
+      logWarn(`Could not create directory ${dir}: ${err.message}`);
+    }
+  }
+}
+
+/**
+ * Copy a single file. Creates parent directories as needed.
+ */
+function copyFile(src, dest) {
+  if (flagDryRun) {
+    console.log(`  ${c(dim, '[dry-run]')} cp ${src} -> ${dest}`);
+    return true;
+  }
+  try {
+    ensureDir(path.dirname(dest));
+    fs.copyFileSync(src, dest);
+    return true;
+  } catch (err) {
+    logWarn(`Could not copy ${src} -> ${dest}: ${err.message}`);
+    return false;
+  }
+}
+
+/**
+ * Copy a directory recursively using fs.cpSync.
+ * Returns the number of files copied.
+ */
+function copyDir(src, dest) {
+  if (!fs.existsSync(src)) {
+    logWarn(`Source directory not found: ${src}`);
+    return 0;
+  }
+
+  const fileCount = countFilesInDir(src);
+
+  if (flagDryRun) {
+    console.log(`  ${c(dim, '[dry-run]')} cpSync ${src}/ -> ${dest}/ (${fileCount} files)`);
+    return fileCount;
+  }
+
+  try {
+    ensureDir(dest);
+    fs.cpSync(src, dest, { recursive: true, force: true });
+    return fileCount;
+  } catch (err) {
+    logWarn(`Could not copy directory ${src} -> ${dest}: ${err.message}`);
+    return 0;
+  }
+}
+
+/**
+ * Read and parse a JSON file, returning null on failure.
+ */
+function readJSON(filePath) {
+  try {
+    const raw = fs.readFileSync(filePath, 'utf8');
+    return JSON.parse(raw);
+  } catch (_) {
+    return null;
+  }
+}
+
+/**
+ * Write a JSON file with pretty formatting.
+ */
+function writeJSON(filePath, data) {
+  if (flagDryRun) {
+    console.log(`  ${c(dim, '[dry-run]')} write ${filePath}`);
+    return;
+  }
+  try {
+    ensureDir(path.dirname(filePath));
+    fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + '\n');
+  } catch (err) {
+    logWarn(`Could not write ${filePath}: ${err.message}`);
+  }
+}
+
+// ─── Check prerequisites ────────────────────────────────────────────────────
+
+function checkPrerequisites() {
+  logStep('Checking prerequisites...');
+
+  // Node.js >= 18
+  const nodeVersion = process.versions.node;
+  const major = parseInt(nodeVersion.split('.')[0], 10);
+  if (major < 18) {
+    logErr(`Node.js >= 18 is required (found v${nodeVersion}).`);
+    logErr('Install from https://nodejs.org');
+    process.exit(1);
+  }
+  logOk(`Node.js v${nodeVersion}`);
+
+  // configDir — create if not exists
+  if (!fs.existsSync(configDir)) {
+    logWarn(`Config directory ${configDir} does not exist, creating...`);
+    ensureDir(configDir);
+    if (!flagDryRun && !fs.existsSync(configDir)) {
+      logErr(`Could not create config directory: ${configDir}`);
+      logErr('Please install Claude Code first: https://claude.ai/download');
+      process.exit(1);
+    }
+  }
+  logOk(`Config directory: ${configDir}`);
+
+  console.log('');
+}
+
+// ─── Install logic ──────────────────────────────────────────────────────────
+
+function doInstall() {
+  checkPrerequisites();
+
+  // ── Step 1: Copy files ──────────────────────────────────────────────────
+
+  // commands/legion/ -> commands/legion/
+  logStep('Copying commands...');
+  const commandsSrc = path.join(srcDir, 'commands', 'legion');
+  const commandsDest = path.join(configDir, 'commands', 'legion');
+  const commandCount = copyDir(commandsSrc, commandsDest);
+  counts.commands = commandCount;
+  totalFiles += commandCount;
+  logOk(`${commandCount} command files`);
+
+  // workflows/ -> legion/workflows/
+  logStep('Copying workflows...');
+  const workflowsSrc = path.join(srcDir, 'workflows');
+  const workflowsDest = path.join(configDir, 'legion', 'workflows');
+  const workflowCount = copyDir(workflowsSrc, workflowsDest);
+  counts.workflows = workflowCount;
+  totalFiles += workflowCount;
+  logOk(`${workflowCount} workflow files`);
+
+  // templates/ -> legion/templates/
+  logStep('Copying templates...');
+  const templatesSrc = path.join(srcDir, 'templates');
+  const templatesDest = path.join(configDir, 'legion', 'templates');
+  const templateCount = copyDir(templatesSrc, templatesDest);
+  counts.templates = templateCount;
+  totalFiles += templateCount;
+  logOk(`${templateCount} template files`);
+
+  // references/ -> legion/references/
+  logStep('Copying references...');
+  const referencesSrc = path.join(srcDir, 'references');
+  const referencesDest = path.join(configDir, 'legion', 'references');
+  const referenceCount = copyDir(referencesSrc, referencesDest);
+  counts.references = referenceCount;
+  totalFiles += referenceCount;
+  logOk(`${referenceCount} reference files`);
+
+  // bin/legion-tools.cjs -> legion/bin/legion-tools.cjs
+  logStep('Copying bin...');
+  const toolsSrc = path.join(srcDir, 'bin', 'legion-tools.cjs');
+  const toolsDest = path.join(configDir, 'legion', 'bin', 'legion-tools.cjs');
+  if (copyFile(toolsSrc, toolsDest)) {
+    counts.bin++;
+    totalFiles++;
+  }
+
+  // bin/lib/ -> legion/bin/lib/
+  const libSrc = path.join(srcDir, 'bin', 'lib');
+  const libDest = path.join(configDir, 'legion', 'bin', 'lib');
+  const libCount = copyDir(libSrc, libDest);
+  counts.bin += libCount;
+  totalFiles += libCount;
+  logOk(`${counts.bin} bin files`);
+
+  // VERSION -> legion/VERSION
+  logStep('Copying VERSION...');
+  const versionSrc = path.join(srcDir, 'VERSION');
+  const versionDest = path.join(configDir, 'legion', 'VERSION');
+  if (copyFile(versionSrc, versionDest)) {
+    counts.other++;
+    totalFiles++;
+  }
+  logOk('VERSION');
+
+  // hooks/legion-context-monitor.js -> hooks/legion-context-monitor.js
+  // hooks/legion-statusline.js -> hooks/legion-statusline.js
+  logStep('Copying hooks...');
+  const hookFiles = ['legion-context-monitor.js', 'legion-statusline.js'];
+  for (const hookName of hookFiles) {
+    const hookSrc = path.join(srcDir, 'hooks', hookName);
+    const hookDest = path.join(configDir, 'hooks', hookName);
+    if (fs.existsSync(hookSrc)) {
+      if (copyFile(hookSrc, hookDest)) {
+        counts.hooks++;
+        totalFiles++;
+        logOk(hookName);
+      }
+    } else {
+      logWarn(`Hook source not found: ${hookSrc}`);
+    }
+  }
+
+  // agents/legion-orchestrator.md -> agents/legion-orchestrator.md (skip if exists unless --force)
+  logStep('Copying agents...');
+  const agentsSrc = path.join(srcDir, 'agents');
+  if (fs.existsSync(agentsSrc)) {
+    const agentFiles = fs.readdirSync(agentsSrc).filter(f => f.endsWith('.md'));
+    for (const agentFile of agentFiles) {
+      const src = path.join(agentsSrc, agentFile);
+      const dest = path.join(configDir, 'agents', agentFile);
+
+      if (fs.existsSync(dest) && !flagForce) {
+        logSkip(`agents/${agentFile} already exists (use --force to overwrite)`);
+        skippedFiles++;
+        continue;
+      }
+
+      if (copyFile(src, dest)) {
+        counts.agents++;
+        totalFiles++;
+        logOk(`agents/${agentFile}`);
+      }
+    }
+  }
+
+  // ── Step 2: Make hooks executable ────────────────────────────────────────
+
+  logStep('Making hooks executable...');
+  for (const hookName of hookFiles) {
+    const hookPath = path.join(configDir, 'hooks', hookName);
+    if (flagDryRun) {
+      console.log(`  ${c(dim, '[dry-run]')} chmod 755 ${hookPath}`);
+    } else {
+      try {
+        if (fs.existsSync(hookPath)) {
+          fs.chmodSync(hookPath, 0o755);
+          logOk(`chmod 755 ${hookName}`);
+        }
+      } catch (err) {
+        logWarn(`Could not chmod ${hookPath}: ${err.message}`);
+      }
+    }
+  }
+
+  // ── Step 3: Register hooks in settings ──────────────────────────────────
+
+  logStep('Registering hooks in settings...');
+  registerHooks();
+
+  // ── Step 4: Generate manifest ───────────────────────────────────────────
+
+  logStep('Generating file manifest...');
+  generateManifest();
+
+  // ── Step 5: Print summary ───────────────────────────────────────────────
+
+  printSummary();
+}
+
+// ─── Register hooks in settings.json ─────────────────────────────────────────
+
+function registerHooks() {
+  // Determine settings file
+  let settingsPath = null;
+  const settingsLocalPath = path.join(configDir, 'settings.local.json');
+  const settingsJsonPath = path.join(configDir, 'settings.json');
+
+  if (fs.existsSync(settingsLocalPath)) {
+    settingsPath = settingsLocalPath;
+  } else if (fs.existsSync(settingsJsonPath)) {
+    settingsPath = settingsJsonPath;
+  } else {
+    // No settings file exists — create settings.local.json
+    settingsPath = settingsLocalPath;
+    if (!flagDryRun) {
+      writeJSON(settingsPath, {});
+    }
+    logOk(`Created ${settingsPath}`);
+  }
+
+  const settings = readJSON(settingsPath) || {};
+
+  let changed = false;
+
+  // ── PostToolUse hook: legion-context-monitor.js ──
+
+  const contextMonitorCmd = `node "${path.join(configDir, 'hooks', 'legion-context-monitor.js').replace(/\\/g, '/')}"`;
+
+  if (!settings.hooks) {
+    settings.hooks = {};
+  }
+  if (!Array.isArray(settings.hooks.PostToolUse)) {
+    settings.hooks.PostToolUse = [];
+  }
+
+  const alreadyRegistered = settings.hooks.PostToolUse.some(entry => {
+    const entryStr = JSON.stringify(entry);
+    return entryStr.includes('legion-context-monitor');
+  });
+
+  if (!alreadyRegistered) {
+    settings.hooks.PostToolUse.push({
+      hooks: [
+        {
+          type: 'command',
+          command: contextMonitorCmd,
+        },
+      ],
+    });
+    changed = true;
+    logOk('Registered PostToolUse: legion-context-monitor.js');
+  } else {
+    logSkip('PostToolUse: legion-context-monitor.js already registered');
+  }
+
+  // ── StatusLine: legion-statusline.js ──
+
+  const statuslineCmd = `node "${path.join(configDir, 'hooks', 'legion-statusline.js').replace(/\\/g, '/')}"`;
+
+  const currentStatusLine = settings.statusLine || null;
+  const currentCmd = (currentStatusLine && typeof currentStatusLine === 'object')
+    ? (currentStatusLine.command || '')
+    : '';
+
+  if (!currentStatusLine) {
+    // No statusline configured — set Legion's
+    settings.statusLine = {
+      type: 'command',
+      command: statuslineCmd,
+    };
+    changed = true;
+    logOk('Configured statusLine: legion-statusline.js');
+  } else if (currentCmd.includes('legion-statusline')) {
+    logSkip('statusLine: legion-statusline.js already configured');
+  } else if (currentCmd.includes('gsd-statusline')) {
+    logWarn('GSD statusline is currently active.');
+    logWarn('Only one statusline can be active at a time.');
+    logWarn(`To switch to Legion, manually update "statusLine" in ${settingsPath}`);
+  } else if (currentCmd) {
+    logWarn(`Another statusline is configured: ${currentCmd}`);
+    logWarn(`To use Legion statusline, update "statusLine" in ${settingsPath}`);
+  }
+
+  // Write settings if changed
+  if (changed) {
+    writeJSON(settingsPath, settings);
+    logOk(`Updated ${settingsPath}`);
+  }
+}
+
+// ─── Generate manifest ──────────────────────────────────────────────────────
+
+function generateManifest() {
+  const manifestPath = path.join(configDir, 'legion-file-manifest.json');
+
+  const manifest = {
+    version: version,
+    timestamp: new Date().toISOString(),
+    files: {},
+  };
+
+  // Directories to scan for manifest
+  const scanDirs = [
+    path.join(configDir, 'legion'),
+    path.join(configDir, 'commands', 'legion'),
+  ];
+
+  // Individual files to include
+  const scanFiles = [
+    path.join(configDir, 'hooks', 'legion-context-monitor.js'),
+    path.join(configDir, 'hooks', 'legion-statusline.js'),
+  ];
+
+  // Also include agent files we installed
+  const agentsSrc = path.join(srcDir, 'agents');
+  if (fs.existsSync(agentsSrc)) {
+    const agentFiles = fs.readdirSync(agentsSrc).filter(f => f.endsWith('.md'));
+    for (const agentFile of agentFiles) {
+      scanFiles.push(path.join(configDir, 'agents', agentFile));
+    }
+  }
+
+  if (flagDryRun) {
+    console.log(`  ${c(dim, '[dry-run]')} would write ${manifestPath}`);
+    return;
+  }
+
+  // Walk directories
+  for (const dir of scanDirs) {
+    const files = walkDir(dir);
+    for (const filePath of files) {
+      const rel = path.relative(configDir, filePath);
+      try {
+        manifest.files[rel] = sha256File(filePath);
+      } catch (err) {
+        logWarn(`Could not hash ${filePath}: ${err.message}`);
+      }
+    }
+  }
+
+  // Hash individual files
+  for (const filePath of scanFiles) {
+    if (fs.existsSync(filePath)) {
+      const rel = path.relative(configDir, filePath);
+      try {
+        manifest.files[rel] = sha256File(filePath);
+      } catch (err) {
+        logWarn(`Could not hash ${filePath}: ${err.message}`);
+      }
+    }
+  }
+
+  // Sort keys
+  const sortedFiles = {};
+  for (const key of Object.keys(manifest.files).sort()) {
+    sortedFiles[key] = manifest.files[key];
+  }
+  manifest.files = sortedFiles;
+
+  writeJSON(manifestPath, manifest);
+  logOk(`Manifest written: ${manifestPath} (${Object.keys(manifest.files).length} files)`);
+}
+
+// ─── Print summary ──────────────────────────────────────────────────────────
+
+function printSummary() {
+  console.log('');
+  console.log(`  ${c(bold + green, 'Legion v' + version + ' installed to ' + configDir + '/')}`);
+  console.log('');
+  console.log(`  Commands:   ${c(bold, String(counts.commands))} (commands/legion/)`);
+  console.log(`  Workflows:  ${c(bold, String(counts.workflows))} (legion/workflows/)`);
+  console.log(`  Templates:  ${c(bold, String(counts.templates))} (legion/templates/)`);
+  console.log(`  References: ${c(bold, String(counts.references))} (legion/references/)`);
+  console.log(`  Hooks:      ${c(bold, String(counts.hooks))} (hooks/)`);
+  console.log(`  Agents:     ${c(bold, String(counts.agents))} (agents/)`);
+  console.log(`  Bin:        ${c(bold, String(counts.bin))} (legion/bin/)`);
+  console.log('');
+  console.log(`  Total: ${c(bold, String(totalFiles))} files installed`);
+  if (skippedFiles > 0) {
+    console.log(`  Skipped: ${c(dim, String(skippedFiles))} files`);
+  }
+  console.log('');
+  console.log(`  ${c(dim, 'To get started:')}`);
+  console.log(`    ${c(cyan, '/legion:devops:quick <task>')}`);
+  console.log(`    ${c(cyan, '/legion:devops:architect <task>')}`);
+  console.log(`    ${c(cyan, '/legion:status')}`);
+  console.log('');
+}
+
+// ─── Uninstall logic ────────────────────────────────────────────────────────
+
+function doUninstall() {
+  checkPrerequisites();
+
+  logStep('Uninstalling Legion...');
+
+  const manifestPath = path.join(configDir, 'legion-file-manifest.json');
+  const manifest = readJSON(manifestPath);
+
+  let removedCount = 0;
+  let failedCount = 0;
+
+  // ── Step 1: Remove manifested files ──
+
+  if (manifest && manifest.files) {
+    logStep('Removing manifested files...');
+    const files = Object.keys(manifest.files).sort().reverse();
+    let agentsSkipped = 0;
+    for (const rel of files) {
+      // Do NOT remove agent files — they may have been customized by the user
+      if (rel.startsWith('agents/') || rel.startsWith('agents\\')) {
+        agentsSkipped++;
+        continue;
+      }
+      const filePath = path.join(configDir, rel);
+      if (flagDryRun) {
+        console.log(`  ${c(dim, '[dry-run]')} rm ${filePath}`);
+        removedCount++;
+        continue;
+      }
+      try {
+        if (fs.existsSync(filePath)) {
+          fs.unlinkSync(filePath);
+          removedCount++;
+        }
+      } catch (err) {
+        logWarn(`Could not remove ${filePath}: ${err.message}`);
+        failedCount++;
+      }
+    }
+    logOk(`Removed ${removedCount} manifested files`);
+    if (agentsSkipped > 0) {
+      logOk(`Preserved ${agentsSkipped} agent file(s) in agents/`);
+    }
+  } else {
+    logWarn('No manifest found, performing directory-based cleanup...');
+  }
+
+  // ── Step 2: Remove directories ──
+
+  logStep('Removing directories...');
+
+  // Remove ~/.claude/legion/
+  const legionDir = path.join(configDir, 'legion');
+  removeDir(legionDir);
+
+  // Remove ~/.claude/commands/legion/
+  const commandsLegionDir = path.join(configDir, 'commands', 'legion');
+  removeDir(commandsLegionDir);
+
+  // ── Step 3: Remove hooks ──
+
+  logStep('Removing hooks...');
+  const hookFiles = [
+    path.join(configDir, 'hooks', 'legion-context-monitor.js'),
+    path.join(configDir, 'hooks', 'legion-statusline.js'),
+  ];
+  for (const hookPath of hookFiles) {
+    if (flagDryRun) {
+      if (fs.existsSync(hookPath)) {
+        console.log(`  ${c(dim, '[dry-run]')} rm ${hookPath}`);
+      }
+      continue;
+    }
+    try {
+      if (fs.existsSync(hookPath)) {
+        fs.unlinkSync(hookPath);
+        logOk(`Removed ${path.basename(hookPath)}`);
+      }
+    } catch (err) {
+      logWarn(`Could not remove ${hookPath}: ${err.message}`);
+    }
+  }
+
+  // ── Step 4: Unregister hooks from settings ──
+
+  logStep('Unregistering hooks from settings...');
+  unregisterHooks();
+
+  // ── Step 5: Remove manifest ──
+
+  if (flagDryRun) {
+    if (fs.existsSync(manifestPath)) {
+      console.log(`  ${c(dim, '[dry-run]')} rm ${manifestPath}`);
+    }
+  } else {
+    try {
+      if (fs.existsSync(manifestPath)) {
+        fs.unlinkSync(manifestPath);
+        logOk('Removed legion-file-manifest.json');
+      }
+    } catch (err) {
+      logWarn(`Could not remove manifest: ${err.message}`);
+    }
+  }
+
+  // ── Summary ──
+
+  console.log('');
+  console.log(`  ${c(bold + green, 'Legion v' + version + ' uninstalled from ' + configDir + '/')}`);
+  console.log('');
+  console.log(`  ${c(dim, 'Removed:')} ${removedCount} files`);
+  if (failedCount > 0) {
+    console.log(`  ${c(yellow, 'Failed:')}  ${failedCount} files`);
+  }
+  console.log('');
+  console.log(`  ${c(dim, 'Note: Agent files (agents/) and project data (.planning/legion/) were NOT removed.')}`);
+  console.log('');
+}
+
+/**
+ * Recursively remove a directory and its contents.
+ */
+function removeDir(dir) {
+  if (!fs.existsSync(dir)) return;
+
+  if (flagDryRun) {
+    const count = countFilesInDir(dir);
+    console.log(`  ${c(dim, '[dry-run]')} rmdir ${dir} (${count} files)`);
+    return;
+  }
+
+  try {
+    fs.rmSync(dir, { recursive: true, force: true });
+    logOk(`Removed ${dir}`);
+  } catch (err) {
+    logWarn(`Could not remove ${dir}: ${err.message}`);
+  }
+}
+
+/**
+ * Remove Legion hooks from settings.json.
+ */
+function unregisterHooks() {
+  let settingsPath = null;
+  const settingsLocalPath = path.join(configDir, 'settings.local.json');
+  const settingsJsonPath = path.join(configDir, 'settings.json');
+
+  if (fs.existsSync(settingsLocalPath)) {
+    settingsPath = settingsLocalPath;
+  } else if (fs.existsSync(settingsJsonPath)) {
+    settingsPath = settingsJsonPath;
+  }
+
+  if (!settingsPath) {
+    logSkip('No settings file found');
+    return;
+  }
+
+  const settings = readJSON(settingsPath);
+  if (!settings) {
+    logWarn(`Could not parse ${settingsPath}`);
+    return;
+  }
+
+  let changed = false;
+
+  // Remove PostToolUse hook entries that reference legion-context-monitor
+  if (settings.hooks && Array.isArray(settings.hooks.PostToolUse)) {
+    const before = settings.hooks.PostToolUse.length;
+    settings.hooks.PostToolUse = settings.hooks.PostToolUse.filter(entry => {
+      const entryStr = JSON.stringify(entry);
+      return !entryStr.includes('legion-context-monitor');
+    });
+    if (settings.hooks.PostToolUse.length < before) {
+      changed = true;
+      logOk('Removed PostToolUse: legion-context-monitor.js');
+    }
+    // Clean up empty arrays/objects
+    if (settings.hooks.PostToolUse.length === 0) {
+      delete settings.hooks.PostToolUse;
+    }
+    if (Object.keys(settings.hooks).length === 0) {
+      delete settings.hooks;
+    }
+  }
+
+  // Remove statusLine if it references legion
+  if (settings.statusLine) {
+    const cmd = (typeof settings.statusLine === 'object')
+      ? (settings.statusLine.command || '')
+      : '';
+    if (cmd.includes('legion-statusline')) {
+      delete settings.statusLine;
+      changed = true;
+      logOk('Removed statusLine: legion-statusline.js');
+    }
+  }
+
+  if (changed) {
+    writeJSON(settingsPath, settings);
+    logOk(`Updated ${settingsPath}`);
+  } else {
+    logSkip('No Legion hooks found in settings');
+  }
+}
+
+// ─── Main ────────────────────────────────────────────────────────────────────
+
+function main() {
+  try {
+    if (flagUninstall) {
+      doUninstall();
+    } else {
+      doInstall();
+    }
+    process.exit(0);
+  } catch (err) {
+    console.error('');
+    logErr(`Unexpected error: ${err.message}`);
+    if (err.stack) {
+      console.error(c(dim, err.stack));
+    }
+    process.exit(1);
+  }
+}
+
+main();