bi-superpowers 1.0.0

package/bin/commands/uninstall.js

@@ -0,0 +1,611 @@
+/**
+ * Uninstall Command — Multi-agent skill + MCP remover
+ * ====================================================
+ *
+ * The exact inverse of `super install`. Removes the bi-superpowers skills
+ * and the 2 Microsoft MCP servers from every selected agent, touching ONLY
+ * what we installed:
+ *   - Skills: deletes our managed skill directories (the symlink, or our
+ *     own skill subdirs in a copy-fallback dir). Never removes a user's
+ *     unrelated skills.
+ *   - MCPs: deletes only the `powerbi-modeling-mcp` + `microsoft-learn`
+ *     entries from each agent's config, preserving every other server and
+ *     top-level key (see `lib/mcp-config.js` → removeMcpConfigForAgent).
+ *
+ * Safety:
+ *   - `--dry-run` previews every change without writing anything.
+ *   - A confirmation prompt guards the destructive run unless `--yes`.
+ *   - Each config rewrite goes through the same atomic + `.bak` backup
+ *     pattern the installer uses.
+ *   - The universal skills dir (~/.agents/skills, also Codex's dir and the
+ *     symlink target for other agents) is only deleted when every agent
+ *     that consumes it is part of this uninstall.
+ *
+ * Fully open source (MIT). CLI copy, comments, and JSDoc stay in English.
+ *
+ * Usage:
+ *   super uninstall
+ *   super uninstall --all --yes
+ *   super uninstall --agent claude-code --agent codex
+ *   super uninstall --dry-run
+ *   super uninstall --skills-only        # leave MCP config untouched
+ *   super uninstall --mcp-only           # leave skills on disk
+ *
+ * @module commands/uninstall
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const readline = require('readline');
+const { AGENTS, UNIVERSAL_DIR } = require('../lib/agents');
+const { removeMcpConfigForAgent } = require('../lib/mcp-config');
+
+const LEGACY_SESSION_DIR = '.bi-superpowers';
+
+/**
+ * Parse CLI arguments into an options object. Mirrors install's flags and
+ * adds `--dry-run`, `--skills-only`, and `--mcp-only`.
+ */
+function parseArgs(args) {
+  const opts = {
+    isYes: args.includes('--yes') || args.includes('-y'),
+    isAll: args.includes('--all'),
+    isDryRun: args.includes('--dry-run'),
+    skillsOnly: args.includes('--skills-only'),
+    mcpOnly: args.includes('--mcp-only'),
+    agentFlags: [],
+  };
+
+  // Contradictory scope flags cancel out into a full uninstall.
+  if (opts.skillsOnly && opts.mcpOnly) {
+    console.warn('⚠ --skills-only and --mcp-only are mutually exclusive. Doing a full uninstall.');
+    opts.skillsOnly = false;
+    opts.mcpOnly = false;
+  }
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--agent' || args[i] === '-a') {
+      const next = args[i + 1];
+      if (next === undefined || next.startsWith('-')) {
+        console.warn(
+          `⚠ Flag ${args[i]} is missing a value. Usage: ${args[i]} <agent-id>. Ignoring.`
+        );
+        continue;
+      }
+      opts.agentFlags.push(next);
+      i++;
+    }
+  }
+
+  return opts;
+}
+
+/**
+ * Create a readline interface for interactive prompts.
+ */
+function createReadline() {
+  return readline.createInterface({ input: process.stdin, output: process.stdout });
+}
+
+/**
+ * Promise-wrapped readline question.
+ */
+function prompt(rl, question) {
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => resolve(answer.trim()));
+  });
+}
+
+/**
+ * Resolve the symlink target of a path, or null if it isn't a symlink or
+ * can't be resolved.
+ */
+function symlinkRealTarget(linkPath) {
+  const st = fs.lstatSync(linkPath, { throwIfNoEntry: false });
+  if (!st || !st.isSymbolicLink()) return null;
+  try {
+    return fs.realpathSync(linkPath);
+  } catch (_) {
+    return null;
+  }
+}
+
+/**
+ * Does `linkPath` resolve to the universal skills directory? Used to decide
+ * whether an agent still consumes the universal copy.
+ */
+function isSymlinkToUniversal(linkPath, baseDir) {
+  const target = symlinkRealTarget(linkPath);
+  if (!target) return false;
+  const universal = path.join(baseDir, UNIVERSAL_DIR);
+  let resolvedUniversal = universal;
+  try {
+    resolvedUniversal = fs.realpathSync(universal);
+  } catch (_) {
+    /* universal may not exist; fall back to the joined path */
+  }
+  return path.resolve(target) === path.resolve(resolvedUniversal);
+}
+
+/**
+ * Read the managed skill names from the installed package's `skills/` dir.
+ * These are the only skill directories uninstall will ever delete, so the
+ * removal stays in lockstep with whatever the package actually ships.
+ */
+function getManagedSkillNames(packageDir) {
+  const skillsSourceDir = path.join(packageDir, 'skills');
+  if (!fs.existsSync(skillsSourceDir)) return [];
+  return fs
+    .readdirSync(skillsSourceDir, { withFileTypes: true })
+    .filter((d) => d.isDirectory() && fs.existsSync(path.join(skillsSourceDir, d.name, 'SKILL.md')))
+    .map((d) => d.name);
+}
+
+/**
+ * Detect agents that currently have a bi-superpowers footprint (managed
+ * skills installed or our MCP servers configured). Used to pre-select the
+ * interactive list so the user removes exactly what's installed.
+ */
+function detectInstalledAgents(baseDir, skillNames) {
+  const detected = [];
+  for (const id of Object.keys(AGENTS)) {
+    if (hasSkillFootprint(baseDir, id, skillNames) || hasMcpFootprint(baseDir, id)) {
+      detected.push(id);
+    }
+  }
+  return detected;
+}
+
+/**
+ * Skill footprint: the agent's dir is a symlink to universal, or it holds
+ * at least one of our managed skill subdirs (copy fallback / universal).
+ */
+function hasSkillFootprint(baseDir, agentId, skillNames) {
+  const agent = AGENTS[agentId];
+  const dir = path.join(baseDir, agent.dir);
+  const st = fs.lstatSync(dir, { throwIfNoEntry: false });
+  if (!st) return false;
+  if (st.isSymbolicLink()) return true;
+  return skillNames.some((name) => fs.existsSync(path.join(dir, name, 'SKILL.md')));
+}
+
+/**
+ * MCP footprint: the agent's config file mentions our modeling server name.
+ * A cheap substring check is enough for pre-selection; the actual removal
+ * is precise.
+ */
+function hasMcpFootprint(baseDir, agentId) {
+  const configPaths = {
+    'claude-code': path.join(baseDir, '.claude.json'),
+    'github-copilot': path.join(baseDir, '.copilot', 'mcp-config.json'),
+    codex: path.join(baseDir, '.codex', 'config.toml'),
+    'gemini-cli': path.join(baseDir, '.gemini', 'settings.json'),
+    kilo: path.join(baseDir, '.config', 'kilo', 'kilo.jsonc'),
+  };
+  const configPath = configPaths[agentId];
+  if (!configPath || !fs.existsSync(configPath)) return false;
+  try {
+    return fs.readFileSync(configPath, 'utf8').includes('powerbi-modeling-mcp');
+  } catch (_) {
+    return false;
+  }
+}
+
+/**
+ * Render a numbered multi-select list and wait for the user's choice.
+ */
+async function selectMultiple(rl, items, preselected = []) {
+  items.forEach((item, i) => {
+    const marker = preselected.includes(item.id) ? '●' : '○';
+    console.log(`  ${i + 1}) ${marker} ${item.name}`);
+  });
+  console.log();
+  console.log('  Enter numbers separated by commas (for example: 1,2,3)');
+  console.log('  Press Enter for detected agents, or "a" for all agents');
+
+  const answer = await prompt(rl, '\n  > ');
+
+  if (answer.toLowerCase() === 'a') {
+    return items.map((item) => item.id);
+  }
+  if (answer === '') {
+    return preselected.length > 0 ? preselected : items.map((item) => item.id);
+  }
+
+  const indices = answer
+    .split(',')
+    .map((s) => parseInt(s.trim(), 10) - 1)
+    .filter((i) => i >= 0 && i < items.length);
+
+  return indices.map((i) => items[i].id);
+}
+
+/**
+ * Resolve which agents to uninstall based on flags or interactive prompt.
+ */
+async function resolveSelectedAgents(opts, baseDir, skillNames, chalk) {
+  if (opts.isAll) {
+    return Object.keys(AGENTS);
+  }
+
+  if (opts.agentFlags.length > 0) {
+    const known = opts.agentFlags.filter((a) => AGENTS[a]);
+    const unknown = opts.agentFlags.filter((a) => !AGENTS[a]);
+    if (unknown.length > 0) {
+      console.log(chalk.yellow(`  Unknown agents: ${unknown.join(', ')}`));
+      console.log(chalk.gray(`  Available agents: ${Object.keys(AGENTS).join(', ')}\n`));
+    }
+    return known;
+  }
+
+  if (opts.isYes) {
+    // Non-interactive without --all: target exactly what's installed.
+    const detected = detectInstalledAgents(baseDir, skillNames);
+    return detected.length > 0 ? detected : Object.keys(AGENTS);
+  }
+
+  const detected = detectInstalledAgents(baseDir, skillNames);
+  console.log(chalk.cyan('  Select the agents to uninstall from:\n'));
+  const items = Object.entries(AGENTS).map(([id, agent]) => ({
+    id,
+    name: detected.includes(id) ? `${agent.name} ${chalk.green('(installed)')}` : agent.name,
+  }));
+
+  const rl = createReadline();
+  try {
+    return await selectMultiple(rl, items, detected);
+  } finally {
+    rl.close();
+  }
+}
+
+/**
+ * Remove a directory only if it exists and is empty. Best-effort; returns
+ * true if it was removed.
+ */
+function removeIfEmpty(dir) {
+  try {
+    if (!fs.existsSync(dir)) return false;
+    if (fs.readdirSync(dir).length > 0) return false;
+    fs.rmdirSync(dir);
+    return true;
+  } catch (_) {
+    return false;
+  }
+}
+
+/**
+ * Remove our managed skills for a single agent. Codex shares the universal
+ * dir, so it is handled by removeUniversalSkills instead and skipped here.
+ *
+ * @returns {{ action: string, dir?: string, count?: number }}
+ */
+function removeAgentSkills(baseDir, agentId, skillNames, dryRun, removeEmpty) {
+  const agent = AGENTS[agentId];
+  if (agent.dir === UNIVERSAL_DIR) {
+    return { action: 'universal' };
+  }
+
+  const dir = path.join(baseDir, agent.dir);
+  const st = fs.lstatSync(dir, { throwIfNoEntry: false });
+  if (!st) {
+    return { action: 'absent', dir: agent.dir };
+  }
+
+  if (st.isSymbolicLink()) {
+    if (!dryRun) fs.unlinkSync(dir);
+    if (removeEmpty && !dryRun) removeIfEmpty(path.dirname(dir));
+    return { action: 'unlinked', dir: agent.dir };
+  }
+
+  // Real directory (copy fallback or user-managed): remove only our subdirs.
+  let count = 0;
+  for (const name of skillNames) {
+    const sub = path.join(dir, name);
+    if (fs.existsSync(sub)) {
+      if (!dryRun) fs.rmSync(sub, { recursive: true, force: true });
+      count++;
+    }
+  }
+  if (removeEmpty && !dryRun) {
+    if (removeIfEmpty(dir)) removeIfEmpty(path.dirname(dir));
+  }
+  return { action: 'removed-copies', dir: agent.dir, count };
+}
+
+/**
+ * Remove our managed skills from the universal dir (~/.agents/skills) and
+ * tidy up the now-empty parent dirs. This is what actually deletes the
+ * skills for Codex and any agent symlinked to the universal copy.
+ *
+ * @returns {{ action: string, count?: number }}
+ */
+function removeUniversalSkills(baseDir, skillNames, dryRun, removeEmpty) {
+  const universal = path.join(baseDir, UNIVERSAL_DIR);
+  const st = fs.lstatSync(universal, { throwIfNoEntry: false });
+  if (!st) {
+    return { action: 'absent' };
+  }
+
+  if (st.isSymbolicLink()) {
+    if (!dryRun) fs.unlinkSync(universal);
+    return { action: 'unlinked' };
+  }
+
+  let count = 0;
+  for (const name of skillNames) {
+    const sub = path.join(universal, name);
+    if (fs.existsSync(sub)) {
+      if (!dryRun) fs.rmSync(sub, { recursive: true, force: true });
+      count++;
+    }
+  }
+
+  if (removeEmpty && !dryRun) {
+    // ~/.agents/skills → ~/.agents, removing each only while empty.
+    if (removeIfEmpty(universal)) {
+      removeIfEmpty(path.dirname(universal));
+    }
+  }
+  return { action: 'removed', count };
+}
+
+/**
+ * Decide whether the universal skills dir is safe to delete: only when
+ * every agent that consumes it (Codex, plus any agent symlinked to it) is
+ * part of this uninstall. Must be evaluated BEFORE any symlink is removed.
+ */
+function universalIsFullyReleased(baseDir, selectedAgents) {
+  const consumers = new Set(['codex']); // codex.dir === UNIVERSAL_DIR
+  for (const [id, agent] of Object.entries(AGENTS)) {
+    if (id === 'codex') continue;
+    const dir = path.join(baseDir, agent.dir);
+    if (isSymlinkToUniversal(dir, baseDir)) {
+      consumers.add(id);
+    }
+  }
+  return [...consumers].every((id) => selectedAgents.includes(id));
+}
+
+/**
+ * Remove the legacy ~/.bi-superpowers session dir left by the 5.0.3 auth
+ * feature. Nothing writes there anymore; this is defensive cleanup.
+ *
+ * @returns {{ existed: boolean, path: string }}
+ */
+function cleanLegacySessionDir(baseDir, dryRun) {
+  const dir = path.join(baseDir, LEGACY_SESSION_DIR);
+  const existed = fs.existsSync(dir);
+  if (existed && !dryRun) {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+  return { existed, path: dir };
+}
+
+/**
+ * Main handler for the `super uninstall` command.
+ * @param {string[]} args - CLI arguments
+ * @param {Object} config - Command config from the CLI (packageDir, version)
+ */
+async function uninstallCommand(args, config) {
+  const chalk = require('chalk');
+  const boxen = require('boxen');
+
+  const opts = parseArgs(args);
+  const baseDir = os.homedir();
+  const packageDir = config.packageDir || path.dirname(path.dirname(__dirname));
+  const skillNames = getManagedSkillNames(packageDir);
+
+  console.log(
+    boxen(
+      chalk.bold.cyan('BI Agent Superpowers') +
+        chalk.gray(` v${config.version}`) +
+        '\n' +
+        chalk.gray(opts.isDryRun ? 'Uninstaller (dry run)' : 'Uninstaller'),
+      { padding: 1, borderStyle: 'round', borderColor: 'cyan' }
+    )
+  );
+
+  const selectedAgents = await resolveSelectedAgents(opts, baseDir, skillNames, chalk);
+  if (selectedAgents.length === 0) {
+    console.log(chalk.yellow('\n  No agent selected. Nothing to uninstall.'));
+    return;
+  }
+
+  const doSkills = !opts.mcpOnly;
+  const doMcp = !opts.skillsOnly;
+  const doExtras = !opts.skillsOnly && !opts.mcpOnly; // legacy dir cleanup
+
+  // Plan the universal-skills decision up front (before removing symlinks).
+  const releaseUniversal = doSkills && universalIsFullyReleased(baseDir, selectedAgents);
+
+  // Confirmation gate for the destructive run.
+  if (!opts.isDryRun && !opts.isYes) {
+    const scope = [doSkills && 'skills', doMcp && 'MCP servers'].filter(Boolean).join(' + ');
+    console.log(
+      chalk.yellow(
+        `\n  This will remove bi-superpowers ${scope} from: ${selectedAgents.join(', ')}.`
+      )
+    );
+    const rl = createReadline();
+    let answer;
+    try {
+      answer = await prompt(rl, '  Continue? (y/N) ');
+    } finally {
+      rl.close();
+    }
+    if (!/^y(es)?$/i.test(answer)) {
+      console.log(chalk.gray('\n  Aborted. Nothing was removed.'));
+      return;
+    }
+  }
+
+  const dry = opts.isDryRun;
+  console.log(
+    chalk.cyan(
+      `\n  ${dry ? 'Would remove' : 'Removing'} from ${selectedAgents.length} agent(s)...\n`
+    )
+  );
+
+  // Phase 1: skills.
+  const skillResults = [];
+  if (doSkills) {
+    for (const agentId of selectedAgents) {
+      try {
+        const result = removeAgentSkills(baseDir, agentId, skillNames, dry, true);
+        skillResults.push({ agent: AGENTS[agentId].name, ...result });
+      } catch (err) {
+        skillResults.push({ agent: AGENTS[agentId].name, action: 'error', error: err.message });
+      }
+    }
+
+    if (releaseUniversal) {
+      try {
+        const uni = removeUniversalSkills(baseDir, skillNames, dry, true);
+        skillResults.push({ agent: `${UNIVERSAL_DIR}`, ...uni });
+      } catch (err) {
+        skillResults.push({ agent: UNIVERSAL_DIR, action: 'error', error: err.message });
+      }
+    }
+
+    for (const r of skillResults) {
+      if (r.action === 'unlinked') {
+        console.log(chalk.green(`  ${dry ? '·' : '✓'} ${r.dir}/ (symlink removed) — ${r.agent}`));
+      } else if (r.action === 'removed-copies') {
+        console.log(
+          chalk.green(`  ${dry ? '·' : '✓'} ${r.dir}/ (${r.count} skill dirs removed) — ${r.agent}`)
+        );
+      } else if (r.action === 'removed') {
+        console.log(chalk.green(`  ${dry ? '·' : '✓'} ${r.agent}/ (${r.count} skills removed)`));
+      } else if (r.action === 'absent') {
+        console.log(chalk.gray(`  – ${r.agent}: no managed skills found`));
+      } else if (r.action === 'error') {
+        console.log(chalk.red(`  ✗ ${r.agent}: ${r.error}`));
+      }
+    }
+    if (doSkills && !releaseUniversal) {
+      console.log(
+        chalk.gray(
+          `  – ${UNIVERSAL_DIR}/ kept (still used by an agent that isn't part of this uninstall)`
+        )
+      );
+    }
+  }
+
+  // Phase 2: MCP config.
+  const mcpResults = [];
+  if (doMcp) {
+    console.log(chalk.cyan(`\n  ${dry ? 'Would remove' : 'Removing'} MCP servers...\n`));
+    for (const agentId of selectedAgents) {
+      try {
+        // On a dry run, inspect without writing by reading the current state.
+        const res = dry ? previewMcpRemoval(baseDir, agentId) : removeMcpConfigForAgent(agentId);
+        if (res && res.removed && res.removed.length > 0) {
+          const rel = res.configPath.replace(baseDir, '~');
+          console.log(
+            chalk.green(
+              `  ${dry ? '·' : '✓'} ${rel} — ${AGENTS[agentId].name} (${res.removed.length} servers)`
+            )
+          );
+        } else {
+          console.log(chalk.gray(`  – ${AGENTS[agentId].name}: no managed MCP servers found`));
+        }
+        mcpResults.push({ agent: AGENTS[agentId].name, ...(res || { removed: [] }) });
+      } catch (err) {
+        console.log(chalk.red(`  ✗ ${AGENTS[agentId].name}: ${err.message}`));
+        mcpResults.push({ agent: AGENTS[agentId].name, error: err.message });
+      }
+    }
+  }
+
+  // Phase 3: legacy session dir.
+  let legacy = { existed: false };
+  if (doExtras) {
+    legacy = cleanLegacySessionDir(baseDir, dry);
+    if (legacy.existed) {
+      console.log(
+        chalk.green(
+          `\n  ${dry ? '·' : '✓'} ${legacy.path.replace(baseDir, '~')} (legacy session removed)`
+        )
+      );
+    }
+  }
+
+  // Summary.
+  const mcpErrors = mcpResults.filter((r) => r.error);
+  const skillErrors = skillResults.filter((r) => r.action === 'error');
+  const hasErrors = mcpErrors.length > 0 || skillErrors.length > 0;
+
+  const headline = dry
+    ? chalk.cyan.bold('Dry run complete — no changes were made.')
+    : hasErrors
+      ? chalk.yellow.bold('Uninstall finished with some errors.')
+      : chalk.green.bold('Uninstall complete.');
+
+  console.log(
+    boxen(
+      headline +
+        '\n\n' +
+        chalk.gray(`Agents: ${selectedAgents.join(', ')}`) +
+        '\n' +
+        chalk.gray(
+          dry
+            ? 'Re-run without --dry-run to apply.'
+            : 'Restart your AI agent so it drops the removed MCP servers.'
+        ),
+      {
+        padding: 1,
+        margin: { top: 1 },
+        borderStyle: 'round',
+        borderColor: dry ? 'cyan' : hasErrors ? 'yellow' : 'green',
+      }
+    )
+  );
+
+  if (hasErrors && !dry) {
+    process.exitCode = 2;
+  }
+}
+
+/**
+ * Read-only MCP removal preview for dry runs: reports which of our servers
+ * are present without touching the file. Mirrors removeMcpConfigForAgent's
+ * return shape.
+ */
+function previewMcpRemoval(baseDir, agentId) {
+  const configPaths = {
+    'claude-code': path.join(baseDir, '.claude.json'),
+    'github-copilot': path.join(baseDir, '.copilot', 'mcp-config.json'),
+    codex: path.join(baseDir, '.codex', 'config.toml'),
+    'gemini-cli': path.join(baseDir, '.gemini', 'settings.json'),
+    kilo: path.join(baseDir, '.config', 'kilo', 'kilo.jsonc'),
+  };
+  const configPath = configPaths[agentId];
+  if (!configPath || !fs.existsSync(configPath)) {
+    return { configPath: configPath || '', existed: false, removed: [] };
+  }
+  let raw = '';
+  try {
+    raw = fs.readFileSync(configPath, 'utf8');
+  } catch (_) {
+    return { configPath, existed: true, removed: [] };
+  }
+  const removed = [];
+  if (raw.includes('powerbi-modeling-mcp')) removed.push('powerbi-modeling-mcp');
+  if (raw.includes('microsoft-learn')) removed.push('microsoft-learn');
+  return { configPath, existed: true, removed };
+}
+
+// Internal exports for testing.
+module.exports = uninstallCommand;
+module.exports.parseArgs = parseArgs;
+module.exports.getManagedSkillNames = getManagedSkillNames;
+module.exports.detectInstalledAgents = detectInstalledAgents;
+module.exports.removeAgentSkills = removeAgentSkills;
+module.exports.removeUniversalSkills = removeUniversalSkills;
+module.exports.universalIsFullyReleased = universalIsFullyReleased;
+module.exports.cleanLegacySessionDir = cleanLegacySessionDir;
+module.exports.removeIfEmpty = removeIfEmpty;
+module.exports.AGENTS = AGENTS;
+module.exports.UNIVERSAL_DIR = UNIVERSAL_DIR;