@fenglimg/fabric-cli 2.0.0 → 2.1.0-rc.2

package/dist/uninstall-TAXSUSKH.js

@@ -0,0 +1,1073 @@
+#!/usr/bin/env node
+import {
+  FABRIC_HOOK_COMMAND_PATHS,
+  HOOK_CONFIG_ARRAY_PATHS,
+  HOOK_CONFIG_TARGETS,
+  HOOK_LIB_DESTINATIONS,
+  HOOK_SCRIPT_DESTINATIONS,
+  SKILL_DESTINATIONS,
+  fabricAgentsSnapshotPath
+} from "./chunk-F46ORPOA.js";
+import {
+  paint
+} from "./chunk-WWNXR34K.js";
+import {
+  createDebugLogger,
+  resolveDevMode
+} from "./chunk-COI5VDFU.js";
+import {
+  detectClientSupports,
+  resolveClients
+} from "./chunk-MF3OTILQ.js";
+import {
+  t
+} from "./chunk-PWLW3B57.js";
+
+// src/commands/uninstall.ts
+import { existsSync as existsSync2, statSync } from "fs";
+import { rm as rm2 } from "fs/promises";
+import { homedir } from "os";
+import { isAbsolute, join as join2, relative, resolve, sep } from "path";
+import { cancel, confirm, group, intro, isCancel, log, note, outro } from "@clack/prompts";
+import { defineCommand } from "citty";
+
+// src/install/uninstall-skills-and-hooks.ts
+import { existsSync } from "fs";
+import { readdir, readFile, rm, rmdir } from "fs/promises";
+import { dirname, join } from "path";
+import { atomicWriteJson, atomicWriteText } from "@fenglimg/fabric-shared/node/atomic-write";
+import { BOOTSTRAP_REGEX } from "@fenglimg/fabric-shared/templates/bootstrap-canonical";
+async function uninstallFabricArchiveSkill(projectRoot) {
+  return removeSkill("skill", SKILL_DESTINATIONS.fabricArchive, projectRoot);
+}
+async function uninstallFabricReviewSkill(projectRoot) {
+  return removeSkill("skill-review", SKILL_DESTINATIONS.fabricReview, projectRoot);
+}
+async function uninstallFabricImportSkill(projectRoot) {
+  return removeSkill("skill-import", SKILL_DESTINATIONS.fabricImport, projectRoot);
+}
+async function uninstallFabricSyncSkill(projectRoot) {
+  return removeSkill("skill-sync", SKILL_DESTINATIONS.fabricSync, projectRoot);
+}
+async function removeSkill(step, rels, projectRoot) {
+  const results = [];
+  for (const rel of rels) {
+    const target = join(projectRoot, rel);
+    results.push(await rmIfExists(step, target));
+    results.push(await rmDirIfEmpty(`${step}-dir`, dirname(target)));
+  }
+  return results;
+}
+async function removeArchiveHintHook(projectRoot) {
+  return removeHookScripts("hook-script", HOOK_SCRIPT_DESTINATIONS.fabricHint, projectRoot);
+}
+async function removeKnowledgeHintBroadHook(projectRoot) {
+  return removeHookScripts(
+    "hook-broad-script",
+    HOOK_SCRIPT_DESTINATIONS.knowledgeHintBroad,
+    projectRoot
+  );
+}
+async function removeKnowledgeHintNarrowHook(projectRoot) {
+  return removeHookScripts(
+    "hook-narrow-script",
+    HOOK_SCRIPT_DESTINATIONS.knowledgeHintNarrow,
+    projectRoot
+  );
+}
+async function removeHookScripts(step, rels, projectRoot) {
+  const results = [];
+  for (const rel of rels) {
+    const target = join(projectRoot, rel);
+    results.push(await rmIfExists(step, target));
+  }
+  return results;
+}
+async function removeHookLibs(projectRoot) {
+  const results = [];
+  for (const dirRel of HOOK_LIB_DESTINATIONS) {
+    const dirAbs = join(projectRoot, dirRel);
+    if (!existsSync(dirAbs)) {
+      results.push({ step: "hook-lib", path: dirAbs, status: "skipped", message: "absent" });
+      continue;
+    }
+    let entries;
+    try {
+      entries = await readdir(dirAbs);
+    } catch (error) {
+      results.push({
+        step: "hook-lib",
+        path: dirAbs,
+        status: "error",
+        message: error instanceof Error ? error.message : String(error)
+      });
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.endsWith(".cjs")) continue;
+      results.push(await rmIfExists("hook-lib", join(dirAbs, entry)));
+    }
+    results.push(await rmDirIfEmpty("hook-lib-dir", dirAbs));
+  }
+  return results;
+}
+async function unmergeClaudeCodeHookConfig(projectRoot) {
+  return unmergeHookConfig({
+    step: "claude-hook-config",
+    projectRoot,
+    configRel: HOOK_CONFIG_TARGETS.claudeCode,
+    arrayPaths: [...HOOK_CONFIG_ARRAY_PATHS.claudeCode],
+    fabricCommands: Object.values(FABRIC_HOOK_COMMAND_PATHS.claudeCode),
+    extractCommands: extractClaudeCommands
+  });
+}
+async function unmergeCodexHookConfig(projectRoot) {
+  return unmergeHookConfig({
+    step: "codex-hook-config",
+    projectRoot,
+    configRel: HOOK_CONFIG_TARGETS.codex,
+    arrayPaths: [...HOOK_CONFIG_ARRAY_PATHS.codex],
+    fabricCommands: Object.values(FABRIC_HOOK_COMMAND_PATHS.codex),
+    extractCommands: extractFlatCommands
+  });
+}
+async function unmergeCursorHookConfig(projectRoot) {
+  return unmergeHookConfig({
+    step: "cursor-hook-config",
+    projectRoot,
+    configRel: HOOK_CONFIG_TARGETS.cursor,
+    arrayPaths: [...HOOK_CONFIG_ARRAY_PATHS.cursor],
+    fabricCommands: Object.values(FABRIC_HOOK_COMMAND_PATHS.cursor),
+    extractCommands: extractFlatCommands
+  });
+}
+async function stripFabricBootstrapBlocks(projectRoot) {
+  const results = [];
+  results.push(await stripClaudeBootstrapImports(projectRoot));
+  results.push(await stripManagedBlock(projectRoot, "AGENTS.md", { deleteWhenEmpty: false }));
+  results.push(
+    await stripManagedBlock(projectRoot, join(".cursor", "rules", "fabric-bootstrap.mdc"), {
+      deleteWhenEmpty: true
+    })
+  );
+  return results;
+}
+async function stripClaudeBootstrapImports(projectRoot) {
+  const step = "bootstrap-claude";
+  const target = join(projectRoot, "CLAUDE.md");
+  if (!existsSync(target)) {
+    return { step, path: target, status: "skipped", message: "absent" };
+  }
+  let existing;
+  try {
+    existing = await readFile(target, "utf8");
+  } catch (error) {
+    return {
+      step,
+      path: target,
+      status: "error",
+      message: error instanceof Error ? error.message : String(error)
+    };
+  }
+  const managedLines = /* @__PURE__ */ new Set(["@.fabric/AGENTS.md", "@.fabric/project-rules.md"]);
+  const lines = existing.split(/\r?\n/);
+  const filtered = lines.filter((l) => !managedLines.has(l.replace(/\s+$/, "")));
+  if (filtered.length === lines.length) {
+    return { step, path: target, status: "skipped", message: "no-fabric-section" };
+  }
+  while (filtered.length > 1 && filtered[filtered.length - 1] === "" && filtered[filtered.length - 2] === "") {
+    filtered.pop();
+  }
+  const next = filtered.join("\n");
+  if (next === existing) {
+    return { step, path: target, status: "skipped", message: "no-fabric-section" };
+  }
+  try {
+    await atomicWriteText(target, next);
+    return { step, path: target, status: "removed" };
+  } catch (error) {
+    return {
+      step,
+      path: target,
+      status: "error",
+      message: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function stripManagedBlock(projectRoot, relPath, options) {
+  const step = relPath.endsWith(".mdc") ? "bootstrap-cursor" : "bootstrap-codex";
+  const target = join(projectRoot, relPath);
+  if (!existsSync(target)) {
+    return { step, path: target, status: "skipped", message: "absent" };
+  }
+  let existing;
+  try {
+    existing = await readFile(target, "utf8");
+  } catch (error) {
+    return {
+      step,
+      path: target,
+      status: "error",
+      message: error instanceof Error ? error.message : String(error)
+    };
+  }
+  const match = existing.match(BOOTSTRAP_REGEX);
+  if (match === null) {
+    return { step, path: target, status: "skipped", message: "no-fabric-section" };
+  }
+  const before = existing.slice(0, match.index ?? 0);
+  const after = existing.slice((match.index ?? 0) + match[0].length);
+  const filtered = `${before}${after.replace(/^\r?\n/, "")}`;
+  if (options.deleteWhenEmpty && isFrontMatterOnly(filtered)) {
+    try {
+      await rm(target, { force: true });
+      return { step, path: target, status: "removed", message: "front-matter-only" };
+    } catch (error) {
+      return {
+        step,
+        path: target,
+        status: "error",
+        message: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  try {
+    await atomicWriteText(target, filtered);
+    return { step, path: target, status: "removed" };
+  } catch (error) {
+    return {
+      step,
+      path: target,
+      status: "error",
+      message: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function isFrontMatterOnly(content) {
+  const trimmed = content.replace(/^\s+/, "");
+  const match = trimmed.match(/^---\n[\s\S]*?\n---\s*$/);
+  if (match === null) return trimmed.length === 0;
+  return true;
+}
+async function deleteFabricAgentsSnapshot(projectRoot) {
+  const target = fabricAgentsSnapshotPath(projectRoot);
+  return rmIfExists("bootstrap-snapshot", target);
+}
+async function uninstallBootstrapStage(projectRoot, _opts = {}) {
+  const results = [];
+  await runAndCollect(
+    results,
+    "bootstrap-blocks",
+    projectRoot,
+    () => stripFabricBootstrapBlocks(projectRoot)
+  );
+  await runAndCollectOne(
+    results,
+    "bootstrap-snapshot",
+    projectRoot,
+    () => deleteFabricAgentsSnapshot(projectRoot)
+  );
+  await runAndCollectOne(
+    results,
+    "cursor-hook-config",
+    projectRoot,
+    () => unmergeCursorHookConfig(projectRoot)
+  );
+  await runAndCollectOne(
+    results,
+    "codex-hook-config",
+    projectRoot,
+    () => unmergeCodexHookConfig(projectRoot)
+  );
+  await runAndCollectOne(
+    results,
+    "claude-hook-config",
+    projectRoot,
+    () => unmergeClaudeCodeHookConfig(projectRoot)
+  );
+  await runAndCollect(results, "hook-lib", projectRoot, () => removeHookLibs(projectRoot));
+  await runAndCollect(
+    results,
+    "hook-narrow-script",
+    projectRoot,
+    () => removeKnowledgeHintNarrowHook(projectRoot)
+  );
+  await runAndCollect(
+    results,
+    "hook-broad-script",
+    projectRoot,
+    () => removeKnowledgeHintBroadHook(projectRoot)
+  );
+  await runAndCollect(
+    results,
+    "hook-script",
+    projectRoot,
+    () => removeArchiveHintHook(projectRoot)
+  );
+  await runAndCollect(
+    results,
+    "skill-sync",
+    projectRoot,
+    () => uninstallFabricSyncSkill(projectRoot)
+  );
+  await runAndCollect(
+    results,
+    "skill-import",
+    projectRoot,
+    () => uninstallFabricImportSkill(projectRoot)
+  );
+  await runAndCollect(
+    results,
+    "skill-review",
+    projectRoot,
+    () => uninstallFabricReviewSkill(projectRoot)
+  );
+  await runAndCollect(
+    results,
+    "skill",
+    projectRoot,
+    () => uninstallFabricArchiveSkill(projectRoot)
+  );
+  return results;
+}
+async function runAndCollect(results, step, projectRoot, fn) {
+  try {
+    const sub = await fn();
+    results.push(...sub);
+  } catch (error) {
+    results.push({
+      step,
+      path: projectRoot,
+      status: "error",
+      message: error instanceof Error ? error.message : String(error)
+    });
+  }
+}
+async function runAndCollectOne(results, step, projectRoot, fn) {
+  try {
+    results.push(await fn());
+  } catch (error) {
+    results.push({
+      step,
+      path: projectRoot,
+      status: "error",
+      message: error instanceof Error ? error.message : String(error)
+    });
+  }
+}
+async function rmIfExists(step, target) {
+  if (!existsSync(target)) {
+    return { step, path: target, status: "skipped", message: "absent" };
+  }
+  try {
+    await rm(target, { force: true });
+    return { step, path: target, status: "removed" };
+  } catch (error) {
+    return {
+      step,
+      path: target,
+      status: "error",
+      message: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function rmDirIfEmpty(step, target) {
+  if (!existsSync(target)) {
+    return { step, path: target, status: "skipped", message: "absent" };
+  }
+  let entries;
+  try {
+    entries = await readdir(target);
+  } catch (error) {
+    return {
+      step,
+      path: target,
+      status: "error",
+      message: error instanceof Error ? error.message : String(error)
+    };
+  }
+  if (entries.length > 0) {
+    return { step, path: target, status: "skipped", message: "not-empty" };
+  }
+  try {
+    await rmdir(target);
+    return { step, path: target, status: "removed" };
+  } catch (error) {
+    return {
+      step,
+      path: target,
+      status: "error",
+      message: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function unmergeHookConfig(args) {
+  const target = join(args.projectRoot, args.configRel);
+  if (!existsSync(target)) {
+    return { step: args.step, path: target, status: "skipped", message: "absent" };
+  }
+  let raw;
+  try {
+    raw = await readFile(target, "utf8");
+  } catch (error) {
+    return {
+      step: args.step,
+      path: target,
+      status: "error",
+      message: error instanceof Error ? error.message : String(error)
+    };
+  }
+  if (raw.trim().length === 0) {
+    return { step: args.step, path: target, status: "skipped", message: "empty" };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    return {
+      step: args.step,
+      path: target,
+      status: "error",
+      message: error instanceof Error ? error.message : String(error)
+    };
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return { step: args.step, path: target, status: "skipped", message: "not-an-object" };
+  }
+  const next = JSON.parse(JSON.stringify(parsed));
+  for (const dotted of args.arrayPaths) {
+    pruneArrayAtPath(next, dotted, args.fabricCommands, args.extractCommands);
+  }
+  if (jsonEqual(parsed, next)) {
+    return { step: args.step, path: target, status: "skipped", message: "no-fabric-entries" };
+  }
+  try {
+    await atomicWriteJson(target, next, { indent: 2 });
+    return { step: args.step, path: target, status: "removed" };
+  } catch (error) {
+    return {
+      step: args.step,
+      path: target,
+      status: "error",
+      message: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function pruneArrayAtPath(root, path, fabricCommands, extractCommands) {
+  const keys = path.split(".");
+  const chain = [];
+  let cursor = root;
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    if (cursor === null || typeof cursor !== "object" || Array.isArray(cursor)) {
+      return;
+    }
+    const parent = cursor;
+    if (!(key in parent)) {
+      return;
+    }
+    chain.push({ parent, key });
+    cursor = parent[key];
+  }
+  if (!Array.isArray(cursor)) {
+    return;
+  }
+  const filtered = cursor.filter((entry) => {
+    const cmds = extractCommands(entry);
+    if (cmds.length === 0) {
+      return true;
+    }
+    return !cmds.some((cmd) => fabricCommands.some((fabric) => cmd === fabric || cmd.endsWith(fabric)));
+  });
+  const leaf = chain[chain.length - 1];
+  leaf.parent[leaf.key] = filtered;
+  if (filtered.length > 0) {
+    return;
+  }
+  for (let i = chain.length - 1; i >= 0; i--) {
+    const { parent, key } = chain[i];
+    const value = parent[key];
+    const isEmpty = Array.isArray(value) && value.length === 0 || value !== null && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === 0;
+    if (!isEmpty) {
+      return;
+    }
+    delete parent[key];
+  }
+}
+function extractClaudeCommands(entry) {
+  if (entry === null || typeof entry !== "object") {
+    return [];
+  }
+  const obj = entry;
+  const inner = obj["hooks"];
+  if (!Array.isArray(inner)) {
+    return [];
+  }
+  const out = [];
+  for (const sub of inner) {
+    if (sub === null || typeof sub !== "object") {
+      continue;
+    }
+    const cmd = sub["command"];
+    if (typeof cmd === "string") {
+      out.push(cmd);
+    }
+  }
+  return out;
+}
+function extractFlatCommands(entry) {
+  if (entry === null || typeof entry !== "object") {
+    return [];
+  }
+  const cmd = entry["command"];
+  return typeof cmd === "string" ? [cmd] : [];
+}
+function jsonEqual(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+
+// src/commands/uninstall.ts
+var UNINSTALL_WIZARD_GROUP_CANCELLED = /* @__PURE__ */ Symbol("uninstall-wizard-group-cancelled");
+var KNOWLEDGE_SUBDIRS = [
+  "decisions",
+  "pitfalls",
+  "guidelines",
+  "models",
+  "processes",
+  "pending"
+];
+var FABRIC_STATE_FILES = ["agents.meta.json", "events.jsonl", "forensic.json"];
+var uninstallCommand = defineCommand({
+  meta: {
+    name: "uninstall",
+    description: t("cli.uninstall.description")
+  },
+  args: {
+    debug: {
+      type: "boolean",
+      description: t("cli.uninstall.args.debug.description"),
+      default: false
+    },
+    "dry-run": {
+      type: "boolean",
+      description: t("cli.uninstall.args.dry-run.description"),
+      default: false
+    },
+    target: {
+      type: "string",
+      description: t("cli.uninstall.args.target.description")
+    },
+    yes: {
+      type: "boolean",
+      description: t("cli.uninstall.args.yes.description"),
+      default: false
+    }
+  },
+  async run({ args }) {
+    await runUninstallCommand(args);
+  }
+});
+var uninstall_default = uninstallCommand;
+async function runUninstallCommand(args) {
+  const logger = createDebugLogger(args.debug);
+  const resolution = resolveDevMode(args.target, process.cwd());
+  const intent = resolveUninstallCliIntent(args, resolution.target);
+  logger(`uninstall target source: ${resolution.source}`);
+  for (const step of resolution.chain) {
+    logger(step);
+  }
+  const supports = detectClientSupports(intent.target);
+  const basePlan = await buildUninstallExecutionPlan(intent.target, {
+    ...intent.options
+    // Carry through interactive flag for plan-summary printing.
+  });
+  const planWithSupports = {
+    ...basePlan,
+    interactive: intent.interactiveSummary && !intent.wizardEnabled,
+    supports
+  };
+  const finalPlan = intent.wizardEnabled ? await resolveUninstallExecutionPlanWithWizard(planWithSupports, createDefaultUninstallWizardAdapter()) : planWithSupports;
+  if (finalPlan === null) {
+    process.exitCode = 130;
+    return;
+  }
+  if (finalPlan.options.planOnly) {
+    printUninstallPlanPreview(finalPlan);
+    return {
+      plan: finalPlan,
+      stageResults: finalPlan.stages.map((stage) => ({
+        name: stage.name,
+        disposition: "skipped",
+        steps: []
+      }))
+    };
+  }
+  if (intent.interactiveSummary && !intent.wizardEnabled && args.yes !== true) {
+    const proceed = await confirmDestructive(finalPlan);
+    if (!proceed) {
+      process.exitCode = 130;
+      return;
+    }
+  }
+  const result = await executeUninstallExecutionPlan(finalPlan);
+  printUninstallSummary(result);
+  return result;
+}
+function resolveUninstallCliIntent(args, targetInput) {
+  const target = normalizeTarget(targetInput);
+  const terminalInteractive = isInteractiveUninstall();
+  const planOnly = args["dry-run"] === true;
+  const options = {
+    planOnly
+  };
+  return {
+    target,
+    options,
+    interactiveSummary: terminalInteractive,
+    wizardEnabled: shouldUseUninstallWizard(args, terminalInteractive) && !planOnly
+  };
+}
+function shouldUseUninstallWizard(args, terminalInteractive = isInteractiveUninstall()) {
+  return terminalInteractive && args.yes !== true;
+}
+async function buildUninstallExecutionPlan(target, options = {}) {
+  const scaffold = buildUninstallFabricPlan(target, options);
+  const supports = detectClientSupports(target);
+  const stages = [
+    { name: "scaffold", skipped: Boolean(options.skipScaffold) },
+    { name: "bootstrap", skipped: Boolean(options.skipBootstrap) },
+    { name: "mcp", skipped: Boolean(options.skipMcp) }
+  ];
+  return {
+    target,
+    options,
+    interactive: false,
+    supports,
+    scaffold,
+    stages
+  };
+}
+function buildUninstallFabricPlan(target, options = {}) {
+  const absTarget = normalizeTarget(target);
+  const fabricDir = join2(absTarget, ".fabric");
+  const personalKnowledgeDir = resolve(resolvePersonalFabricRoot(), ".fabric", "knowledge");
+  const entries = [];
+  for (const name of FABRIC_STATE_FILES) {
+    const p = join2(fabricDir, name);
+    entries.push({ path: p, kind: "state-file", absent: !existsSync2(p) });
+  }
+  for (const sub of KNOWLEDGE_SUBDIRS) {
+    const gk = join2(fabricDir, "knowledge", sub, ".gitkeep");
+    entries.push({ path: gk, kind: "gitkeep", absent: !existsSync2(gk) });
+  }
+  const safeEntries = entries.filter((entry) => !isInsidePersonalRoot(entry.path, personalKnowledgeDir));
+  return {
+    target: absTarget,
+    fabricDir,
+    personalKnowledgeDir,
+    options,
+    entries: safeEntries
+  };
+}
+async function executeUninstallFabricPlan(plan) {
+  const results = [];
+  for (const entry of plan.entries) {
+    if (entry.absent) {
+      results.push({
+        step: scaffoldStepLabel(entry.kind),
+        path: entry.path,
+        status: "skipped",
+        message: "absent"
+      });
+      continue;
+    }
+    try {
+      await rm2(entry.path, { force: true });
+      results.push({ step: scaffoldStepLabel(entry.kind), path: entry.path, status: "removed" });
+    } catch (error) {
+      results.push({
+        step: scaffoldStepLabel(entry.kind),
+        path: entry.path,
+        status: "error",
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  return results;
+}
+function scaffoldStepLabel(kind) {
+  switch (kind) {
+    case "state-file":
+      return "scaffold-state";
+    case "gitkeep":
+      return "scaffold-gitkeep";
+  }
+}
+async function uninstallMcpClients(target, options = {}) {
+  const workspaceRoot = resolve(target);
+  const writers = resolveClients(workspaceRoot, {});
+  const details = [];
+  const results = [];
+  for (const writer of writers) {
+    let configPath;
+    try {
+      configPath = await writer.detect(workspaceRoot);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      details.push({ client: writer.clientKind, status: "error", message });
+      results.push({
+        step: `mcp-${writer.clientKind}`,
+        path: "",
+        status: "error",
+        message
+      });
+      continue;
+    }
+    if (configPath === null) {
+      details.push({ client: writer.clientKind, status: "skipped", message: "no-config-path" });
+      results.push({
+        step: `mcp-${writer.clientKind}`,
+        path: "",
+        status: "skipped",
+        message: "no-config-path"
+      });
+      continue;
+    }
+    if (options.dryRun === true) {
+      details.push({ client: writer.clientKind, status: "dry-run", path: configPath });
+      results.push({
+        step: `mcp-${writer.clientKind}`,
+        path: configPath,
+        status: "skipped",
+        message: "dry-run"
+      });
+      continue;
+    }
+    let removeResult;
+    try {
+      removeResult = await writer.remove("fabric", workspaceRoot);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      details.push({ client: writer.clientKind, status: "error", path: configPath, message });
+      results.push({
+        step: `mcp-${writer.clientKind}`,
+        path: configPath,
+        status: "error",
+        message
+      });
+      continue;
+    }
+    details.push({
+      client: writer.clientKind,
+      status: removeResult.status,
+      path: removeResult.path,
+      message: removeResult.message
+    });
+    results.push({
+      step: `mcp-${writer.clientKind}`,
+      path: removeResult.path ?? configPath,
+      status: removeResult.status === "removed" ? "removed" : removeResult.status === "error" ? "error" : "skipped",
+      message: removeResult.message
+    });
+  }
+  return { details, results };
+}
+async function executeUninstallExecutionPlan(plan) {
+  const stageResults = [];
+  for (const stage of plan.stages) {
+    if (stage.skipped) {
+      stageResults.push({ name: stage.name, disposition: "skipped", steps: [] });
+      continue;
+    }
+    console.log(formatUninstallStageHeader(stage.name));
+    try {
+      const steps = await executeUninstallStage(plan, stage.name);
+      const disposition = steps.some((s) => s.status === "error") ? "failed" : "ran";
+      stageResults.push({ name: stage.name, disposition, steps });
+      console.log(formatUninstallStageResult(stage.name, steps));
+    } catch (error) {
+      stageResults.push({
+        name: stage.name,
+        disposition: "failed",
+        steps: [
+          {
+            step: stage.name,
+            path: plan.target,
+            status: "error",
+            message: error instanceof Error ? error.message : String(error)
+          }
+        ]
+      });
+      writeStderr(formatUninstallStageFailure(stage.name, error));
+    }
+  }
+  return { plan, stageResults };
+}
+async function executeUninstallStage(plan, stageName) {
+  switch (stageName) {
+    case "scaffold":
+      return executeUninstallFabricPlan(plan.scaffold);
+    case "bootstrap": {
+      const opts = {};
+      return uninstallBootstrapStage(plan.target, opts);
+    }
+    case "mcp": {
+      const { results } = await uninstallMcpClients(plan.target);
+      return results;
+    }
+  }
+}
+async function uninstallFabric(target, options = {}) {
+  const plan = await buildUninstallExecutionPlan(target, options);
+  return executeUninstallExecutionPlan(plan);
+}
+async function resolveUninstallExecutionPlanWithWizard(basePlan, wizardAdapter) {
+  const selection = await wizardAdapter.run({
+    target: basePlan.target,
+    options: basePlan.options,
+    supports: basePlan.supports,
+    lockedStages: []
+  });
+  if (selection === null) {
+    return null;
+  }
+  const nextOptions = {
+    ...basePlan.options,
+    skipScaffold: !selection.scaffold,
+    skipBootstrap: !selection.bootstrap,
+    skipMcp: !selection.mcp
+  };
+  const rebuilt = await buildUninstallExecutionPlan(basePlan.target, nextOptions);
+  return {
+    ...rebuilt,
+    interactive: false,
+    supports: basePlan.supports
+  };
+}
+function createDefaultUninstallWizardAdapter() {
+  return {
+    async run(context) {
+      intro(t("cli.uninstall.wizard.intro"));
+      note(
+        t("cli.uninstall.wizard.overview.body", {
+          target: context.target
+        }),
+        t("cli.uninstall.wizard.overview.title")
+      );
+      printUninstallPlanSummary(context.target, context.options, context.supports);
+      log.step(t("cli.uninstall.wizard.step.target"));
+      const continueWithTarget = await confirm({
+        message: t("cli.uninstall.wizard.target.confirm", { target: context.target }),
+        initialValue: true
+      });
+      if (isCancel(continueWithTarget) || !continueWithTarget) {
+        emitUninstallWizardCancellation();
+        return null;
+      }
+      log.step(t("cli.uninstall.wizard.step.plan"));
+      let groupedSelection;
+      try {
+        groupedSelection = await group(
+          {
+            scaffold: async () => context.lockedStages.includes("scaffold") ? false : confirmInGroup({
+              message: t("cli.uninstall.wizard.stage.scaffold", {
+                defaultValue: formatPromptDefault(!context.options.skipScaffold)
+              }),
+              initialValue: !context.options.skipScaffold
+            }),
+            bootstrap: async () => context.lockedStages.includes("bootstrap") ? false : confirmInGroup({
+              message: t("cli.uninstall.wizard.stage.bootstrap", {
+                defaultValue: formatPromptDefault(!context.options.skipBootstrap)
+              }),
+              initialValue: !context.options.skipBootstrap
+            }),
+            mcp: async () => context.lockedStages.includes("mcp") ? false : confirmInGroup({
+              message: t("cli.uninstall.wizard.stage.mcp", {
+                defaultValue: formatPromptDefault(!context.options.skipMcp)
+              }),
+              initialValue: !context.options.skipMcp
+            })
+          },
+          {
+            onCancel() {
+              throw UNINSTALL_WIZARD_GROUP_CANCELLED;
+            }
+          }
+        );
+      } catch (error) {
+        if (error === UNINSTALL_WIZARD_GROUP_CANCELLED) {
+          emitUninstallWizardCancellation();
+          return null;
+        }
+        throw error;
+      }
+      const previewOptions = {
+        ...context.options,
+        skipScaffold: !groupedSelection.scaffold,
+        skipBootstrap: !groupedSelection.bootstrap,
+        skipMcp: !groupedSelection.mcp
+      };
+      log.step(t("cli.uninstall.wizard.step.review"));
+      printUninstallPlanSummary(context.target, previewOptions, context.supports);
+      const confirmed = await confirm({
+        message: t("cli.uninstall.wizard.execute.confirm"),
+        initialValue: true
+      });
+      if (isCancel(confirmed) || !confirmed) {
+        emitUninstallWizardCancellation();
+        return null;
+      }
+      outro(t("cli.uninstall.wizard.outro"));
+      return groupedSelection;
+    }
+  };
+}
+function emitUninstallWizardCancellation() {
+  cancel(t("cli.uninstall.wizard.cancelled"));
+}
+async function confirmInGroup(options) {
+  const result = await confirm(options);
+  if (isCancel(result)) {
+    throw UNINSTALL_WIZARD_GROUP_CANCELLED;
+  }
+  return result;
+}
+async function confirmDestructive(plan) {
+  printUninstallPlanSummary(plan.target, plan.options, plan.supports);
+  const answer = await confirm({
+    message: t("cli.uninstall.confirm.proceed", { target: plan.target }),
+    initialValue: false
+  });
+  if (isCancel(answer)) {
+    return false;
+  }
+  return answer === true;
+}
+function printUninstallPlanPreview(plan) {
+  console.log(t("cli.uninstall.plan.preview-title"));
+  printUninstallPlanSummary(plan.target, plan.options, plan.supports);
+  console.log(
+    t("cli.uninstall.plan.preview-result", {
+      scaffold: yesNoLabel(!plan.options.skipScaffold),
+      bootstrap: yesNoLabel(!plan.options.skipBootstrap),
+      mcp: yesNoLabel(!plan.options.skipMcp)
+    })
+  );
+  if (!plan.options.skipScaffold && plan.scaffold.entries.length > 0) {
+    console.log(t("cli.uninstall.plan.scaffold-entries.title"));
+    for (const entry of plan.scaffold.entries) {
+      const marker = entry.absent ? paint.muted("(absent)") : paint.success("(present)");
+      console.log(`  - ${entry.path} ${marker}`);
+    }
+  }
+}
+function printUninstallPlanSummary(target, options, supports) {
+  console.log(t("cli.uninstall.plan.title"));
+  console.log(t("cli.uninstall.plan.target", { target }));
+  console.log(
+    t("cli.uninstall.plan.actions", {
+      scaffold: yesNoLabel(!options.skipScaffold),
+      bootstrap: yesNoLabel(!options.skipBootstrap),
+      mcp: yesNoLabel(!options.skipMcp)
+    })
+  );
+  const detected = supports.filter((support) => support.detected);
+  console.log(
+    t("cli.uninstall.plan.detected", {
+      clients: detected.length > 0 ? detected.map((support) => support.label).join(", ") : t("cli.shared.none")
+    })
+  );
+  console.log(t("cli.uninstall.plan.preserves"));
+  console.log(`  - ${target}/.fabric/knowledge/  ${paint.muted(t("cli.uninstall.plan.preserves.knowledge"))}`);
+  console.log(`  - ~/.fabric/knowledge/  ${paint.muted(t("cli.uninstall.plan.preserves.personal"))}`);
+}
+function printUninstallSummary(result) {
+  const removed = result.stageResults.flatMap(
+    (stage) => stage.steps.filter((s) => s.status === "removed")
+  ).length;
+  const skipped = result.stageResults.flatMap(
+    (stage) => stage.steps.filter((s) => s.status === "skipped")
+  ).length;
+  const errors = result.stageResults.flatMap(
+    (stage) => stage.steps.filter((s) => s.status === "error")
+  ).length;
+  note(
+    t("cli.uninstall.summary.body", {
+      removed: String(removed),
+      skipped: String(skipped),
+      errors: String(errors)
+    }),
+    t("cli.uninstall.summary.title")
+  );
+  for (const stage of result.stageResults) {
+    for (const step of stage.steps) {
+      if (step.status === "error") {
+        writeStderr(`${paint.error(t("cli.shared.error"))} ${stage.name}/${step.step} ${step.path}: ${step.message ?? "unknown error"}`);
+      }
+    }
+  }
+}
+function formatUninstallStageHeader(stageName) {
+  return `${paint.ai(t("cli.shared.next"))} ${paint.muted(t(`cli.uninstall.stages.${stageName}`))}`;
+}
+function formatUninstallStageResult(stageName, steps) {
+  const removedCount = steps.filter((s) => s.status === "removed").length;
+  const skippedCount = steps.filter((s) => s.status === "skipped").length;
+  const errorCount = steps.filter((s) => s.status === "error").length;
+  const counts = `removed=${removedCount} skipped=${skippedCount} errors=${errorCount}`;
+  const label = errorCount > 0 ? paint.warn(t("cli.uninstall.stages.completed-with-errors")) : paint.success(t("cli.uninstall.stages.completed"));
+  return `${label} ${stageName}: ${counts}`;
+}
+function formatUninstallStageFailure(stage, error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return `${paint.error(t("cli.uninstall.stages.failed"))} ${stage}: ${message}`;
+}
+function resolvePersonalFabricRoot() {
+  return process.env.FABRIC_HOME ?? homedir();
+}
+function isInsidePersonalRoot(candidate, personalKnowledgeDir) {
+  const candidateAbs = resolve(candidate);
+  const rootAbs = resolve(personalKnowledgeDir);
+  if (candidateAbs === rootAbs) {
+    return true;
+  }
+  const rel = relative(rootAbs, candidateAbs);
+  return rel.length > 0 && !rel.startsWith("..") && !isAbsolute(rel) && !rel.split(sep).includes("..");
+}
+function normalizeTarget(targetInput) {
+  return isAbsolute(targetInput) ? targetInput : resolve(process.cwd(), targetInput);
+}
+function assertExistingDirectory(target) {
+  if (!existsSync2(target) || !statSync(target).isDirectory()) {
+    throw new Error(t("cli.uninstall.errors.target-not-directory", { path: target }));
+  }
+}
+function isInteractiveUninstall() {
+  return Boolean(process.stdin.isTTY) && Boolean(process.stdout.isTTY) && Boolean(process.stderr.isTTY);
+}
+function formatPromptDefault(value) {
+  return value ? "Y/n" : "y/N";
+}
+function yesNoLabel(value) {
+  return value ? t("cli.shared.yes") : t("cli.shared.no");
+}
+function writeStderr(message) {
+  process.stderr.write(`${message}
+`);
+}
+export {
+  assertExistingDirectory,
+  buildUninstallExecutionPlan,
+  buildUninstallFabricPlan,
+  createDefaultUninstallWizardAdapter,
+  uninstall_default as default,
+  executeUninstallExecutionPlan,
+  executeUninstallFabricPlan,
+  isInsidePersonalRoot,
+  resolveUninstallExecutionPlanWithWizard,
+  runUninstallCommand,
+  shouldUseUninstallWizard,
+  uninstallCommand,
+  uninstallFabric,
+  uninstallMcpClients
+};