@juho0719/cckit 0.1.1 → 0.2.1

package/assets/claudemd/CLAUDE.md

@@ -0,0 +1,69 @@
+---
+name: Claude Behavioral Guidelines
+description: LLM coding best practices - think before coding, simplicity, surgical changes, goal-driven execution
+---
+# Claude Behavioral Guidelines
+
+Behavioral guidelines to reduce common LLM coding mistakes. Merge with project-specific instructions as needed.
+
+**Tradeoff:** These guidelines bias toward caution over speed. For trivial tasks, use judgment.
+
+## 1. Think Before Coding
+
+**Don't assume. Don't hide confusion. Surface tradeoffs.**
+
+Before implementing:
+- State your assumptions explicitly. If uncertain, ask.
+- If multiple interpretations exist, present them - don't pick silently.
+- If a simpler approach exists, say so. Push back when warranted.
+- If something is unclear, stop. Name what's confusing. Ask.
+
+## 2. Simplicity First
+
+**Minimum code that solves the problem. Nothing speculative.**
+
+- No features beyond what was asked.
+- No abstractions for single-use code.
+- No "flexibility" or "configurability" that wasn't requested.
+- No error handling for impossible scenarios.
+- If you write 200 lines and it could be 50, rewrite it.
+
+Ask yourself: "Would a senior engineer say this is overcomplicated?" If yes, simplify.
+
+## 3. Surgical Changes
+
+**Touch only what you must. Clean up only your own mess.**
+
+When editing existing code:
+- Don't "improve" adjacent code, comments, or formatting.
+- Don't refactor things that aren't broken.
+- Match existing style, even if you'd do it differently.
+- If you notice unrelated dead code, mention it - don't delete it.
+
+When your changes create orphans:
+- Remove imports/variables/functions that YOUR changes made unused.
+- Don't remove pre-existing dead code unless asked.
+
+The test: Every changed line should trace directly to the user's request.
+
+## 4. Goal-Driven Execution
+
+**Define success criteria. Loop until verified.**
+
+Transform tasks into verifiable goals:
+- "Add validation" → "Write tests for invalid inputs, then make them pass"
+- "Fix the bug" → "Write a test that reproduces it, then make it pass"
+- "Refactor X" → "Ensure tests pass before and after"
+
+For multi-step tasks, state a brief plan:
+```
+1. [Step] → verify: [check]
+2. [Step] → verify: [check]
+3. [Step] → verify: [check]
+```
+
+Strong success criteria let you loop independently. Weak criteria ("make it work") require constant clarification.
+
+---
+
+**These guidelines are working if:** fewer unnecessary changes in diffs, fewer rewrites due to overcomplication, and clarifying questions come before implementation rather than after mistakes.

package/dist/{chunk-6B46AIFM.js → chunk-OLLOS3GG.js}

@@ -98,6 +98,21 @@ async function getRuleCategories() {
   }
   return categories;
 }
