argsbarg 1.4.2 → 1.5.0

package/src/install/install.test.ts

@@ -0,0 +1,124 @@
+import { describe, expect, test, beforeEach, afterEach } from "bun:test";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { CliCommand } from "../types.ts";
+import { detectInstalledArtifacts } from "./detect-installed.ts";
+import { resolveInstallPaths } from "./paths.ts";
+import { buildInstallPlan } from "./plan.ts";
+import { printInstallStatus } from "./status.ts";
+import { parseInstallOpts } from "./index.ts";
+
+const fixture: CliCommand = {
+  key: "testapp",
+  description: "Test",
+  mcpServer: { name: "testapp" },
+  handler: () => {},
+};
+
+let home: string;
+let prevHome: string | undefined;
+
+beforeEach(() => {
+  home = mkdtempSync(join(tmpdir(), "argsbarg-install-"));
+  prevHome = process.env.HOME;
+  process.env.HOME = home;
+});
+
+afterEach(() => {
+  if (prevHome === undefined) delete process.env.HOME;
+  else process.env.HOME = prevHome;
+  rmSync(home, { recursive: true, force: true });
+});
+
+describe("install paths", () => {
+  test("resolveInstallPaths honors prefix", () => {
+    const paths = resolveInstallPaths(fixture, { prefix: join(home, "custom", "bin") });
+    expect(paths.binaryPath).toBe(join(home, "custom", "bin", "testapp"));
+  });
+
+  test("fish completion uses XDG_CONFIG_HOME", () => {
+    const xdg = join(home, "xdg");
+    process.env.XDG_CONFIG_HOME = xdg;
+    const paths = resolveInstallPaths(fixture, {});
+    expect(paths.fishCompletion).toBe(join(xdg, "fish", "completions", "testapp.fish"));
+  });
+});
+
+describe("detect installed", () => {
+  test("detects binary and completions", () => {
+    const paths = resolveInstallPaths(fixture, {});
+    mkdirSync(paths.bindir, { recursive: true });
+    writeFileSync(paths.binaryPath, "fake", "utf8");
+    mkdirSync(join(home, ".bash_completion.d"), { recursive: true });
+    writeFileSync(paths.bashCompletion, "# bash", "utf8");
+
+    const detected = detectInstalledArtifacts(paths);
+    expect(detected.binary).toBe(true);
+    expect(detected.bashCompletion).toBe(true);
+    expect(detected.zshCompletion).toBe(false);
+  });
+});
+
+describe("install plan", () => {
+  test("buildInstallPlan --all includes binary", () => {
+    const paths = resolveInstallPaths(fixture, {});
+    const plan = buildInstallPlan(fixture, paths, parseInstallOpts({ all: "1" }));
+    expect(plan.some((a) => a.kind === "binary")).toBe(true);
+  });
+});
+
+describe("install status", () => {
+  test("printInstallStatus human output", () => {
+    const paths = resolveInstallPaths(fixture, {});
+    mkdirSync(paths.bindir, { recursive: true });
+    writeFileSync(paths.binaryPath, "fake", "utf8");
+
+    const chunks: string[] = [];
+    const orig = process.stdout.write;
+    process.stdout.write = ((s: string) => {
+      chunks.push(s);
+      return true;
+    }) as typeof process.stdout.write;
+    try {
+      printInstallStatus(fixture, {});
+      const out = chunks.join("");
+      expect(out).toContain("Installed artifacts for testapp");
+      expect(out).toContain(paths.binaryPath);
+    } finally {
+      process.stdout.write = orig;
+    }
+  });
+
+  test("printInstallStatus json output", () => {
+    const paths = resolveInstallPaths(fixture, {});
+    mkdirSync(join(home, ".cursor"), { recursive: true });
+    writeFileSync(
+      paths.cursorMcpPath,
+      JSON.stringify({ mcpServers: { testapp: { command: "testapp", args: ["mcp"] } } }),
+      "utf8",
+    );
+
+    const chunks: string[] = [];
+    const orig = process.stdout.write;
+    process.stdout.write = ((s: string) => {
+      chunks.push(s);
+      return true;
+    }) as typeof process.stdout.write;
+    try {
+      printInstallStatus(fixture, { json: true });
+      const data = JSON.parse(chunks.join(""));
+      expect(data.cursorMcp).toContain("mcp.json");
+    } finally {
+      process.stdout.write = orig;
+    }
+  });
+});
+
+describe("parseInstallOpts", () => {
+  test("json implies yes in validate path via cliInstall", () => {
+    const opts = parseInstallOpts({ json: "1", all: "1" });
+    expect(opts.json).toBe(true);
+    expect(opts.all).toBe(true);
+  });
+});

