@juho0719/cckit 0.1.1 → 0.2.0

package/dist/{cli-VZRGF733.js → cli-H6IDWH7Q.js}

@@ -91,6 +91,7 @@ async function runCli() {
     mcps: [],
     mcpEnvValues: /* @__PURE__ */ new Map()
   };
+  const skippedMcps = /* @__PURE__ */ new Map();
   if (selectedCategories.includes("agents")) {
     const allAgents = await getAgents();
     plan.agents = await checkbox({
@@ -161,14 +162,29 @@ async function runCli() {
       console.log(chalk.yellow(`
   ${server.name} requires environment variables:`));
       const envMap = {};
+      const skippedKeys = [];
       for (const envKey of server.envVars) {
-        const value = await input({
-          message: `  ${envKey}:`,
-          default: ""
+        const action = await select({
+          message: `  How do you want to set ${chalk.bold(envKey)}?`,
+          choices: [
+            { name: "Enter value now", value: "enter" },
+            { name: `Skip ${chalk.gray(`(keep placeholder: YOUR_${envKey}_HERE)`)}`, value: "skip" }
+          ]
         });
-        if (value) envMap[envKey] = value;
+        if (action === "skip") {
+          skippedKeys.push(envKey);
+        } else {
+          const value = await input({
+            message: `  ${envKey}:`,
+            default: ""
+          });
+          if (value) envMap[envKey] = value;
+        }
       }
       plan.mcpEnvValues.set(server.name, envMap);
+      if (skippedKeys.length > 0) {
+        skippedMcps.set(server.name, skippedKeys);
+      }
     }
   }
   console.log(chalk.bold("\n  Installation Summary"));
@@ -228,6 +244,15 @@ async function runCli() {
     if (plan.ruleCategories.length) console.log(`  ${chalk.green("\u2713")} Rules appended \u2192 ${join(targetDir, "CLAUDE.md")}`);
     if (plan.mcps.length) console.log(`  ${chalk.green("\u2713")} ${plan.mcps.length} MCP server(s) \u2192 ${scope === "global" ? "~/.claude.json" : "./.claude.json"}`);
     console.log("");
+    if (skippedMcps.size > 0) {
+      console.log(chalk.yellow("  \u26A0  The following MCP servers have placeholder env vars:"));
+      for (const [serverName, keys] of skippedMcps) {
+        console.log(`     ${chalk.bold("-")} ${serverName} ${chalk.gray(`(${keys.join(", ")})`)} `);
+      }
+      const configPath = scope === "global" ? "~/.claude.json" : "./.claude.json";
+      console.log(chalk.gray(`     \u2192 Edit ${configPath} to set the actual values`));
+      console.log("");
+    }
   } catch (err) {
     spinner.fail(chalk.red("Installation failed"));
     throw err;

package/dist/index.js

@@ -20,15 +20,17 @@ function printHelp() {
 cckit - Claude Code Harness Installer v${getVersion()}
 
 Usage:
-  cckit           Interactive installation wizard
-  cckit --all     Install all items (global scope)
-  cckit --version Show version
-  cckit --help    Show this help
+  cckit               Interactive installation wizard
+  cckit --uninstall   Interactive uninstall wizard
+  cckit --all         Install all items (global scope)
+  cckit --version     Show version
+  cckit --help        Show this help
 
 Options:
-  --all           Install all agents, skills, commands, hooks, rules, and MCPs
-                  to ~/.claude/ without interactive prompts
-  --scope         Scope for --all flag: global (default) or project
+  --uninstall, -u   Launch interactive uninstall wizard
+  --all             Install all agents, skills, commands, hooks, rules, and MCPs
+                    to ~/.claude/ without interactive prompts
+  --scope           Scope for --all flag: global (default) or project
 `);
 }
 async function installAll(scope) {
@@ -114,13 +116,18 @@ async function main() {
     printHelp();
     return;
   }
+  if (args.includes("--uninstall") || args.includes("-u")) {
+    const { runUninstallCli } = await import("./uninstall-cli-KYQTJCKO.js");
+    await runUninstallCli();
+    return;
+  }
   if (args.includes("--all")) {
     const scopeIdx = args.indexOf("--scope");
     const scope = scopeIdx !== -1 && args[scopeIdx + 1] === "project" ? "project" : "global";
     await installAll(scope);
     return;
   }
-  const { runCli } = await import("./cli-VZRGF733.js");
+  const { runCli } = await import("./cli-H6IDWH7Q.js");
   await runCli();
 }
 main().catch((err) => {

package/dist/uninstall-cli-KYQTJCKO.js

@@ -0,0 +1,544 @@
+import {
+  getAgents,
+  getCommands,
+  getHooks,
+  getMcpServers,
+  getRuleCategories,
+  getSkills
+} from "./chunk-6B46AIFM.js";
+import {
+  getAssetsDir,
+  getGlobalDir,
+  getProjectDir
+} from "./chunk-5XOKKPAA.js";
+
+// src/uninstall-cli.ts
+import { checkbox, select, confirm } from "@inquirer/prompts";
+import chalk from "chalk";
+import ora from "ora";
+import { join as join8 } from "path";
+
+// src/scanner.ts
+import { readdir, readFile, access } from "fs/promises";
+import { constants } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+function getClaudeJsonPath(scope) {
+  if (scope === "global") {
+    return join(homedir(), ".claude.json");
+  }
+  return join(process.cwd(), ".claude.json");
+}
+async function getInstalledAgents(targetDir) {
+  const agentsDir = join(targetDir, "agents");
+  let installedFiles = [];
+  try {
+    installedFiles = (await readdir(agentsDir)).filter((f) => f.endsWith(".md"));
+  } catch {
+    return [];
+  }
+  const registryAgents = await getAgents();
+  return registryAgents.filter((a) => installedFiles.includes(a.file));
+}
+async function getInstalledSkills(targetDir) {
+  const skillsDir = join(targetDir, "skills");
+  let installedDirs = [];
+  try {
+    const entries = await readdir(skillsDir, { withFileTypes: true });
+    installedDirs = entries.filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch {
+    return [];
+  }
+  const registrySkills = await getSkills();
+  return registrySkills.filter((s) => installedDirs.includes(s.dir));
+}
+async function getInstalledCommands(targetDir) {
+  const commandsDir = join(targetDir, "commands");
+  let installedFiles = [];
+  try {
+    installedFiles = (await readdir(commandsDir)).filter((f) => f.endsWith(".md"));
+  } catch {
+    return [];
+  }
+  const registryCommands = await getCommands();
+  return registryCommands.filter((c) => installedFiles.includes(c.file));
+}
+async function getInstalledHooks(targetDir) {
+  const hooksDir = join(targetDir, "hooks");
+  let installedFiles = [];
+  try {
+    installedFiles = (await readdir(hooksDir)).filter((f) => f.endsWith(".js"));
+  } catch {
+    return [];
+  }
+  const registryHooks = await getHooks();
+  return registryHooks.filter((h) => installedFiles.includes(h.file));
+}
+async function getInstalledRuleCategories(targetDir) {
+  const claudeMdPath = join(targetDir, "CLAUDE.md");
+  let content = "";
+  try {
+    await access(claudeMdPath, constants.F_OK);
+    content = await readFile(claudeMdPath, "utf-8");
+  } catch {
+    return [];
+  }
+  const installedHeaders = /* @__PURE__ */ new Set();
+  for (const line of content.split("\n")) {
+    const match = line.match(/^(#{1,2}\s+.+)/);
+    if (match) installedHeaders.add(match[1].trim());
+  }
+  const allCategories = await getRuleCategories();
+  const installedCategories = [];
+  for (const rc of allCategories) {
+    const catDir = join(getAssetsDir(), "rules", rc.category);
+    let found = false;
+    for (const file of rc.files) {
+      try {
+        const fileContent = await readFile(join(catDir, file), "utf-8");
+        const headerMatch = fileContent.match(/^(#{1,2}\s+.+)/m);
+        if (headerMatch && installedHeaders.has(headerMatch[1].trim())) {
+          found = true;
+          break;
+        }
+      } catch {
+      }
+    }
+    if (found) installedCategories.push(rc.category);
+  }
+  return installedCategories;
+}
+async function getInstalledMcps(scope) {
+  const filePath = getClaudeJsonPath(scope);
+  let claudeJson = {};
+  try {
+    await access(filePath, constants.F_OK);
+    const raw = await readFile(filePath, "utf-8");
+    claudeJson = JSON.parse(raw);
+  } catch {
+    return [];
+  }
+  if (!claudeJson.mcpServers) return [];
+  const installedNames = new Set(Object.keys(claudeJson.mcpServers));
+  const registryMcps = await getMcpServers();
+  return registryMcps.filter((m) => installedNames.has(m.name)).map((m) => m.name);
+}
+
+// src/uninstallers/agents.ts
+import { join as join2 } from "path";
+import { rm, access as access2 } from "fs/promises";
+import { constants as constants2 } from "fs";
+async function uninstallAgents(agents, targetDir) {
+  const agentsDir = join2(targetDir, "agents");
+  for (const agent of agents) {
+    const filePath = join2(agentsDir, agent.file);
+    try {
+      await access2(filePath, constants2.F_OK);
+      await rm(filePath);
+    } catch {
+    }
+  }
+}
+
+// src/uninstallers/skills.ts
+import { join as join3 } from "path";
+import { rm as rm2, access as access3 } from "fs/promises";
+import { constants as constants3 } from "fs";
+async function uninstallSkills(skills, targetDir) {
+  const skillsDir = join3(targetDir, "skills");
+  for (const skill of skills) {
+    const dirPath = join3(skillsDir, skill.dir);
+    try {
+      await access3(dirPath, constants3.F_OK);
+      await rm2(dirPath, { recursive: true });
+    } catch {
+    }
+  }
+}
+
+// src/uninstallers/commands.ts
+import { join as join4 } from "path";
+import { rm as rm3, access as access4 } from "fs/promises";
+import { constants as constants4 } from "fs";
+async function uninstallCommands(commands, targetDir) {
+  const commandsDir = join4(targetDir, "commands");
+  for (const cmd of commands) {
+    const filePath = join4(commandsDir, cmd.file);
+    try {
+      await access4(filePath, constants4.F_OK);
+      await rm3(filePath);
+    } catch {
+    }
+  }
+}
+
+// src/uninstallers/hooks.ts
+import { join as join5 } from "path";
+import { rm as rm4, readFile as readFile2, writeFile, access as access5 } from "fs/promises";
+import { constants as constants5 } from "fs";
+async function removeHookFromSettings(settingsPath, hookCommand) {
+  let settings = {};
+  try {
+    await access5(settingsPath, constants5.F_OK);
+    const content = await readFile2(settingsPath, "utf-8");
+    settings = JSON.parse(content);
+  } catch {
+    return;
+  }
+  if (!settings.hooks) return;
+  for (const hookType of Object.keys(settings.hooks)) {
+    const matchers = settings.hooks[hookType];
+    for (let i = matchers.length - 1; i >= 0; i--) {
+      const matcher = matchers[i];
+      matcher.hooks = matcher.hooks.filter((h) => h.command !== hookCommand);
+      if (matcher.hooks.length === 0) {
+        matchers.splice(i, 1);
+      }
+    }
+    if (matchers.length === 0) {
+      delete settings.hooks[hookType];
+    }
+  }
+  if (Object.keys(settings.hooks).length === 0) {
+    delete settings.hooks;
+  }
+  await writeFile(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+}
+async function uninstallHooks(hooks, targetDir) {
+  const hooksDir = join5(targetDir, "hooks");
+  const settingsPath = join5(targetDir, "settings.json");
+  for (const hook of hooks) {
+    const filePath = join5(hooksDir, hook.file);
+    const hookCommand = `node ${filePath}`;
+    await removeHookFromSettings(settingsPath, hookCommand);
+    try {
+      await access5(filePath, constants5.F_OK);
+      await rm4(filePath);
+    } catch {
+    }
+  }
+}
+
+// src/uninstallers/rules.ts
+import { readFile as readFile3, writeFile as writeFile2, access as access6 } from "fs/promises";
+import { constants as constants6 } from "fs";
+import { join as join6 } from "path";
+async function uninstallRules(categories, claudeMdPath) {
+  let existing = "";
+  try {
+    await access6(claudeMdPath, constants6.F_OK);
+    existing = await readFile3(claudeMdPath, "utf-8");
+  } catch {
+    return;
+  }
+  const headersToRemove = /* @__PURE__ */ new Set();
+  for (const category of categories) {
+    const catDir = join6(getAssetsDir(), "rules", category);
+    let files;
+    try {
+      const { readdir: readdir2 } = await import("fs/promises");
+      files = (await readdir2(catDir)).filter((f) => f.endsWith(".md"));
+    } catch {
+      continue;
+    }
+    for (const file of files) {
+      try {
+        const content = await readFile3(join6(catDir, file), "utf-8");
+        const headerMatch = content.match(/^(#{1,2}\s+.+)/m);
+        if (headerMatch) {
+          headersToRemove.add(headerMatch[1].trim());
+        }
+      } catch {
+      }
+    }
+  }
+  if (headersToRemove.size === 0) return;
+  const lines = existing.split("\n");
+  const result = [];
+  let inRemovedSection = false;
+  let currentDepth = 0;
+  for (const line of lines) {
+    const headerMatch = line.match(/^(#{1,2})\s+/);
+    if (headerMatch) {
+      const depth = headerMatch[1].length;
+      const trimmed = line.trim();
+      if (headersToRemove.has(trimmed)) {
+        inRemovedSection = true;
+        currentDepth = depth;
+        continue;
+      }
+      if (inRemovedSection && depth <= currentDepth) {
+        inRemovedSection = false;
+      }
+    }
+    if (!inRemovedSection) {
+      result.push(line);
+    }
+  }
+  const cleaned = result.join("\n").replace(/\n{3,}/g, "\n\n");
+  await writeFile2(claudeMdPath, cleaned, "utf-8");
+}
+
+// src/uninstallers/mcps.ts
+import { join as join7 } from "path";
+import { readFile as readFile4, writeFile as writeFile3, access as access7 } from "fs/promises";
+import { constants as constants7 } from "fs";
+import { homedir as homedir2 } from "os";
+function getClaudeJsonPath2(scope) {
+  if (scope === "global") {
+    return join7(homedir2(), ".claude.json");
+  }
+  return join7(process.cwd(), ".claude.json");
+}
+async function uninstallMcps(serverNames, scope) {
+  const filePath = getClaudeJsonPath2(scope);
+  let claudeJson = {};
+  try {
+    await access7(filePath, constants7.F_OK);
+    const content = await readFile4(filePath, "utf-8");
+    claudeJson = JSON.parse(content);
+  } catch {
+    return;
+  }
+  if (!claudeJson.mcpServers) return;
+  for (const name of serverNames) {
+    delete claudeJson.mcpServers[name];
+  }
+  await writeFile3(filePath, JSON.stringify(claudeJson, null, 2) + "\n", "utf-8");
+}
+
+// src/uninstall-cli.ts
+function printBanner() {
+  console.log(
+    chalk.red.bold(`
+  \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2557  \u2588\u2588\u2557\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557
+ \u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2551 \u2588\u2588\u2554\u255D\u2588\u2588\u2551\u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D
+ \u2588\u2588\u2551     \u2588\u2588\u2551     \u2588\u2588\u2588\u2588\u2588\u2554\u255D \u2588\u2588\u2551   \u2588\u2588\u2551
+ \u2588\u2588\u2551     \u2588\u2588\u2551     \u2588\u2588\u2554\u2550\u2588\u2588\u2557 \u2588\u2588\u2551   \u2588\u2588\u2551
+ \u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551  \u2588\u2588\u2557\u2588\u2588\u2551   \u2588\u2588\u2551
+  \u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u255D   \u255A\u2550\u255D
+`)
+  );
+  console.log(chalk.gray("  Claude Code Harness Uninstaller\n"));
+}
+async function runUninstallCli() {
+  printBanner();
+  const scope = await select({
+    message: "Uninstall scope:",
+    choices: [
+      {
+        name: `Global  ${chalk.gray("~/.claude/")}`,
+        value: "global"
+      },
+      {
+        name: `Project ${chalk.gray("./.claude/")}`,
+        value: "project"
+      }
+    ]
+  });
+  const targetDir = scope === "global" ? getGlobalDir() : getProjectDir();
+  console.log(chalk.gray("\n  Scanning installed items...\n"));
+  const [
+    installedAgents,
+    installedSkills,
+    installedCommands,
+    installedHooks,
+    installedRuleCategories,
+    installedMcpNames
+  ] = await Promise.all([
+    getInstalledAgents(targetDir),
+    getInstalledSkills(targetDir),
+    getInstalledCommands(targetDir),
+    getInstalledHooks(targetDir),
+    getInstalledRuleCategories(targetDir),
+    getInstalledMcps(scope)
+  ]);
+  const totalInstalled = installedAgents.length + installedSkills.length + installedCommands.length + installedHooks.length + installedRuleCategories.length + installedMcpNames.length;
+  if (totalInstalled === 0) {
+    console.log(chalk.yellow("  Nothing installed. Exiting."));
+    return;
+  }
+  const availableCategories = [];
+  if (installedAgents.length > 0)
+    availableCategories.push({
+      name: `Agents   ${chalk.gray(`(${installedAgents.length} installed)`)}`,
+      value: "agents"
+    });
+  if (installedSkills.length > 0)
+    availableCategories.push({
+      name: `Skills   ${chalk.gray(`(${installedSkills.length} installed)`)}`,
+      value: "skills"
+    });
+  if (installedCommands.length > 0)
+    availableCategories.push({
+      name: `Commands ${chalk.gray(`(${installedCommands.length} installed)`)}`,
+      value: "commands"
+    });
+  if (installedHooks.length > 0)
+    availableCategories.push({
+      name: `Hooks    ${chalk.gray(`(${installedHooks.length} installed)`)}`,
+      value: "hooks"
+    });
+  if (installedRuleCategories.length > 0)
+    availableCategories.push({
+      name: `Rules    ${chalk.gray(`(${installedRuleCategories.length} categories)`)}`,
+      value: "rules"
+    });
+  if (installedMcpNames.length > 0)
+    availableCategories.push({
+      name: `MCPs     ${chalk.gray(`(${installedMcpNames.length} installed)`)}`,
+      value: "mcps"
+    });
+  const selectedCategories = await checkbox({
+    message: "Select categories to uninstall:",
+    choices: availableCategories
+  });
+  if (selectedCategories.length === 0) {
+    console.log(chalk.yellow("\n  No categories selected. Exiting."));
+    return;
+  }
+  const plan = {
+    scope,
+    agents: [],
+    skills: [],
+    commands: [],
+    hooks: [],
+    ruleCategories: [],
+    mcpNames: []
+  };
+  if (selectedCategories.includes("agents") && installedAgents.length > 0) {
+    plan.agents = await checkbox({
+      message: "Select agents to uninstall:",
+      choices: installedAgents.map((a) => ({
+        name: `${chalk.bold(a.name.padEnd(30))} ${chalk.gray(a.description.slice(0, 60))}`,
+        value: a,
+        checked: false
+      }))
+    });
+  }
+  if (selectedCategories.includes("skills") && installedSkills.length > 0) {
+    plan.skills = await checkbox({
+      message: "Select skills to uninstall:",
+      choices: installedSkills.map((s) => ({
+        name: `${chalk.bold(s.name.padEnd(35))} ${chalk.gray(s.description.slice(0, 55))}`,
+        value: s,
+        checked: false
+      }))
+    });
+  }
+  if (selectedCategories.includes("commands") && installedCommands.length > 0) {
+    plan.commands = await checkbox({
+      message: "Select commands to uninstall:",
+      choices: installedCommands.map((c) => ({
+        name: `${chalk.bold(c.name.padEnd(25))} ${chalk.gray(c.description.slice(0, 65))}`,
+        value: c,
+        checked: false
+      }))
+    });
+  }
+  if (selectedCategories.includes("hooks") && installedHooks.length > 0) {
+    plan.hooks = await checkbox({
+      message: "Select hooks to uninstall:",
+      choices: installedHooks.map((h) => ({
+        name: `${chalk.bold(h.name.padEnd(35))} ${chalk.gray(h.description.slice(0, 55))}`,
+        value: h,
+        checked: false
+      }))
+    });
+  }
+  if (selectedCategories.includes("rules") && installedRuleCategories.length > 0) {
+    plan.ruleCategories = await checkbox({
+      message: "Select rule categories to uninstall:",
+      choices: installedRuleCategories.map((cat) => ({
+        name: chalk.bold(cat),
+        value: cat,
+        checked: false
+      }))
+    });
+  }
+  if (selectedCategories.includes("mcps") && installedMcpNames.length > 0) {
+    plan.mcpNames = await checkbox({
+      message: "Select MCP servers to uninstall:",
+      choices: installedMcpNames.map((name) => ({
+        name: chalk.bold(name),
+        value: name,
+        checked: false
+      }))
+    });
+  }
+  const totalToRemove = plan.agents.length + plan.skills.length + plan.commands.length + plan.hooks.length + plan.ruleCategories.length + plan.mcpNames.length;
+  if (totalToRemove === 0) {
+    console.log(chalk.yellow("\n  Nothing selected. Exiting."));
+    return;
+  }
+  console.log(chalk.bold("\n  Uninstall Summary"));
+  console.log(chalk.gray("  \u2500".repeat(40)));
+  console.log(`  Scope   : ${chalk.cyan(scope)} (${targetDir})`);
+  if (plan.agents.length) console.log(`  Agents  : ${plan.agents.map((a) => a.name).join(", ")}`);
+  if (plan.skills.length) console.log(`  Skills  : ${plan.skills.map((s) => s.name).join(", ")}`);
+  if (plan.commands.length)
+    console.log(`  Commands: ${plan.commands.map((c) => c.name).join(", ")}`);
+  if (plan.hooks.length) console.log(`  Hooks   : ${plan.hooks.map((h) => h.name).join(", ")}`);
+  if (plan.ruleCategories.length)
+    console.log(`  Rules   : ${plan.ruleCategories.join(", ")}`);
+  if (plan.mcpNames.length) console.log(`  MCPs    : ${plan.mcpNames.join(", ")}`);
+  console.log("");
+  const ok = await confirm({
+    message: chalk.red("Proceed with uninstallation? This cannot be undone."),
+    default: false
+  });
+  if (!ok) {
+    console.log(chalk.yellow("\n  Aborted."));
+    return;
+  }
+  console.log("");
+  const spinner = ora("Uninstalling...").start();
+  try {
+    if (plan.agents.length) {
+      spinner.text = "Removing agents...";
+      await uninstallAgents(plan.agents, targetDir);
+    }
+    if (plan.skills.length) {
+      spinner.text = "Removing skills...";
+      await uninstallSkills(plan.skills, targetDir);
+    }
+    if (plan.commands.length) {
+      spinner.text = "Removing commands...";
+      await uninstallCommands(plan.commands, targetDir);
+    }
+    if (plan.hooks.length) {
+      spinner.text = "Removing hooks...";
+      await uninstallHooks(plan.hooks, targetDir);
+    }
+    if (plan.ruleCategories.length) {
+      spinner.text = "Removing rules...";
+      const claudeMd = join8(targetDir, "CLAUDE.md");
+      await uninstallRules(plan.ruleCategories, claudeMd);
+    }
+    if (plan.mcpNames.length) {
+      spinner.text = "Removing MCP servers...";
+      await uninstallMcps(plan.mcpNames, scope);
+    }
+    spinner.succeed(chalk.green("Uninstallation complete!"));
+    console.log("");
+    if (plan.agents.length)
+      console.log(`  ${chalk.red("\u2717")} ${plan.agents.length} agent(s) removed`);
+    if (plan.skills.length)
+      console.log(`  ${chalk.red("\u2717")} ${plan.skills.length} skill(s) removed`);
+    if (plan.commands.length)
+      console.log(`  ${chalk.red("\u2717")} ${plan.commands.length} command(s) removed`);
+    if (plan.hooks.length)
+      console.log(`  ${chalk.red("\u2717")} ${plan.hooks.length} hook(s) removed`);
+    if (plan.ruleCategories.length)
+      console.log(`  ${chalk.red("\u2717")} Rules removed (${plan.ruleCategories.join(", ")})`);
+    if (plan.mcpNames.length)
+      console.log(`  ${chalk.red("\u2717")} ${plan.mcpNames.length} MCP server(s) removed`);
+    console.log("");
+  } catch (err) {
+    spinner.fail(chalk.red("Uninstallation failed"));
+    throw err;
+  }
+}
+export {
+  runUninstallCli
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juho0719/cckit",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Claude Code Harness Installer - Interactive CLI for installing Claude Code agents, skills, commands, hooks, rules, and MCP servers",
   "type": "module",
   "bin": {