+async function getClaudemdItems() {
+  const dir = join(getAssetsDir(), "claudemd");
+  const files = (await readdir(dir)).filter((f) => f.endsWith(".md"));
+  const items = [];
+  for (const file of files) {
+    const content = await readFile(join(dir, file), "utf-8");
+    const fm = parseFrontmatter(content);
+    items.push({
+      name: fm["name"] || basename(file, ".md"),
+      description: fm["description"] || "",
+      file
+    });
+  }
+  return items;
+}
 async function getMcpServers() {
   const filePath = join(getAssetsDir(), "mcps", "mcp-servers.json");
   const content = await readFile(filePath, "utf-8");
@@ -132,5 +147,6 @@ export {
   getCommands,
   getHooks,
   getRuleCategories,
+  getClaudemdItems,
   getMcpServers
 };

package/dist/chunk-SW3OJLHC.js

@@ -0,0 +1,35 @@
+import {
+  getAssetsDir
+} from "./chunk-5XOKKPAA.js";
+
+// src/installers/claudemd.ts
+import { join } from "path";
+import { readFile, writeFile, access } from "fs/promises";
+import { constants } from "fs";
+async function installClaudemd(items, targetDir) {
+  const claudemdDir = join(getAssetsDir(), "claudemd");
+  const targetClaudeMd = join(targetDir, "CLAUDE.md");
+  let existing = "";
+  try {
+    await access(targetClaudeMd, constants.F_OK);
+    existing = await readFile(targetClaudeMd, "utf-8");
+  } catch {
+  }
+  const toAppend = [];
+  for (const item of items) {
+    const raw = await readFile(join(claudemdDir, item.file), "utf-8");
+    const content = raw.replace(/^---\s*\n[\s\S]*?\n---\s*\n/, "").trim();
+    const headerMatch = content.match(/^#{1,2}\s+.+/m);
+    if (headerMatch) {
+      if (existing.includes(headerMatch[0])) continue;
+    }
+    toAppend.push(content);
+  }
+  if (toAppend.length === 0) return;
+  const appendContent = (existing.endsWith("\n") ? "" : "\n") + toAppend.join("\n\n") + "\n";
+  await writeFile(targetClaudeMd, existing + appendContent, "utf-8");
+}
+
+export {
+  installClaudemd
+};

package/dist/claudemd-KKQ2DL7P.js

@@ -0,0 +1,7 @@
+import {
+  installClaudemd
+} from "./chunk-SW3OJLHC.js";
+import "./chunk-5XOKKPAA.js";
+export {
+  installClaudemd
+};

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

@@ -1,14 +1,18 @@
 import {
   installMcps
 } from "./chunk-W63UKEIT.js";
+import {
+  installClaudemd
+} from "./chunk-SW3OJLHC.js";
 import {
   getAgents,
+  getClaudemdItems,
   getCommands,
   getHooks,
   getMcpServers,
   getRuleCategories,
   getSkills
-} from "./chunk-6B46AIFM.js";
+} from "./chunk-OLLOS3GG.js";
 import {
   installAgents
 } from "./chunk-EYY2IZ7N.js";
@@ -74,7 +78,8 @@ async function runCli() {
       { name: "Commands - Slash commands", value: "commands" },
       { name: "Hooks    - Post-tool hooks", value: "hooks" },
       { name: "Rules    - CLAUDE.md rules", value: "rules" },
-      { name: "MCPs     - MCP server configs", value: "mcps" }
+      { name: "MCPs     - MCP server configs", value: "mcps" },
+      { name: "ClaudeMd - Behavioral guidelines", value: "claudemd" }
     ]
   });
   if (selectedCategories.length === 0) {
@@ -89,8 +94,10 @@ async function runCli() {
     hooks: [],
     ruleCategories: [],
     mcps: [],
-    mcpEnvValues: /* @__PURE__ */ new Map()
+    mcpEnvValues: /* @__PURE__ */ new Map(),
+    claudemds: []
   };
+  const skippedMcps = /* @__PURE__ */ new Map();
   if (selectedCategories.includes("agents")) {
     const allAgents = await getAgents();
     plan.agents = await checkbox({
@@ -146,6 +153,17 @@ async function runCli() {
       }))
     });
   }