package/src/install/mcp-config.ts

@@ -0,0 +1,70 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { CliCommand } from "../types.ts";
+import { InstallPaths } from "./paths.ts";
+
+export interface McpServerEntry {
+  command: string;
+  args: string[];
+}
+
+export function expectedMcpEntry(root: CliCommand): McpServerEntry {
+  return { command: root.key, args: ["mcp"] };
+}
+
+function entriesEqual(a: McpServerEntry, b: McpServerEntry): boolean {
+  return a.command === b.command && JSON.stringify(a.args) === JSON.stringify(b.args);
+}
+
+/** Reads mcpServers[name] from a JSON config file, or undefined. */
+export function readMcpServerEntry(path: string, name: string): McpServerEntry | undefined {
+  if (!existsSync(path)) return undefined;
+  try {
+    const data = JSON.parse(readFileSync(path, "utf8")) as { mcpServers?: Record<string, McpServerEntry> };
+    return data.mcpServers?.[name];
+  } catch {
+    return undefined;
+  }
+}
+
+/** Returns an error message when existing entry conflicts, or null if safe to merge. */
+export function checkMcpConflict(
+  path: string,
+  name: string,
+  expected: McpServerEntry,
+  yes: boolean,
+): string | null {
+  const existing = readMcpServerEntry(path, name);
+  if (existing && !entriesEqual(existing, expected) && !yes) {
+    return (
+      `MCP server "${name}" in ${path} differs from expected entry.\n` +
+      `  existing: ${JSON.stringify(existing)}\n` +
+      `  expected: ${JSON.stringify(expected)}\n` +
+      `Use --yes to overwrite.`
+    );
+  }
+  return null;
+}
+
+/** Merges MCP server entry into config file. */
+export function mergeMcpConfig(path: string, name: string, entry: McpServerEntry, dry: boolean): void {
+  if (dry) return;
+  let data: Record<string, unknown> = {};
+  if (existsSync(path)) {
+    data = JSON.parse(readFileSync(path, "utf8")) as Record<string, unknown>;
+  }
+  const servers = (data.mcpServers as Record<string, McpServerEntry> | undefined) ?? {};
+  servers[name] = entry;
+  data.mcpServers = servers;
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, JSON.stringify(data, null, 2) + "\n", "utf8");
+}
+
+/** Removes MCP server entry from config file (keeps file if other keys remain). */
+export function removeMcpConfig(path: string, name: string, dry: boolean): void {
+  if (dry || !existsSync(path)) return;
+  const data = JSON.parse(readFileSync(path, "utf8")) as { mcpServers?: Record<string, unknown> };
+  if (!data.mcpServers?.[name]) return;
+  delete data.mcpServers[name];
+  writeFileSync(path, JSON.stringify(data, null, 2) + "\n", "utf8");
+}

package/src/install/paths.ts

@@ -0,0 +1,69 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { CliCommand } from "../types.ts";
+import { sanitizeToolSegment } from "../mcp/tools.ts";
+
+export interface InstallPaths {
+  bindir: string;
+  binaryPath: string;
+  bashCompletion: string;
+  zshCompletion: string;
+  fishCompletion: string;
+  cursorSkillDir: string;
+  claudeSkillDir: string;
+  cursorMcpPath: string;
+  claudeMcpPath: string;
+  bashRc: string;
+  zshRc: string;
+  mcpName: string;
+  skillDirName: string;
+}
+
+/** Resolves the user home directory (`$HOME` when set). */
+export function userHome(): string {
+  return process.env.HOME ?? homedir();
+}
+
+function expandTilde(path: string): string {
+  if (path.startsWith("~/")) {
+    return join(userHome(), path.slice(2));
+  }
+  if (path === "~") {
+    return userHome();
+  }
+  return path;
+}
+
+/** Resolves the binary install directory from CLI flag, env, or config. */
+export function resolveBindir(root: CliCommand, prefix?: string): string {
+  const raw = prefix ?? process.env.INSTALL_PREFIX ?? root.install?.prefix;
+  if (raw) {
+    return expandTilde(raw);
+  }
+  return join(userHome(), ".local", "bin");
+}
+
+/** Resolves all install artifact paths for a program root. */
+export function resolveInstallPaths(root: CliCommand, opts: { prefix?: string }): InstallPaths {
+  const home = userHome();
+  const bindir = resolveBindir(root, opts.prefix);
+  const key = root.key;
+  const skillDirName = sanitizeToolSegment(root.key);
+  const xdgConfig = process.env.XDG_CONFIG_HOME ?? join(home, ".config");
+
+  return {
+    bindir,
+    binaryPath: join(bindir, key),
+    bashCompletion: join(home, ".bash_completion.d", key),
+    zshCompletion: join(home, ".zsh", "completions", `_${key}`),
+    fishCompletion: join(xdgConfig, "fish", "completions", `${key}.fish`),
+    cursorSkillDir: join(home, ".cursor", "skills", skillDirName),
+    claudeSkillDir: join(home, ".claude", "skills", skillDirName),
+    cursorMcpPath: join(home, ".cursor", "mcp.json"),
+    claudeMcpPath: join(home, ".claude.json"),
+    bashRc: join(home, ".bashrc"),
+    zshRc: join(home, ".zshrc"),
+    mcpName: root.mcpServer?.name ?? root.key,
+    skillDirName,
+  };
+}

package/src/install/plan.ts

@@ -0,0 +1,183 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { CliCommand } from "../types.ts";
+import { installBinary } from "./binary.ts";
+import { installCompletions } from "./completions.ts";
+import { detectInstalledArtifacts } from "./detect-installed.ts";
+import { expectedMcpEntry, mergeMcpConfig } from "./mcp-config.ts";
+import { InstallPaths, userHome } from "./paths.ts";
+import { detectShells } from "./shell.ts";
+
+export interface InstallOpts {
+  all?: boolean;
+  bin?: boolean;
+  completions?: boolean;
+  skill?: boolean;
+  mcp?: boolean;
+  update?: boolean;
+  status?: boolean;
+  uninstall?: boolean;
+  yes?: boolean;
+  dry?: boolean;
+  json?: boolean;
+  quiet?: boolean;
+  prefix?: string;
+}
+
+export type InstallActionKind = "binary" | "completions" | "cursor-skill" | "claude-skill" | "cursor-mcp" | "claude-mcp";
+
+export interface InstallAction {
+  kind: InstallActionKind;
+  summary: string;
+  message: string;
+  run: () => string[];
+}
+
+function wantsBin(opts: InstallOpts): boolean {
+  return !!(opts.all || opts.bin || opts.update);
+}
+
+function wantsCompletions(opts: InstallOpts): boolean {
+  return !!(opts.all || opts.completions);
+}
+
+function wantsSkill(opts: InstallOpts): boolean {
+  return !!(opts.all || opts.skill);
+}
+
+function wantsMcp(opts: InstallOpts, root: CliCommand): boolean {
+  return !!(opts.all || opts.mcp) && root.mcpServer !== undefined;
+}
+
+/** Builds install actions for normal mode (--all / scoped targets). */
+export function buildInstallPlan(root: CliCommand, paths: InstallPaths, opts: InstallOpts): InstallAction[] {
+  const actions: InstallAction[] = [];
+  const dry = !!opts.dry;
+
+  if (wantsBin(opts)) {
+    actions.push({
+      kind: "binary",
+      summary: `binary: ${paths.binaryPath}`,
+      message: `Installing binary to ${paths.binaryPath}`,
+      run: () => installBinary(root, paths, dry).changedFiles,
+    });
+  }
+
+  if (wantsCompletions(opts)) {
+    const shells = detectShells();
+    if (shells.bash) {
+      actions.push({
+        kind: "completions",
+        summary: `bash completion: ${paths.bashCompletion}`,
+        message: `Writing bash completion to ${paths.bashCompletion}`,
+        run: () => {
+          const all = installCompletions(root, paths, dry);
+          return all.filter((p) => p === paths.bashCompletion);
+        },
+      });
+    }
+    if (shells.zsh) {
+      actions.push({
+        kind: "completions",
+        summary: `zsh completion: ${paths.zshCompletion}`,
+        message: `Writing zsh completion to ${paths.zshCompletion}`,
+        run: () => {
+          const all = installCompletions(root, paths, dry);
+          return all.filter((p) => p === paths.zshCompletion);
+        },
+      });
+    }
+    if (shells.fish) {
+      actions.push({
+        kind: "completions",
+        summary: `fish completion: ${paths.fishCompletion}`,
+        message: `Writing fish completion to ${paths.fishCompletion}`,
+        run: () => {
+          const all = installCompletions(root, paths, dry);
+          return all.filter((p) => p === paths.fishCompletion);
+        },
+      });
+    }
+  }
+
+  if (wantsSkill(opts)) {
+    const home = userHome();
+    if (existsSync(join(home, ".cursor"))) {
+      actions.push({
+        kind: "cursor-skill",
+        summary: `cursor skill: ${paths.cursorSkillDir}/`,
+        message: `Installing Cursor skill to ${paths.cursorSkillDir}/`,
+        run: () => [],
+      });
+    }
+    if (existsSync(join(home, ".claude"))) {
+      actions.push({
+        kind: "claude-skill",
+        summary: `claude skill: ${paths.claudeSkillDir}/`,
+        message: `Installing Claude Code skill to ${paths.claudeSkillDir}/`,
+        run: () => [],
+      });
+    }
+  }
+
+  if (wantsMcp(opts, root)) {
+    const entry = expectedMcpEntry(root);
+    if (existsSync(join(userHome(), ".cursor"))) {
+      actions.push({
+        kind: "cursor-mcp",
+        summary: `cursor mcp: ${paths.cursorMcpPath} (server "${paths.mcpName}")`,
+        message: `Merging MCP server "${paths.mcpName}" into ${paths.cursorMcpPath}`,
+        run: () => {
+          mergeMcpConfig(paths.cursorMcpPath, paths.mcpName, entry, dry);
+          return [paths.cursorMcpPath];
+        },
+      });
+    }
+    actions.push({
+      kind: "claude-mcp",
+      summary: `claude mcp: ${paths.claudeMcpPath} (server "${paths.mcpName}")`,
+      message: `Merging MCP server "${paths.mcpName}" into ${paths.claudeMcpPath}`,
+      run: () => {
+        mergeMcpConfig(paths.claudeMcpPath, paths.mcpName, entry, dry);
+        return [paths.claudeMcpPath];
+      },
+    });
+  }
+
+  return actions;
+}
+
+/** Builds update actions for artifacts already installed. */
+export function buildUpdatePlan(root: CliCommand, paths: InstallPaths, opts: InstallOpts): InstallAction[] {
+  const detected = detectInstalledArtifacts(paths);
+  const scoped: InstallOpts = {
+    bin: true,
+    completions: detected.bashCompletion || detected.zshCompletion || detected.fishCompletion,
+    skill: detected.cursorSkill || detected.claudeSkill,
+    mcp: (detected.cursorMcp || detected.claudeMcp) && root.mcpServer !== undefined,
+    dry: opts.dry,
+  };
+  const plan = buildInstallPlan(root, paths, scoped);
+
+  return plan.filter((action) => {
+    switch (action.kind) {
+      case "binary":
+        return true;
+      case "completions":
+        if (action.summary.startsWith("bash")) return detected.bashCompletion;
+        if (action.summary.startsWith("zsh")) return detected.zshCompletion;
+        if (action.summary.startsWith("fish")) return detected.fishCompletion;
+        return false;
+      case "cursor-skill":
+        return detected.cursorSkill;
+      case "claude-skill":
+        return detected.claudeSkill;
+      case "cursor-mcp":
+        return detected.cursorMcp;
+      case "claude-mcp":
+        return detected.claudeMcp;
+      default:
+        return false;
+    }
+  });
+}