+  if (selectedCategories.includes("claudemd")) {
+    const allClaudemds = await getClaudemdItems();
+    plan.claudemds = await checkbox({
+      message: "Select claudemd items:",
+      choices: allClaudemds.map((c) => ({
+        name: `${chalk.bold(c.name.padEnd(35))} ${chalk.gray(c.description.slice(0, 55))}`,
+        value: c,
+        checked: false
+      }))
+    });
+  }
   if (selectedCategories.includes("mcps")) {
     const allMcps = await getMcpServers();
     plan.mcps = await checkbox({
@@ -161,14 +179,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"));
@@ -180,8 +213,9 @@ async function runCli() {
   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.mcps.length) console.log(`  MCPs    : ${plan.mcps.map((m) => m.name).join(", ")}`);
+  if (plan.claudemds.length) console.log(`  ClaudeMd: ${plan.claudemds.map((c) => c.name).join(", ")}`);
   console.log("");
-  const totalItems = plan.agents.length + plan.skills.length + plan.commands.length + plan.hooks.length + plan.ruleCategories.length + plan.mcps.length;
+  const totalItems = plan.agents.length + plan.skills.length + plan.commands.length + plan.hooks.length + plan.ruleCategories.length + plan.mcps.length + plan.claudemds.length;
   if (totalItems === 0) {
     console.log(chalk.yellow("  Nothing selected. Exiting."));
     return;
@@ -219,6 +253,10 @@ async function runCli() {
       spinner.text = "Installing MCP servers...";
       await installMcps(plan.mcps, plan.scope, plan.mcpEnvValues);
     }
+    if (plan.claudemds.length) {
+      spinner.text = "Installing claudemd...";
+      await installClaudemd(plan.claudemds, targetDir);
+    }
     spinner.succeed(chalk.green("Installation complete!"));
     console.log("");
     if (plan.agents.length) console.log(`  ${chalk.green("\u2713")} ${plan.agents.length} agent(s) \u2192 ${join(targetDir, "agents")}`);
@@ -227,7 +265,17 @@ async function runCli() {
     if (plan.hooks.length) console.log(`  ${chalk.green("\u2713")} ${plan.hooks.length} hook(s) \u2192 ${join(targetDir, "hooks")}`);
     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"}`);
+    if (plan.claudemds.length) console.log(`  ${chalk.green("\u2713")} ClaudeMd appended \u2192 ${join(targetDir, "CLAUDE.md")}`);
     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) {
@@ -49,33 +51,38 @@ Installing all to ${targetDir}...
       { getHooks },
       { getRuleCategories },
       { getMcpServers },
+      { getClaudemdItems },
       { installAgents },
       { installSkills },
       { installCommands },
       { installHooks },
       { installRules },
-      { installMcps }
+      { installMcps },
+      { installClaudemd }
     ] = await Promise.all([
-      import("./registry-EGXWYWWK.js"),
-      import("./registry-EGXWYWWK.js"),
-      import("./registry-EGXWYWWK.js"),
-      import("./registry-EGXWYWWK.js"),
-      import("./registry-EGXWYWWK.js"),
-      import("./registry-EGXWYWWK.js"),
+      import("./registry-BU55RMHU.js"),
+      import("./registry-BU55RMHU.js"),
+      import("./registry-BU55RMHU.js"),
+      import("./registry-BU55RMHU.js"),
+      import("./registry-BU55RMHU.js"),
+      import("./registry-BU55RMHU.js"),
+      import("./registry-BU55RMHU.js"),
       import("./agents-AEKT67A6.js"),
       import("./skills-ULMW3UCM.js"),
       import("./commands-P5LILVZ5.js"),
       import("./hooks-IIG2XK4I.js"),
       import("./rules-2CPBVNNJ.js"),
-      import("./mcps-67Q7TBGW.js")
+      import("./mcps-67Q7TBGW.js"),
+      import("./claudemd-KKQ2DL7P.js")
     ]);
-    const [agents, skills, commands, hooks, ruleCategories, mcps] = await Promise.all([
+    const [agents, skills, commands, hooks, ruleCategories, mcps, claudemds] = await Promise.all([
       getAgents(),
       getSkills(),
       getCommands(),
       getHooks(),
       getRuleCategories(),
-      getMcpServers()
+      getMcpServers(),
+      getClaudemdItems()
     ]);
     spinner.text = "Installing agents...";
     await installAgents(agents, targetDir);
@@ -90,6 +97,8 @@ Installing all to ${targetDir}...
     await installRules(ruleCategories.map((rc) => rc.category), claudeMd);
     spinner.text = "Installing MCP servers...";
     await installMcps(mcps, scope, /* @__PURE__ */ new Map());
+    spinner.text = "Installing claudemd...";
+    await installClaudemd(claudemds, targetDir);
     spinner.succeed(chalk.green("All items installed successfully!"));
     console.log(`
   ${chalk.green("\u2713")} ${agents.length} agents`);
@@ -97,7 +106,8 @@ Installing all to ${targetDir}...
     console.log(`  ${chalk.green("\u2713")} ${commands.length} commands`);
     console.log(`  ${chalk.green("\u2713")} ${hooks.length} hooks`);
     console.log(`  ${chalk.green("\u2713")} Rules (${ruleCategories.length} categories)`);
-    console.log(`  ${chalk.green("\u2713")} ${mcps.length} MCP servers
+    console.log(`  ${chalk.green("\u2713")} ${mcps.length} MCP servers`);
+    console.log(`  ${chalk.green("\u2713")} ${claudemds.length} claudemd item(s)
 `);
   } catch (err) {
     spinner.fail("Installation failed");
@@ -114,13 +124,18 @@ async function main() {
     printHelp();
     return;
   }
+  if (args.includes("--uninstall") || args.includes("-u")) {
+    const { runUninstallCli } = await import("./uninstall-cli-VCOZGDBM.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-D2Q5QUO7.js");
   await runCli();
 }
 main().catch((err) => {

package/dist/{registry-EGXWYWWK.js → registry-BU55RMHU.js}

@@ -1,14 +1,16 @@
 import {
   getAgents,
+  getClaudemdItems,
   getCommands,
   getHooks,
   getMcpServers,
   getRuleCategories,
   getSkills
-} from "./chunk-6B46AIFM.js";
+} from "./chunk-OLLOS3GG.js";
 import "./chunk-5XOKKPAA.js";
 export {
   getAgents,
+  getClaudemdItems,
   getCommands,
   getHooks,
   getMcpServers,

package/dist/uninstall-cli-VCOZGDBM.js

@@ -0,0 +1,651 @@
+import {
+  getAgents,
+  getClaudemdItems,
+  getCommands,
+  getHooks,
+  getMcpServers,
+  getRuleCategories,
+  getSkills
+} from "./chunk-OLLOS3GG.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 join9 } 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 getInstalledClaudemd(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 allItems = await getClaudemdItems();
+  const result = [];
+  for (const item of allItems) {
+    try {
+      const raw = await readFile(join(getAssetsDir(), "claudemd", item.file), "utf-8");
+      const itemContent = raw.replace(/^---\s*\n[\s\S]*?\n---\s*\n/, "");
+      const headerMatch = itemContent.match(/^(#{1,2}\s+.+)/m);
+      if (headerMatch && installedHeaders.has(headerMatch[1].trim())) {
+        result.push(item);
+      }
+    } catch {
+    }
+  }
+  return result;
+}
+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/uninstallers/claudemd.ts
+import { readFile as readFile5, writeFile as writeFile4, access as access8 } from "fs/promises";
+import { constants as constants8 } from "fs";
+import { join as join8 } from "path";
+async function uninstallClaudemd(items, targetDir) {
+  const claudeMdPath = join8(targetDir, "CLAUDE.md");
+  let existing = "";
+  try {
+    await access8(claudeMdPath, constants8.F_OK);
+    existing = await readFile5(claudeMdPath, "utf-8");
+  } catch {
+    return;
+  }
+  const headersToRemove = /* @__PURE__ */ new Set();
+  for (const item of items) {
+    try {
+      const raw = await readFile5(join8(getAssetsDir(), "claudemd", item.file), "utf-8");
+      const content = raw.replace(/^---\s*\n[\s\S]*?\n---\s*\n/, "");
+      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 writeFile4(claudeMdPath, cleaned, "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,
+    installedClaudemds
+  ] = await Promise.all([
+    getInstalledAgents(targetDir),
+    getInstalledSkills(targetDir),
+    getInstalledCommands(targetDir),
+    getInstalledHooks(targetDir),
+    getInstalledRuleCategories(targetDir),
+    getInstalledMcps(scope),
+    getInstalledClaudemd(targetDir)
+  ]);
+  const totalInstalled = installedAgents.length + installedSkills.length + installedCommands.length + installedHooks.length + installedRuleCategories.length + installedMcpNames.length + installedClaudemds.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"
+    });
+  if (installedClaudemds.length > 0)
+    availableCategories.push({
+      name: `ClaudeMd ${chalk.gray(`(${installedClaudemds.length} installed)`)}`,
+      value: "claudemd"
+    });
+  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: [],
+    claudemds: []
+  };
+  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
+      }))
+    });
+  }
+  if (selectedCategories.includes("claudemd") && installedClaudemds.length > 0) {
+    plan.claudemds = await checkbox({
+      message: "Select claudemd items to uninstall:",
+      choices: installedClaudemds.map((c) => ({
+        name: `${chalk.bold(c.name.padEnd(35))} ${chalk.gray(c.description.slice(0, 55))}`,
+        value: c,
+        checked: false
+      }))
+    });
+  }
+  const totalToRemove = plan.agents.length + plan.skills.length + plan.commands.length + plan.hooks.length + plan.ruleCategories.length + plan.mcpNames.length + plan.claudemds.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(", ")}`);
+  if (plan.claudemds.length) console.log(`  ClaudeMd: ${plan.claudemds.map((c) => c.name).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 = join9(targetDir, "CLAUDE.md");
+      await uninstallRules(plan.ruleCategories, claudeMd);
+    }
+    if (plan.mcpNames.length) {
+      spinner.text = "Removing MCP servers...";
+      await uninstallMcps(plan.mcpNames, scope);
+    }
+    if (plan.claudemds.length) {
+      spinner.text = "Removing claudemd...";
+      await uninstallClaudemd(plan.claudemds, targetDir);
+    }
+    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`);
+    if (plan.claudemds.length)
+      console.log(`  ${chalk.red("\u2717")} ClaudeMd removed (${plan.claudemds.map((c) => c.name).join(", ")})`);
+    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.1",
   "description": "Claude Code Harness Installer - Interactive CLI for installing Claude Code agents, skills, commands, hooks, rules, and MCP servers",
   "type": "module",
   "bin": {