package/src/install/shell.ts

@@ -0,0 +1,56 @@
+export interface ShellDetection {
+  bash: boolean;
+  zsh: boolean;
+  fish: boolean;
+}
+
+/** Detects which shells are available on PATH. */
+export function detectShells(): ShellDetection {
+  return {
+    bash: Bun.which("bash") !== null,
+    zsh: Bun.which("zsh") !== null,
+    fish: Bun.which("fish") !== null,
+  };
+}
+
+export function rcMarkerStart(appKey: string, tag: string): string {
+  return `# ${appKey}:${tag}`;
+}
+
+export function rcMarkerEnd(appKey: string, tag: string): string {
+  return `# end ${appKey}:${tag}`;
+}
+
+/** Returns rc snippet block for PATH, or null if already present. */
+export function buildPathRcBlock(appKey: string, bindir: string): string {
+  const start = rcMarkerStart(appKey, "path");
+  const end = rcMarkerEnd(appKey, "path");
+  return [start, `export PATH="${bindir}:$PATH"`, end].join("\n");
+}
+
+/** Returns rc snippet block for zsh fpath, or null if already present. */
+export function buildZshFpathRcBlock(appKey: string, completionsDir: string): string {
+  const start = rcMarkerStart(appKey, "fpath");
+  const end = rcMarkerEnd(appKey, "fpath");
+  return [start, `fpath=(${completionsDir} $fpath)`, end].join("\n");
+}
+
+/** Removes a marker-delimited block from rc file content. */
+export function removeRcBlock(content: string, appKey: string, tag: string): string {
+  const start = rcMarkerStart(appKey, tag);
+  const end = rcMarkerEnd(appKey, tag);
+  const re = new RegExp(
+    `${escapeRegExp(start)}[\\s\\S]*?${escapeRegExp(end)}\\n?`,
+    "g",
+  );
+  return content.replace(re, "");
+}
+
+/** Returns true when the marker block already exists in content. */
+export function hasRcBlock(content: string, appKey: string, tag: string): boolean {
+  return content.includes(rcMarkerStart(appKey, tag));
+}
+
+function escapeRegExp(s: string): string {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/src/install/status.ts

@@ -0,0 +1,63 @@
+import { CliCommand } from "../types.ts";
+import { buildInstallStatus, detectInstalledArtifacts } from "./detect-installed.ts";
+import type { InstallOpts } from "./plan.ts";
+import { resolveInstallPaths } from "./paths.ts";
+
+export function installOut(msg: string, opts: InstallOpts): void {
+  if (opts.quiet || opts.json) return;
+  process.stdout.write(msg + "\n");
+}
+
+export function installInfo(msg: string, opts: InstallOpts): void {
+  if (opts.quiet) return;
+  if (opts.json && !opts.dry) return;
+  const prefix = opts.dry ? "[dry run] " : "";
+  process.stderr.write(prefix + msg + "\n");
+}
+
+export function installErr(msg: string): void {
+  process.stderr.write(msg + "\n");
+}
+
+/** Prints install status to stdout (human or JSON). */
+export function printInstallStatus(root: CliCommand, opts: InstallOpts): void {
+  const paths = resolveInstallPaths(root, opts);
+  const detected = detectInstalledArtifacts(paths);
+  const status = buildInstallStatus(paths, detected);
+
+  if (opts.json) {
+    const json: Record<string, string> = {};
+    if (status.binary) json.binary = status.binary;
+    if (status.bashCompletion) json.bashCompletion = status.bashCompletion;
+    if (status.zshCompletion) json.zshCompletion = status.zshCompletion;
+    if (status.fishCompletion) json.fishCompletion = status.fishCompletion;
+    if (status.cursorSkill) json.cursorSkill = status.cursorSkill;
+    if (status.claudeSkill) json.claudeSkill = status.claudeSkill;
+    if (status.cursorMcp) json.cursorMcp = status.cursorMcp;
+    if (status.claudeMcp) json.claudeMcp = status.claudeMcp;
+    process.stdout.write(JSON.stringify(json, null, 2) + "\n");
+    return;
+  }
+
+  installOut(`Installed artifacts for ${root.key}:`, opts);
+  const lines: [string, string | undefined][] = [
+    ["binary", status.binary],
+    ["bash completion", status.bashCompletion],
+    ["zsh completion", status.zshCompletion],
+    ["fish completion", status.fishCompletion],
+    ["cursor skill", status.cursorSkill],
+    ["claude skill", status.claudeSkill],
+    ["cursor mcp", status.cursorMcp],
+    ["claude mcp", status.claudeMcp],
+  ];
+  let any = false;
+  for (const [label, value] of lines) {
+    if (value) {
+      installOut(`  ${label}: ${value}`, opts);
+      any = true;
+    }
+  }
+  if (!any) {
+    installOut("  (none detected)", opts);
+  }
+}

package/src/install/uninstall.ts

@@ -0,0 +1,111 @@
+import { existsSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { CliCommand } from "../types.ts";
+import { uninstallBinary } from "./binary.ts";
+import { uninstallCompletions } from "./completions.ts";
+import { detectInstalledArtifacts } from "./detect-installed.ts";
+import { removeMcpConfig } from "./mcp-config.ts";
+import { InstallPaths, userHome } from "./paths.ts";
+import type { InstallOpts } from "./plan.ts";
+
+export interface UninstallAction {
+  summary: string;
+  message: string;
+  run: () => string[];
+}
+
+function scopeAll(opts: InstallOpts): boolean {
+  return !opts.bin && !opts.completions && !opts.skill && !opts.mcp;
+}
+
+/** Builds uninstall actions from detected artifacts. */
+export function buildUninstallPlan(
+  root: CliCommand,
+  paths: InstallPaths,
+  opts: InstallOpts,
+): UninstallAction[] {
+  const detected = detectInstalledArtifacts(paths);
+  const all = scopeAll(opts);
+  const dry = !!opts.dry;
+  const actions: UninstallAction[] = [];
+
+  if ((all || opts.bin) && detected.binary) {
+    actions.push({
+      summary: `binary: ${paths.binaryPath}`,
+      message: `Removing binary ${paths.binaryPath}`,
+      run: () => uninstallBinary(root, paths, dry),
+    });
+  }
+
+  if ((all || opts.completions) && (detected.bashCompletion || detected.zshCompletion || detected.fishCompletion)) {
+    if (detected.bashCompletion) {
+      actions.push({
+        summary: `bash completion: ${paths.bashCompletion}`,
+        message: `Removing bash completion ${paths.bashCompletion}`,
+        run: () => uninstallCompletions(paths, dry).filter((p) => p === paths.bashCompletion),
+      });
+    }
+    if (detected.zshCompletion) {
+      actions.push({
+        summary: `zsh completion: ${paths.zshCompletion}`,
+        message: `Removing zsh completion ${paths.zshCompletion}`,
+        run: () => uninstallCompletions(paths, dry).filter((p) => p === paths.zshCompletion),
+      });
+    }
+    if (detected.fishCompletion) {
+      actions.push({
+        summary: `fish completion: ${paths.fishCompletion}`,
+        message: `Removing fish completion ${paths.fishCompletion}`,
+        run: () => uninstallCompletions(paths, dry).filter((p) => p === paths.fishCompletion),
+      });
+    }
+  }
+
+  if ((all || opts.skill) && detected.cursorSkill) {
+    actions.push({
+      summary: `cursor skill: ${paths.cursorSkillDir}/`,
+      message: `Removing Cursor skill ${paths.cursorSkillDir}/`,
+      run: () => [],
+    });
+  }
+
+  if ((all || opts.skill) && detected.claudeSkill) {
+    actions.push({
+      summary: `claude skill: ${paths.claudeSkillDir}/`,
+      message: `Removing Claude Code skill ${paths.claudeSkillDir}/`,
+      run: () => [],
+    });
+  }
+
+  if ((all || opts.mcp) && root.mcpServer !== undefined) {
+    if (detected.cursorMcp) {
+      actions.push({
+        summary: `cursor mcp: ${paths.cursorMcpPath}`,
+        message: `Removing MCP server "${paths.mcpName}" from ${paths.cursorMcpPath}`,
+        run: () => {
+          removeMcpConfig(paths.cursorMcpPath, paths.mcpName, dry);
+          return [paths.cursorMcpPath];
+        },
+      });
+    }
+    if (detected.claudeMcp) {
+      actions.push({
+        summary: `claude mcp: ${paths.claudeMcpPath}`,
+        message: `Removing MCP server "${paths.mcpName}" from ${paths.claudeMcpPath}`,
+        run: () => {
+          removeMcpConfig(paths.claudeMcpPath, paths.mcpName, dry);
+          return [paths.claudeMcpPath];
+        },
+      });
+    }
+  }
+
+  return actions;
+}
+
+/** Rimraf skill directories during uninstall. */
+export function uninstallSkillDir(dir: string, dry: boolean): string[] {
+  if (!existsSync(dir)) return [];
+  if (!dry) rmSync(dir, { recursive: true, force: true });
+  return [dir + "/"];
+}

package/src/mcp/tools.ts

@@ -150,7 +150,7 @@ export function collectMcpTools(root: CliCommand): McpToolDef[] {
   /** Walks the command tree and appends leaf tools. */
   function walk(cmd: CliCommand, path: string[]): void {
     if ("handler" in cmd && cmd.handler) {
-      if (cmd.key === "completion" || cmd.key === "mcp") {
+      if (cmd.key === "completion" || cmd.key === "install" || cmd.key === "mcp") {
         return;
       }
       if (cmd.mcpTool?.enabled === false) {