skilldb 0.4.3 → 0.5.2

package/dist/cli.js

@@ -221,6 +221,8 @@ function truncate2(str, max) {
 }
 
 // src/commands/add.ts
+import fs3 from "fs";
+import path3 from "path";
 import pc3 from "picocolors";
 
 // src/cache.ts
@@ -306,9 +308,38 @@ function updateGitignore(cwd) {
 }
 
 // src/commands/add.ts
-async function addCommand(packName) {
+function getConfig() {
+  try {
+    return JSON.parse(fs3.readFileSync(path3.join(process.cwd(), ".skilldb", "config.json"), "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function getSkillsDir() {
+  const config = getConfig();
+  const dir = config.skillsDir;
+  if (dir && fs3.existsSync(path3.dirname(dir))) return dir;
+  const cwd = process.cwd();
+  if (fs3.existsSync(path3.join(cwd, ".claude"))) return path3.join(cwd, ".claude", "skills", "skilldb");
+  if (fs3.existsSync(path3.join(cwd, ".cursor"))) return path3.join(cwd, ".cursor", "rules", "skilldb");
+  if (fs3.existsSync(path3.join(cwd, ".codex"))) return path3.join(cwd, ".codex", "skills", "skilldb");
+  return null;
+}
+async function addCommand(packName, options) {
   const client = new SkillDBClient();
+  const target = options?.target || getConfig().installMode || "cache";
   console.log(pc3.bold(`Adding pack: ${packName}`));
+  const useSkillsDir = target === "skills-dir" || target === "hybrid";
+  const skillsDir = useSkillsDir ? getSkillsDir() : null;
+  if (useSkillsDir && !skillsDir) {
+    console.error(pc3.red('No IDE skills directory found. Run "skilldb init" first.'));
+    process.exit(1);
+  }
+  if (useSkillsDir && skillsDir) {
+    console.log(`Target: ${pc3.cyan(skillsDir)} ${pc3.dim("(IDE auto-loads these)")}`);
+  } else {
+    console.log(`Target: ${pc3.dim(".skilldb/skills/ (cache)")}`);
+  }
   initCache();
   try {
     const res = await client.list({ pack: packName, limit: 500, includeContent: true });
@@ -319,19 +350,40 @@ async function addCommand(packName) {
     let added = 0;
     let skipped = 0;
     for (const skill of res.skills) {
-      if (isCached(skill.id)) {
-        skipped++;
-        console.log(pc3.dim(`  skip  ${skill.id} (already cached)`));
-        continue;
+      if (!isCached(skill.id)) {
+        cacheSkill(skill);
+      }
+      if (useSkillsDir && skillsDir && skill.content) {
+        const packDir = path3.join(skillsDir, skill.pack);
+        fs3.mkdirSync(packDir, { recursive: true });
+        const skillFile = path3.join(packDir, skill.name + ".md");
+        if (fs3.existsSync(skillFile)) {
+          skipped++;
+          console.log(pc3.dim(`  skip  ${skill.id} (already installed)`));
+        } else {
+          fs3.writeFileSync(skillFile, skill.content);
+          added++;
+          console.log(pc3.green(`  add   ${skill.id}`) + pc3.dim(` \u2192 ${path3.relative(process.cwd(), skillFile)}`));
+        }
+      } else if (!useSkillsDir) {
+        if (isCached(skill.id)) {
+          skipped++;
+          console.log(pc3.dim(`  skip  ${skill.id} (already cached)`));
+        } else {
+          added++;
+          console.log(pc3.green(`  add   ${skill.id}`));
+        }
       }
-      const filePath = cacheSkill(skill);
-      added++;
-      console.log(pc3.green(`  add   ${skill.id}`) + pc3.dim(` \u2192 ${filePath}`));
     }
     console.log(
       `
 ${pc3.green(`${added} skill${added === 1 ? "" : "s"} added`)}` + (skipped > 0 ? pc3.dim(`, ${skipped} skipped`) : "")
     );
+    if (useSkillsDir && skillsDir) {
+      console.log(pc3.dim(`
+Skills installed to ${path3.relative(process.cwd(), skillsDir)}`));
+      console.log(pc3.dim("Your IDE will auto-load them \u2014 no CLAUDE.md changes needed."));
+    }
     if (res.skills.some((s) => !s.content)) {
       console.log(pc3.yellow("\nNote: Some skills were cached without content (metadata only)."));
       console.log(pc3.yellow('Run "skilldb login" with a Pro key to download full content.'));
@@ -403,8 +455,8 @@ async function infoCommand(id) {
 }
 
 // src/commands/init.ts
-import fs3 from "fs";
-import path3 from "path";
+import fs4 from "fs";
+import path4 from "path";
 import pc6 from "picocolors";
 import readline from "readline";
 function prompt(question) {
@@ -417,48 +469,38 @@ function prompt(question) {
   });
 }
 function detectIDE(cwd) {
-  if (fs3.existsSync(path3.join(cwd, "CLAUDE.md")) || fs3.existsSync(path3.join(cwd, ".claude"))) {
+  if (fs4.existsSync(path4.join(cwd, "CLAUDE.md")) || fs4.existsSync(path4.join(cwd, ".claude"))) {
     return {
       ide: "claude-code",
       label: "Claude Code",
-      configFile: path3.join(cwd, "CLAUDE.md")
+      skillsDir: path4.join(cwd, ".claude", "skills", "skilldb"),
+      configFile: path4.join(cwd, "CLAUDE.md")
     };
   }
-  if (fs3.existsSync(path3.join(cwd, ".cursor")) || fs3.existsSync(path3.join(cwd, ".cursorrules"))) {
+  if (fs4.existsSync(path4.join(cwd, ".cursor")) || fs4.existsSync(path4.join(cwd, ".cursorrules"))) {
     return {
       ide: "cursor",
       label: "Cursor",
-      configFile: fs3.existsSync(path3.join(cwd, ".cursorrules")) ? path3.join(cwd, ".cursorrules") : path3.join(cwd, ".cursor", "rules")
+      skillsDir: path4.join(cwd, ".cursor", "rules", "skilldb"),
+      configFile: fs4.existsSync(path4.join(cwd, ".cursorrules")) ? path4.join(cwd, ".cursorrules") : path4.join(cwd, ".cursor", "rules", "skilldb.md")
     };
   }
-  if (fs3.existsSync(path3.join(cwd, "codex.md")) || fs3.existsSync(path3.join(cwd, ".codex"))) {
+  if (fs4.existsSync(path4.join(cwd, "codex.md")) || fs4.existsSync(path4.join(cwd, ".codex"))) {
     return {
       ide: "codex",
       label: "Codex CLI",
-      configFile: path3.join(cwd, "codex.md")
+      skillsDir: path4.join(cwd, ".codex", "skills", "skilldb"),
+      configFile: path4.join(cwd, "codex.md")
     };
   }
   return null;
 }
-function getIntegrationSnippet(ide) {
-  const marker = "<!-- skilldb:start -->";
-  const endMarker = "<!-- skilldb:end -->";
-  const content = `
-## SkillDB Skills
-
-Local skills are available in \`.skilldb/skills/\`. Use them as reference when working on tasks.
-Search: \`skilldb search react server components\` (supports multiple words)
-Download a skill: \`skilldb get <pack>/<skill>\` (e.g. \`skilldb get software-skills/code-review\`)
-Download a full pack: \`skilldb add <pack>\`
-`.trim();
-  return `
-
-${marker}
-${content}
-${endMarker}
-`;
-}
-async function initCommand() {
+var IDE_SKILLS_DIRS = {
+  "claude-code": ".claude/skills/skilldb",
+  "cursor": ".cursor/rules/skilldb",
+  "codex": ".codex/skills/skilldb"
+};
+async function initCommand(options) {
   const cwd = process.cwd();
   console.log(pc6.bold("SkillDB Init\n"));
   let detection = detectIDE(cwd);
@@ -476,42 +518,131 @@ async function initCommand() {
       console.log(pc6.red("Invalid choice."));
       process.exit(1);
     }
-    const configFiles = {
-      "claude-code": path3.join(cwd, "CLAUDE.md"),
-      "cursor": path3.join(cwd, ".cursorrules"),
-      "codex": path3.join(cwd, "codex.md")
-    };
     detection = {
       ide,
       label: ide === "claude-code" ? "Claude Code" : ide === "cursor" ? "Cursor" : "Codex CLI",
-      configFile: configFiles[ide]
+      skillsDir: path4.join(cwd, IDE_SKILLS_DIRS[ide]),
+      configFile: path4.join(cwd, ide === "claude-code" ? "CLAUDE.md" : ide === "cursor" ? ".cursorrules" : "codex.md")
     };
   }
+  const targetArg = options?.target;
+  let mode;
+  if (targetArg === "mcp") mode = "mcp";
+  else if (targetArg === "skills-dir") mode = "skills-dir";
+  else if (targetArg === "claude-md" || targetArg === "config") mode = "claude-md";
+  else {
+    console.log(`
+Where should skills be loaded from?
+`);
+    console.log(`  1) ${pc6.cyan("MCP Server")}         ${pc6.dim("\u2014 agent fetches on demand, nothing added to files (recommended)")}`);
+    console.log(`  2) ${pc6.cyan("Skills directory")}    ${pc6.dim(`\u2014 installed to ${IDE_SKILLS_DIRS[detection.ide]}, auto-loaded by IDE`)}`);
+    console.log(`  3) ${pc6.cyan("Hybrid")}              ${pc6.dim("\u2014 MCP for search + skills dir for always-on core skills")}`);
+    console.log(`  4) ${pc6.cyan(path4.basename(detection.configFile))}       ${pc6.dim("\u2014 append to config file (legacy, can bloat)")}`);
+    const modeChoice = await prompt("\nChoice (1-4): ");
+    mode = { "1": "mcp", "2": "skills-dir", "3": "hybrid", "4": "claude-md" }[modeChoice] || "hybrid";
+  }
   const cacheDir = initCache(cwd);
-  console.log(`Created ${pc6.dim(cacheDir)}`);
+  console.log(`
+Created ${pc6.dim(cacheDir)}`);
   updateGitignore(cwd);
-  console.log(`Updated ${pc6.dim(".gitignore")}`);
-  const snippet = getIntegrationSnippet(detection.ide);
-  const configFile = detection.configFile;
-  let existing = "";
-  if (fs3.existsSync(configFile)) {
-    existing = fs3.readFileSync(configFile, "utf-8");
-  }
-  if (existing.includes("<!-- skilldb:start -->")) {
-    console.log(pc6.dim(`${path3.basename(configFile)} already has SkillDB integration.`));
-  } else {
-    const dir = path3.dirname(configFile);
-    if (!fs3.existsSync(dir)) {
-      fs3.mkdirSync(dir, { recursive: true });
+  if (mode === "mcp" || mode === "hybrid") {
+    console.log(`
+${pc6.cyan("MCP Server setup:")}`);
+    console.log(`  Install globally:  ${pc6.dim("npm install -g skilldb")}`);
+    if (detection.ide === "claude-code") {
+      console.log(`  Add to Claude:     ${pc6.dim("claude mcp add skilldb -- skilldb-mcp")}`);
+    } else if (detection.ide === "cursor") {
+      console.log(`  Add to Cursor:     ${pc6.dim("Add to .cursor/mcp.json:")}`);
+      console.log(pc6.dim(`    { "mcpServers": { "skilldb": { "command": "skilldb-mcp" } } }`));
+    } else {
+      console.log(`  Run:               ${pc6.dim("skilldb-mcp")}`);
+    }
+    const marker = "<!-- skilldb:start -->";
+    const snippet = `
+
+${marker}
+## SkillDB
+Skills available via MCP server. Use \`skilldb_search\` to find skills and \`skilldb_get\` to load them.
+<!-- skilldb:end -->
+`;
+    const configFile = detection.configFile;
+    let existing = "";
+    if (fs4.existsSync(configFile)) existing = fs4.readFileSync(configFile, "utf-8");
+    if (!existing.includes("skilldb:start")) {
+      fs4.mkdirSync(path4.dirname(configFile), { recursive: true });
+      fs4.writeFileSync(configFile, existing + snippet);
+      console.log(`
+  Added MCP reference to ${pc6.cyan(path4.basename(configFile))} ${pc6.dim("(2 lines, no bloat)")}`);
     }
-    fs3.writeFileSync(configFile, existing + snippet);
-    console.log(`Added SkillDB snippet to ${pc6.cyan(path3.basename(configFile))}`);
   }
-  console.log(pc6.green("\nDone! Next steps:"));
-  console.log(`  ${pc6.dim("$")} skilldb login                              ${pc6.dim("# save your API key")}`);
-  console.log(`  ${pc6.dim("$")} skilldb search react server components     ${pc6.dim("# multi-word search")}`);
-  console.log(`  ${pc6.dim("$")} skilldb get software-skills/code-review    ${pc6.dim("# download one skill")}`);
-  console.log(`  ${pc6.dim("$")} skilldb add game-design-skills             ${pc6.dim("# download full pack")}`);
+  if (mode === "skills-dir" || mode === "hybrid") {
+    const skillsDir = detection.skillsDir;
+    fs4.mkdirSync(skillsDir, { recursive: true });
+    console.log(`
+${pc6.cyan("Skills directory:")} ${pc6.dim(skillsDir)}`);
+    console.log(`  Skills installed here are auto-loaded by ${detection.label}.`);
+    console.log(`  Add skills:  ${pc6.dim("skilldb add software-skills --target skills-dir")}`);
+    fs4.writeFileSync(path4.join(skillsDir, "README.md"), `# SkillDB Skills
+
+Skills in this directory are automatically loaded by ${detection.label}.
+
+Manage with:
+- \`skilldb add <pack> --target skills-dir\`
+- \`skilldb remove <pack>\`
+- \`skilldb use <profile>\`
+
+Browse: https://skilldb.dev
+`);
+  }
+  if (mode === "claude-md") {
+    const marker = "<!-- skilldb:start -->";
+    const endMarker = "<!-- skilldb:end -->";
+    const content = `
+## SkillDB Skills
+
+Local skills: \`.skilldb/skills/\`. Use as reference for tasks.
+Search: \`skilldb search <query>\`
+Download: \`skilldb add <pack>\`
+`;
+    const snippet = `
+
+${marker}${content}${endMarker}
+`;
+    const configFile = detection.configFile;
+    let existing = "";
+    if (fs4.existsSync(configFile)) existing = fs4.readFileSync(configFile, "utf-8");
+    if (!existing.includes("skilldb:start")) {
+      fs4.mkdirSync(path4.dirname(configFile), { recursive: true });
+      fs4.writeFileSync(configFile, existing + snippet);
+      console.log(`
+Added SkillDB snippet to ${pc6.cyan(path4.basename(configFile))}`);
+    }
+    console.log(pc6.yellow("\n\u26A0  Config-file mode can bloat over time. Consider --target mcp or --target skills-dir."));
+  }
+  const configPath = path4.join(cwd, ".skilldb", "config.json");
+  let config = {};
+  try {
+    config = JSON.parse(fs4.readFileSync(configPath, "utf-8"));
+  } catch {
+  }
+  config.installMode = mode;
+  config.ide = detection.ide;
+  config.skillsDir = detection.skillsDir;
+  fs4.writeFileSync(configPath, JSON.stringify(config, null, 2));
+  console.log(pc6.green("\n\u2713 Done! Next steps:"));
+  if (mode === "mcp" || mode === "hybrid") {
+    console.log(`  ${pc6.dim("$")} npm install -g skilldb`);
+    if (detection.ide === "claude-code") {
+      console.log(`  ${pc6.dim("$")} claude mcp add skilldb -- skilldb-mcp`);
+    }
+    console.log(`  Then ask your agent: ${pc6.dim('"Search SkillDB for code review skills"')}`);
+  }
+  if (mode === "skills-dir" || mode === "hybrid") {
+    console.log(`  ${pc6.dim("$")} skilldb add software-skills --target skills-dir`);
+  }
+  if (mode === "claude-md") {
+    console.log(`  ${pc6.dim("$")} skilldb add software-skills`);
+  }
 }
 
 // src/commands/login.ts
@@ -552,8 +683,8 @@ async function loginCommand() {
 }
 
 // src/commands/use.ts
-import fs4 from "fs";
-import path4 from "path";
+import fs5 from "fs";
+import path5 from "path";
 import pc8 from "picocolors";
 var SKILLDB_DIR2 = ".skilldb";
 var ACTIVE_DIR = "active";
@@ -569,23 +700,23 @@ var PROFILES = {
   "ai-agent": ["ai-agent-skills", "prompt-engineering-skills", "llm-skills"]
 };
 function readConfig(cwd) {
-  const p = path4.join(cwd, SKILLDB_DIR2, CONFIG_FILE);
+  const p = path5.join(cwd, SKILLDB_DIR2, CONFIG_FILE);
   try {
-    return JSON.parse(fs4.readFileSync(p, "utf-8"));
+    return JSON.parse(fs5.readFileSync(p, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeConfig(cwd, config) {
-  const dir = path4.join(cwd, SKILLDB_DIR2);
-  if (!fs4.existsSync(dir)) fs4.mkdirSync(dir, { recursive: true });
-  fs4.writeFileSync(path4.join(dir, CONFIG_FILE), JSON.stringify(config, null, 2) + "\n");
+  const dir = path5.join(cwd, SKILLDB_DIR2);
+  if (!fs5.existsSync(dir)) fs5.mkdirSync(dir, { recursive: true });
+  fs5.writeFileSync(path5.join(dir, CONFIG_FILE), JSON.stringify(config, null, 2) + "\n");
 }
 function autoDetect(cwd) {
-  const has = (f) => fs4.existsSync(path4.join(cwd, f));
+  const has = (f) => fs5.existsSync(path5.join(cwd, f));
   let pkgDeps = [];
   try {
-    const pkg = JSON.parse(fs4.readFileSync(path4.join(cwd, "package.json"), "utf-8"));
+    const pkg = JSON.parse(fs5.readFileSync(path5.join(cwd, "package.json"), "utf-8"));
     pkgDeps = Object.keys({ ...pkg.dependencies, ...pkg.devDependencies });
   } catch {
   }
@@ -600,19 +731,19 @@ function autoDetect(cwd) {
   return "fullstack";
 }
 function activateProfile(cwd, profile) {
-  const activeDir = path4.join(cwd, SKILLDB_DIR2, ACTIVE_DIR);
-  if (fs4.existsSync(activeDir)) fs4.rmSync(activeDir, { recursive: true });
-  fs4.mkdirSync(activeDir, { recursive: true });
+  const activeDir = path5.join(cwd, SKILLDB_DIR2, ACTIVE_DIR);
+  if (fs5.existsSync(activeDir)) fs5.rmSync(activeDir, { recursive: true });
+  fs5.mkdirSync(activeDir, { recursive: true });
   const packs = PROFILES[profile] || [];
-  const skillsDir = path4.join(cwd, SKILLDB_DIR2, "skills");
+  const skillsDir = path5.join(cwd, SKILLDB_DIR2, "skills");
   let copied = 0;
   for (const pack of packs) {
-    const packDir = path4.join(skillsDir, pack);
-    if (!fs4.existsSync(packDir)) continue;
-    const destDir = path4.join(activeDir, pack);
-    fs4.mkdirSync(destDir, { recursive: true });
-    for (const file of fs4.readdirSync(packDir)) {
-      fs4.copyFileSync(path4.join(packDir, file), path4.join(destDir, file));
+    const packDir = path5.join(skillsDir, pack);
+    if (!fs5.existsSync(packDir)) continue;
+    const destDir = path5.join(activeDir, pack);
+    fs5.mkdirSync(destDir, { recursive: true });
+    for (const file of fs5.readdirSync(packDir)) {
+      fs5.copyFileSync(path5.join(packDir, file), path5.join(destDir, file));
       copied++;
     }
   }
@@ -647,8 +778,8 @@ async function useCommand(profile, options) {
     return;
   }
   if (profile === "none") {
-    const activeDir = path4.join(cwd, SKILLDB_DIR2, ACTIVE_DIR);
-    if (fs4.existsSync(activeDir)) fs4.rmSync(activeDir, { recursive: true });
+    const activeDir = path5.join(cwd, SKILLDB_DIR2, ACTIVE_DIR);
+    if (fs5.existsSync(activeDir)) fs5.rmSync(activeDir, { recursive: true });
     const config = readConfig(cwd);
     delete config.activeProfile;
     writeConfig(cwd, config);
@@ -669,42 +800,42 @@ async function useCommand(profile, options) {
 }
 
 // src/commands/budget.ts
-import fs5 from "fs";
-import path5 from "path";
+import fs6 from "fs";
+import path6 from "path";
 import pc9 from "picocolors";
 var SKILLDB_DIR3 = ".skilldb";
 var CONFIG_FILE2 = "config.json";
 var ACTIVE_DIR2 = "active";
 var TOKENS_PER_LINE = 10;
 function readConfig2(cwd) {
-  const p = path5.join(cwd, SKILLDB_DIR3, CONFIG_FILE2);
+  const p = path6.join(cwd, SKILLDB_DIR3, CONFIG_FILE2);
   try {
-    return JSON.parse(fs5.readFileSync(p, "utf-8"));
+    return JSON.parse(fs6.readFileSync(p, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeConfig2(cwd, config) {
-  const dir = path5.join(cwd, SKILLDB_DIR3);
-  if (!fs5.existsSync(dir)) fs5.mkdirSync(dir, { recursive: true });
-  fs5.writeFileSync(path5.join(dir, CONFIG_FILE2), JSON.stringify(config, null, 2) + "\n");
+  const dir = path6.join(cwd, SKILLDB_DIR3);
+  if (!fs6.existsSync(dir)) fs6.mkdirSync(dir, { recursive: true });
+  fs6.writeFileSync(path6.join(dir, CONFIG_FILE2), JSON.stringify(config, null, 2) + "\n");
 }
 function countActiveSkills(cwd) {
-  const activeDir = path5.join(cwd, SKILLDB_DIR3, ACTIVE_DIR2);
+  const activeDir = path6.join(cwd, SKILLDB_DIR3, ACTIVE_DIR2);
   const files = [];
   let totalLines = 0;
-  if (!fs5.existsSync(activeDir)) return { files, totalLines, totalTokens: 0 };
+  if (!fs6.existsSync(activeDir)) return { files, totalLines, totalTokens: 0 };
   function walk(dir) {
-    for (const entry of fs5.readdirSync(dir, { withFileTypes: true })) {
-      const full = path5.join(dir, entry.name);
+    for (const entry of fs6.readdirSync(dir, { withFileTypes: true })) {
+      const full = path6.join(dir, entry.name);
       if (entry.isDirectory()) {
         walk(full);
         continue;
       }
       if (!entry.name.endsWith(".md")) continue;
-      const content = fs5.readFileSync(full, "utf-8");
+      const content = fs6.readFileSync(full, "utf-8");
       const lines = content.split("\n").length;
-      files.push(path5.relative(path5.join(cwd, SKILLDB_DIR3), full));
+      files.push(path6.relative(path6.join(cwd, SKILLDB_DIR3), full));
       totalLines += lines;
     }
   }
@@ -733,14 +864,14 @@ async function budgetCommand(action, value) {
   }
   if (action === "optimize") {
     let walk2 = function(dir) {
-      for (const entry of fs5.readdirSync(dir, { withFileTypes: true })) {
-        const full = path5.join(dir, entry.name);
+      for (const entry of fs6.readdirSync(dir, { withFileTypes: true })) {
+        const full = path6.join(dir, entry.name);
         if (entry.isDirectory()) {
           walk2(full);
           continue;
         }
         if (!entry.name.endsWith(".md")) continue;
-        const lines = fs5.readFileSync(full, "utf-8").split("\n").length;
+        const lines = fs6.readFileSync(full, "utf-8").split("\n").length;
         skillFiles.push({ path: full, lines });
       }
     };
@@ -754,7 +885,7 @@ async function budgetCommand(action, value) {
       console.log(pc9.green("Already within budget. No changes needed."));
       return;
     }
-    const activeDir = path5.join(cwd, SKILLDB_DIR3, ACTIVE_DIR2);
+    const activeDir = path6.join(cwd, SKILLDB_DIR3, ACTIVE_DIR2);
     const skillFiles = [];
     walk2(activeDir);
     skillFiles.sort((a, b) => b.lines - a.lines);
@@ -762,10 +893,10 @@ async function budgetCommand(action, value) {
     let removed = 0;
     for (const sf of skillFiles) {
       if (current <= config.budget.max) break;
-      fs5.unlinkSync(sf.path);
+      fs6.unlinkSync(sf.path);
       current -= config.budget.unit === "tokens" ? sf.lines * TOKENS_PER_LINE : sf.lines;
       removed++;
-      console.log(pc9.yellow(`  removed ${path5.basename(sf.path)}`) + pc9.dim(` (${sf.lines} lines)`));
+      console.log(pc9.yellow(`  removed ${path6.basename(sf.path)}`) + pc9.dim(` (${sf.lines} lines)`));
     }
     console.log(pc9.green(`
 Optimized: removed ${removed} skill(s) to fit budget.`));
@@ -787,15 +918,15 @@ Optimized: removed ${removed} skill(s) to fit budget.`));
 }
 
 // src/commands/slim.ts
-import fs6 from "fs";
-import path6 from "path";
+import fs7 from "fs";
+import path7 from "path";
 import pc10 from "picocolors";
 var SKILLDB_DIR4 = ".skilldb";
 var ACTIVE_DIR3 = "active";
 var SLIM_DIR = "slim";
 var SKILLS_DIR2 = "skills";
 function ensureDir2(dir) {
-  if (!fs6.existsSync(dir)) fs6.mkdirSync(dir, { recursive: true });
+  if (!fs7.existsSync(dir)) fs7.mkdirSync(dir, { recursive: true });
 }
 function slimContent(content, ratio) {
   const lines = content.split("\n");
@@ -865,14 +996,14 @@ function slimContent(content, ratio) {
 function processDir(sourceDir, destDir, ratio) {
   ensureDir2(destDir);
   let count = 0;
-  for (const entry of fs6.readdirSync(sourceDir, { withFileTypes: true })) {
-    const srcPath = path6.join(sourceDir, entry.name);
+  for (const entry of fs7.readdirSync(sourceDir, { withFileTypes: true })) {
+    const srcPath = path7.join(sourceDir, entry.name);
     if (entry.isDirectory()) {
-      count += processDir(srcPath, path6.join(destDir, entry.name), ratio);
+      count += processDir(srcPath, path7.join(destDir, entry.name), ratio);
       continue;
     }
     if (!entry.name.endsWith(".md")) continue;
-    const content = fs6.readFileSync(srcPath, "utf-8");
+    const content = fs7.readFileSync(srcPath, "utf-8");
     const slimmed = slimContent(content, ratio);
     const footer = `
 
@@ -880,7 +1011,7 @@ function processDir(sourceDir, destDir, ratio) {
 *Full skill: \`skilldb get ${entry.name.replace(".md", "")}\`*
 `;
     ensureDir2(destDir);
-    fs6.writeFileSync(path6.join(destDir, entry.name), slimmed + footer);
+    fs7.writeFileSync(path7.join(destDir, entry.name), slimmed + footer);
     count++;
     const origLines = content.split("\n").length;
     const slimLines = slimmed.split("\n").length;
@@ -897,38 +1028,38 @@ async function slimCommand(pack, options) {
     console.error(pc10.red("Ratio must be between 0 and 1 (e.g. 0.3 for 30%)."));
     process.exit(1);
   }
-  const slimDir = path6.join(cwd, SKILLDB_DIR4, SLIM_DIR);
+  const slimDir = path7.join(cwd, SKILLDB_DIR4, SLIM_DIR);
   console.log(pc10.bold(`Generating slim versions (${Math.round(ratio * 100)}% ratio)
 `));
   let sourceDir;
   if (pack) {
-    sourceDir = path6.join(cwd, SKILLDB_DIR4, SKILLS_DIR2, pack);
-    if (!fs6.existsSync(sourceDir)) {
-      sourceDir = path6.join(cwd, SKILLDB_DIR4, ACTIVE_DIR3, pack);
+    sourceDir = path7.join(cwd, SKILLDB_DIR4, SKILLS_DIR2, pack);
+    if (!fs7.existsSync(sourceDir)) {
+      sourceDir = path7.join(cwd, SKILLDB_DIR4, ACTIVE_DIR3, pack);
     }
-    if (!fs6.existsSync(sourceDir)) {
+    if (!fs7.existsSync(sourceDir)) {
       console.error(pc10.red(`Pack "${pack}" not found in skills/ or active/.`));
       process.exit(1);
     }
   } else {
-    sourceDir = path6.join(cwd, SKILLDB_DIR4, ACTIVE_DIR3);
-    if (!fs6.existsSync(sourceDir)) {
-      sourceDir = path6.join(cwd, SKILLDB_DIR4, SKILLS_DIR2);
+    sourceDir = path7.join(cwd, SKILLDB_DIR4, ACTIVE_DIR3);
+    if (!fs7.existsSync(sourceDir)) {
+      sourceDir = path7.join(cwd, SKILLDB_DIR4, SKILLS_DIR2);
     }
   }
-  if (!fs6.existsSync(sourceDir)) {
+  if (!fs7.existsSync(sourceDir)) {
     console.error(pc10.red('No skills found. Install skills first with "skilldb add <pack>".'));
     process.exit(1);
   }
-  const destDir = pack ? path6.join(slimDir, pack) : slimDir;
+  const destDir = pack ? path7.join(slimDir, pack) : slimDir;
   const count = processDir(sourceDir, destDir, ratio);
   console.log(pc10.green(`
 ${count} skill(s) slimmed \u2192 .skilldb/slim/`));
 }
 
 // src/commands/recommend.ts
-import fs7 from "fs";
-import path7 from "path";
+import fs8 from "fs";
+import path8 from "path";
 import pc11 from "picocolors";
 var TECH_MAP = {
   react: ["react-patterns-skills", "web-polish-skills"],
@@ -954,7 +1085,7 @@ function scanProject(cwd) {
   const detected = [];
   const packs = /* @__PURE__ */ new Set();
   try {
-    const pkg = JSON.parse(fs7.readFileSync(path7.join(cwd, "package.json"), "utf-8"));
+    const pkg = JSON.parse(fs8.readFileSync(path8.join(cwd, "package.json"), "utf-8"));
     const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
     for (const dep of Object.keys(allDeps)) {
       const key = dep.replace(/^@[^/]+\//, "");
@@ -968,11 +1099,11 @@ function scanProject(cwd) {
     }
   } catch {
   }
-  if (fs7.existsSync(path7.join(cwd, "Dockerfile"))) {
+  if (fs8.existsSync(path8.join(cwd, "Dockerfile"))) {
     detected.push("docker");
     (TECH_MAP.docker || []).forEach((p) => packs.add(p));
   }
-  if (fs7.existsSync(path7.join(cwd, "tsconfig.json"))) {
+  if (fs8.existsSync(path8.join(cwd, "tsconfig.json"))) {
     detected.push("typescript");
     (TECH_MAP.typescript || []).forEach((p) => packs.add(p));
   }
@@ -1034,8 +1165,8 @@ async function recommendCommand(options) {
 }
 
 // src/commands/doctor.ts
-import fs8 from "fs";
-import path8 from "path";
+import fs9 from "fs";
+import path9 from "path";
 import pc12 from "picocolors";
 var SKILLDB_DIR5 = ".skilldb";
 var SKILLS_DIR3 = "skills";
@@ -1043,26 +1174,26 @@ var ACTIVE_DIR4 = "active";
 var CONFIG_FILE3 = "config.json";
 var TOKENS_PER_LINE2 = 10;
 function readConfig3(cwd) {
-  const p = path8.join(cwd, SKILLDB_DIR5, CONFIG_FILE3);
+  const p = path9.join(cwd, SKILLDB_DIR5, CONFIG_FILE3);
   try {
-    return JSON.parse(fs8.readFileSync(p, "utf-8"));
+    return JSON.parse(fs9.readFileSync(p, "utf-8"));
   } catch {
     return {};
   }
 }
 function collectFiles(dir) {
   const result = [];
-  if (!fs8.existsSync(dir)) return result;
+  if (!fs9.existsSync(dir)) return result;
   function walk(d) {
-    for (const entry of fs8.readdirSync(d, { withFileTypes: true })) {
-      const full = path8.join(d, entry.name);
+    for (const entry of fs9.readdirSync(d, { withFileTypes: true })) {
+      const full = path9.join(d, entry.name);
       if (entry.isDirectory()) {
         walk(full);
         continue;
       }
       if (!entry.name.endsWith(".md")) continue;
-      const lines = fs8.readFileSync(full, "utf-8").split("\n").length;
-      result.push({ name: path8.relative(dir, full), lines });
+      const lines = fs9.readFileSync(full, "utf-8").split("\n").length;
+      result.push({ name: path9.relative(dir, full), lines });
     }
   }
   walk(dir);
@@ -1074,29 +1205,29 @@ async function doctorCommand() {
   const config = readConfig3(cwd);
   let issues = 0;
   console.log(pc12.bold("SkillDB Doctor\n"));
-  const skilldbDir = path8.join(cwd, SKILLDB_DIR5);
-  if (!fs8.existsSync(skilldbDir)) {
+  const skilldbDir = path9.join(cwd, SKILLDB_DIR5);
+  if (!fs9.existsSync(skilldbDir)) {
     console.log(pc12.red('  [!] .skilldb/ not found. Run "skilldb init" first.'));
     return;
   }
   console.log(pc12.green("  [ok] .skilldb/ directory exists"));
   const installedIds = Object.keys(manifest.installed);
-  const skillsDir = path8.join(cwd, SKILLDB_DIR5, SKILLS_DIR3);
+  const skillsDir = path9.join(cwd, SKILLDB_DIR5, SKILLS_DIR3);
   const skillFiles = collectFiles(skillsDir);
   console.log(pc12.green(`  [ok] ${installedIds.length} skills in manifest, ${skillFiles.length} files on disk`));
   let orphaned = 0;
   for (const id of installedIds) {
     const [pack, file] = id.split("/");
     const name = file.replace(".md", "").replace(/[/\\:*?"<>|]/g, "-");
-    const filePath = path8.join(skillsDir, pack, `${name}.md`);
-    if (!fs8.existsSync(filePath)) {
+    const filePath = path9.join(skillsDir, pack, `${name}.md`);
+    if (!fs9.existsSync(filePath)) {
       orphaned++;
       if (orphaned <= 3) console.log(pc12.yellow(`  [!] Missing file for manifest entry: ${id}`));
     }
   }
   if (orphaned > 3) console.log(pc12.yellow(`  [!] ...and ${orphaned - 3} more missing files`));
   if (orphaned > 0) issues++;
-  const activeDir = path8.join(cwd, SKILLDB_DIR5, ACTIVE_DIR4);
+  const activeDir = path9.join(cwd, SKILLDB_DIR5, ACTIVE_DIR4);
   const activeFiles = collectFiles(activeDir);
   if (config.activeProfile) {
     console.log(pc12.green(`  [ok] Active profile: ${config.activeProfile} (${activeFiles.length} skills)`));
@@ -1133,8 +1264,8 @@ ${issues} issue(s) found. Run suggested commands to fix.`)
 }
 
 // src/commands/update.ts
-import fs9 from "fs";
-import path9 from "path";
+import fs10 from "fs";
+import path10 from "path";
 import pc13 from "picocolors";
 var SKILLDB_DIR6 = ".skilldb";
 var SKILLS_DIR4 = "skills";
@@ -1173,7 +1304,7 @@ async function updateCommand(pack) {
           console.log(pc13.dim(`  skip  ${id} (not found on remote)`));
           continue;
         }
-        const localPath = path9.join(
+        const localPath = path10.join(
           cwd,
           SKILLDB_DIR6,
           SKILLS_DIR4,
@@ -1182,7 +1313,7 @@ async function updateCommand(pack) {
         );
         let localContent = "";
         try {
-          localContent = fs9.readFileSync(localPath, "utf-8");
+          localContent = fs10.readFileSync(localPath, "utf-8");
         } catch {
         }
         if (remote.content && remote.content !== localContent) {
@@ -1211,19 +1342,19 @@ ${pc13.green(`${updated} updated`)}` + pc13.dim(`, ${unchanged} unchanged`) + (f
 }
 
 // src/commands/remove.ts
-import fs10 from "fs";
-import path10 from "path";
+import fs11 from "fs";
+import path11 from "path";
 import pc14 from "picocolors";
 var SKILLDB_DIR7 = ".skilldb";
 var SKILLS_DIR5 = "skills";
 var ACTIVE_DIR5 = "active";
 function collectActiveSkills(cwd) {
-  const activeDir = path10.join(cwd, SKILLDB_DIR7, ACTIVE_DIR5);
+  const activeDir = path11.join(cwd, SKILLDB_DIR7, ACTIVE_DIR5);
   const result = /* @__PURE__ */ new Set();
-  if (!fs10.existsSync(activeDir)) return result;
-  for (const pack of fs10.readdirSync(activeDir, { withFileTypes: true })) {
+  if (!fs11.existsSync(activeDir)) return result;
+  for (const pack of fs11.readdirSync(activeDir, { withFileTypes: true })) {
     if (!pack.isDirectory()) continue;
-    for (const file of fs10.readdirSync(path10.join(activeDir, pack.name))) {
+    for (const file of fs11.readdirSync(path11.join(activeDir, pack.name))) {
       if (file.endsWith(".md")) {
         result.add(`${pack.name}/${file}`);
       }
@@ -1234,12 +1365,12 @@ function collectActiveSkills(cwd) {
 function removeSkillFile(cwd, id) {
   const [pack, file] = id.split("/");
   const name = file.replace(".md", "").replace(/[/\\:*?"<>|]/g, "-");
-  const filePath = path10.join(cwd, SKILLDB_DIR7, SKILLS_DIR5, pack, `${name}.md`);
-  if (fs10.existsSync(filePath)) {
-    fs10.unlinkSync(filePath);
-    const packDir = path10.join(cwd, SKILLDB_DIR7, SKILLS_DIR5, pack);
-    if (fs10.existsSync(packDir) && fs10.readdirSync(packDir).length === 0) {
-      fs10.rmdirSync(packDir);
+  const filePath = path11.join(cwd, SKILLDB_DIR7, SKILLS_DIR5, pack, `${name}.md`);
+  if (fs11.existsSync(filePath)) {
+    fs11.unlinkSync(filePath);
+    const packDir = path11.join(cwd, SKILLDB_DIR7, SKILLS_DIR5, pack);
+    if (fs11.existsSync(packDir) && fs11.readdirSync(packDir).length === 0) {
+      fs11.rmdirSync(packDir);
     }
     return true;
   }
@@ -1314,32 +1445,32 @@ ${packIds.length} skill(s) from "${target}" removed.`));
 }
 
 // src/commands/export.ts
-import fs11 from "fs";
-import path11 from "path";
+import fs12 from "fs";
+import path12 from "path";
 import pc15 from "picocolors";
 var SKILLDB_DIR8 = ".skilldb";
 var ACTIVE_DIR6 = "active";
 var CONFIG_FILE4 = "config.json";
 function readConfig4(cwd) {
-  const p = path11.join(cwd, SKILLDB_DIR8, CONFIG_FILE4);
+  const p = path12.join(cwd, SKILLDB_DIR8, CONFIG_FILE4);
   try {
-    return JSON.parse(fs11.readFileSync(p, "utf-8"));
+    return JSON.parse(fs12.readFileSync(p, "utf-8"));
   } catch {
     return {};
   }
 }
 function collectActiveSkills2(cwd) {
-  const activeDir = path11.join(cwd, SKILLDB_DIR8, ACTIVE_DIR6);
+  const activeDir = path12.join(cwd, SKILLDB_DIR8, ACTIVE_DIR6);
   const result = [];
-  if (!fs11.existsSync(activeDir)) return result;
-  for (const pack of fs11.readdirSync(activeDir, { withFileTypes: true })) {
+  if (!fs12.existsSync(activeDir)) return result;
+  for (const pack of fs12.readdirSync(activeDir, { withFileTypes: true })) {
     if (!pack.isDirectory()) continue;
-    for (const file of fs11.readdirSync(path11.join(activeDir, pack.name))) {
+    for (const file of fs12.readdirSync(path12.join(activeDir, pack.name))) {
       if (file.endsWith(".md")) {
         result.push({
           pack: pack.name,
           name: file.replace(".md", ""),
-          path: path11.join(activeDir, pack.name, file)
+          path: path12.join(activeDir, pack.name, file)
         });
       }
     }
@@ -1387,7 +1518,7 @@ function exportProfile(cwd) {
     exportedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   const filename = ".skilldb-profile.json";
-  fs11.writeFileSync(path11.join(cwd, filename), JSON.stringify(profile, null, 2) + "\n");
+  fs12.writeFileSync(path12.join(cwd, filename), JSON.stringify(profile, null, 2) + "\n");
   console.log(pc15.green(`Exported profile to ${filename}`));
   console.log(pc15.dim('Share this file and import with "skilldb use --import .skilldb-profile.json"'));
 }
@@ -1398,7 +1529,7 @@ function exportInject(cwd, id) {
     console.error(pc15.red(`Skill "${id}" not found locally. Run "skilldb get ${id}" first.`));
     process.exit(1);
   }
-  const content = fs11.readFileSync(cachedPath, "utf-8");
+  const content = fs12.readFileSync(cachedPath, "utf-8");
   process.stdout.write(content);
 }
 async function exportCommand(format, target) {
@@ -1427,8 +1558,8 @@ async function exportCommand(format, target) {
 }
 
 // src/commands/stats.ts
-import fs12 from "fs";
-import path12 from "path";
+import fs13 from "fs";
+import path13 from "path";
 import pc16 from "picocolors";
 var SKILLDB_DIR9 = ".skilldb";
 var SKILLS_DIR6 = "skills";
@@ -1436,25 +1567,25 @@ var ACTIVE_DIR7 = "active";
 var CONFIG_FILE5 = "config.json";
 var TOKENS_PER_LINE3 = 10;
 function readConfig5(cwd) {
-  const p = path12.join(cwd, SKILLDB_DIR9, CONFIG_FILE5);
+  const p = path13.join(cwd, SKILLDB_DIR9, CONFIG_FILE5);
   try {
-    return JSON.parse(fs12.readFileSync(p, "utf-8"));
+    return JSON.parse(fs13.readFileSync(p, "utf-8"));
   } catch {
     return {};
   }
 }
 function countDir(dir) {
   const result = { files: 0, lines: 0, packs: /* @__PURE__ */ new Set(), categories: /* @__PURE__ */ new Set() };
-  if (!fs12.existsSync(dir)) return result;
-  for (const pack of fs12.readdirSync(dir, { withFileTypes: true })) {
+  if (!fs13.existsSync(dir)) return result;
+  for (const pack of fs13.readdirSync(dir, { withFileTypes: true })) {
     if (!pack.isDirectory()) continue;
     result.packs.add(pack.name);
     const cat = pack.name.replace(/-skills$/, "");
     result.categories.add(cat);
-    for (const file of fs12.readdirSync(path12.join(dir, pack.name))) {
+    for (const file of fs13.readdirSync(path13.join(dir, pack.name))) {
       if (!file.endsWith(".md")) continue;
       result.files++;
-      result.lines += fs12.readFileSync(path12.join(dir, pack.name, file), "utf-8").split("\n").length;
+      result.lines += fs13.readFileSync(path13.join(dir, pack.name, file), "utf-8").split("\n").length;
     }
   }
   return result;
@@ -1463,8 +1594,8 @@ async function statsCommand() {
   const cwd = process.cwd();
   const config = readConfig5(cwd);
   const manifest = readManifest(cwd);
-  const skillsDir = path12.join(cwd, SKILLDB_DIR9, SKILLS_DIR6);
-  const activeDir = path12.join(cwd, SKILLDB_DIR9, ACTIVE_DIR7);
+  const skillsDir = path13.join(cwd, SKILLDB_DIR9, SKILLS_DIR6);
+  const activeDir = path13.join(cwd, SKILLDB_DIR9, ACTIVE_DIR7);
   const installed = countDir(skillsDir);
   const active = countDir(activeDir);
   console.log(pc16.bold("SkillDB Stats\n"));
@@ -1502,8 +1633,8 @@ async function statsCommand() {
 }
 
 // src/commands/diff.ts
-import fs13 from "fs";
-import path13 from "path";
+import fs14 from "fs";
+import path14 from "path";
 import pc17 from "picocolors";
 var SKILLDB_DIR10 = ".skilldb";
 var SKILLS_DIR7 = "skills";
@@ -1564,15 +1695,15 @@ async function diffCommand(target) {
     if (!id.includes(".md")) id = id + ".md";
     const [pack, file] = id.split("/");
     const name = file.replace(".md", "").replace(/[/\\:*?"<>|]/g, "-");
-    const localPath = path13.join(cwd, SKILLDB_DIR10, SKILLS_DIR7, pack, `${name}.md`);
-    if (!fs13.existsSync(localPath)) {
+    const localPath = path14.join(cwd, SKILLDB_DIR10, SKILLS_DIR7, pack, `${name}.md`);
+    if (!fs14.existsSync(localPath)) {
       console.error(pc17.red(`Skill "${id}" not found locally.`));
       process.exit(1);
     }
     console.log(pc17.bold("Comparing with remote...\n"));
     try {
       const remote = await client.get(id);
-      const localContent = fs13.readFileSync(localPath, "utf-8");
+      const localContent = fs14.readFileSync(localPath, "utf-8");
       if (!remote.content) {
         console.log(pc17.yellow("Remote content not available (API key required)."));
         return;
@@ -1603,10 +1734,10 @@ async function diffCommand(target) {
         if (!remote?.content) continue;
         const [pack, file] = id.split("/");
         const name = file.replace(".md", "").replace(/[/\\:*?"<>|]/g, "-");
-        const localPath = path13.join(cwd, SKILLDB_DIR10, SKILLS_DIR7, pack, `${name}.md`);
+        const localPath = path14.join(cwd, SKILLDB_DIR10, SKILLS_DIR7, pack, `${name}.md`);
         let localContent = "";
         try {
-          localContent = fs13.readFileSync(localPath, "utf-8");
+          localContent = fs14.readFileSync(localPath, "utf-8");
         } catch {
           continue;
         }
@@ -1629,17 +1760,189 @@ ${pc17.green(`${upToDate} up to date`)}` + (changed > 0 ? pc17.yellow(`, ${chang
   }
 }
 
+// src/commands/purge.ts
+import fs15 from "fs";
+import path15 from "path";
+import pc18 from "picocolors";
+import readline3 from "readline";
+var SKILLDB_DIR11 = ".skilldb";
+var SKILLS_DIR8 = "skills";
+var ACTIVE_DIR8 = "active";
+var SLIM_DIR2 = "slim";
+function prompt3(question) {
+  const rl = readline3.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+function getDirectorySize(dir) {
+  if (!fs15.existsSync(dir)) return 0;
+  let size = 0;
+  for (const entry of fs15.readdirSync(dir, { withFileTypes: true })) {
+    const full = path15.join(dir, entry.name);
+    if (entry.isDirectory()) size += getDirectorySize(full);
+    else size += fs15.statSync(full).size;
+  }
+  return size;
+}
+function collectAllSkills(dir) {
+  const skills = [];
+  if (!fs15.existsSync(dir)) return skills;
+  for (const pack of fs15.readdirSync(dir, { withFileTypes: true })) {
+    if (!pack.isDirectory()) continue;
+    for (const file of fs15.readdirSync(path15.join(dir, pack.name))) {
+      if (file.endsWith(".md")) skills.push(`${pack.name}/${file}`);
+    }
+  }
+  return skills;
+}
+function collectActivePacks(cwd) {
+  const activeDir = path15.join(cwd, SKILLDB_DIR11, ACTIVE_DIR8);
+  const packs = /* @__PURE__ */ new Set();
+  if (!fs15.existsSync(activeDir)) return packs;
+  for (const entry of fs15.readdirSync(activeDir, { withFileTypes: true })) {
+    if (entry.isDirectory()) packs.add(entry.name);
+  }
+  return packs;
+}
+async function purgeCommand(options) {
+  const cwd = process.cwd();
+  const skillsDir = path15.join(cwd, SKILLDB_DIR11, SKILLS_DIR8);
+  const activeDir = path15.join(cwd, SKILLDB_DIR11, ACTIVE_DIR8);
+  const slimDir = path15.join(cwd, SKILLDB_DIR11, SLIM_DIR2);
+  if (!fs15.existsSync(path15.join(cwd, SKILLDB_DIR11))) {
+    console.log(pc18.red('No .skilldb/ directory found. Run "skilldb init" first.'));
+    process.exit(1);
+  }
+  const allSkills = collectAllSkills(skillsDir);
+  const activePacks = collectActivePacks(cwd);
+  const activeSkills = /* @__PURE__ */ new Set();
+  if (fs15.existsSync(activeDir)) {
+    for (const pack of fs15.readdirSync(activeDir, { withFileTypes: true })) {
+      if (!pack.isDirectory()) continue;
+      for (const file of fs15.readdirSync(path15.join(activeDir, pack.name))) {
+        if (file.endsWith(".md")) activeSkills.add(`${pack.name}/${file}`);
+      }
+    }
+  }
+  const inactiveSkills = allSkills.filter((s) => !activeSkills.has(s));
+  const slimSkills = collectAllSkills(slimDir);
+  const totalSize = getDirectorySize(path15.join(cwd, SKILLDB_DIR11));
+  const skillsSize = getDirectorySize(skillsDir);
+  const slimSize = getDirectorySize(slimDir);
+  console.log(pc18.bold("\nSkillDB Purge\n"));
+  console.log(`  Total skills cached:  ${pc18.cyan(String(allSkills.length))}`);
+  console.log(`  Active skills:        ${pc18.green(String(activeSkills.size))}`);
+  console.log(`  Inactive skills:      ${pc18.yellow(String(inactiveSkills.length))}`);
+  console.log(`  Slim summaries:       ${pc18.dim(String(slimSkills.length))}`);
+  console.log(`  Total disk usage:     ${pc18.cyan((totalSize / 1024).toFixed(0) + " KB")}`);
+  console.log();
+  if (allSkills.length === 0 && slimSkills.length === 0) {
+    console.log(pc18.dim("Nothing to purge."));
+    return;
+  }
+  const stats = { skillsRemoved: 0, packsRemoved: 0, slimRemoved: 0, bytesFreed: 0, activeKept: activeSkills.size };
+  let toPurge = [];
+  let purgeSlim = options?.slim || options?.all || false;
+  if (options?.all) {
+    toPurge = [...allSkills];
+    purgeSlim = true;
+    console.log(pc18.red(`Will remove ALL ${allSkills.length} cached skills + ${slimSkills.length} slim summaries`));
+  } else if (options?.inactive) {
+    toPurge = inactiveSkills;
+    console.log(pc18.yellow(`Will remove ${inactiveSkills.length} inactive skills (keeping ${activeSkills.size} active)`));
+  } else {
+    toPurge = inactiveSkills;
+    purgeSlim = true;
+    console.log(pc18.yellow(`Will remove ${inactiveSkills.length} inactive skills + ${slimSkills.length} slim summaries`));
+    console.log(pc18.green(`  Keeping ${activeSkills.size} active skills`));
+  }
+  if (toPurge.length === 0 && !purgeSlim) {
+    console.log(pc18.dim("\nNothing to purge \u2014 all skills are active."));
+    return;
+  }
+  if (!options?.force && !options?.dryRun) {
+    const answer = await prompt3(`
+  Continue? (y/N) `);
+    if (answer.toLowerCase() !== "y") {
+      console.log(pc18.dim("Cancelled."));
+      return;
+    }
+  }
+  if (options?.dryRun) {
+    console.log(pc18.dim("\n  (Dry run \u2014 no files will be deleted)\n"));
+    for (const skill of toPurge.slice(0, 20)) {
+      console.log(pc18.dim(`  would remove: ${skill}`));
+    }
+    if (toPurge.length > 20) console.log(pc18.dim(`  ... and ${toPurge.length - 20} more`));
+    return;
+  }
+  const manifest = readManifest(cwd);
+  for (const skillId of toPurge) {
+    const [pack, file] = skillId.split("/");
+    const filePath = path15.join(skillsDir, pack, file);
+    if (fs15.existsSync(filePath)) {
+      stats.bytesFreed += fs15.statSync(filePath).size;
+      fs15.unlinkSync(filePath);
+      stats.skillsRemoved++;
+    }
+    if (manifest.installed[skillId]) {
+      delete manifest.installed[skillId];
+    }
+    const packDir = path15.join(skillsDir, pack);
+    if (fs15.existsSync(packDir) && fs15.readdirSync(packDir).length === 0) {
+      fs15.rmdirSync(packDir);
+      stats.packsRemoved++;
+    }
+  }
+  if (purgeSlim && fs15.existsSync(slimDir)) {
+    for (const pack of fs15.readdirSync(slimDir, { withFileTypes: true })) {
+      if (!pack.isDirectory()) continue;
+      const packPath = path15.join(slimDir, pack.name);
+      for (const file of fs15.readdirSync(packPath)) {
+        const filePath = path15.join(packPath, file);
+        stats.bytesFreed += fs15.statSync(filePath).size;
+        fs15.unlinkSync(filePath);
+        stats.slimRemoved++;
+      }
+      if (fs15.readdirSync(packPath).length === 0) fs15.rmdirSync(packPath);
+    }
+  }
+  if (options?.all && fs15.existsSync(activeDir)) {
+    for (const pack of fs15.readdirSync(activeDir, { withFileTypes: true })) {
+      if (!pack.isDirectory()) continue;
+      const packPath = path15.join(activeDir, pack.name);
+      for (const file of fs15.readdirSync(packPath)) {
+        fs15.unlinkSync(path15.join(packPath, file));
+      }
+      fs15.rmdirSync(packPath);
+    }
+    stats.activeKept = 0;
+  }
+  writeManifest(cwd, manifest);
+  console.log(pc18.green(`
+  \u2713 Purge complete`));
+  console.log(`    Skills removed:  ${stats.skillsRemoved}`);
+  console.log(`    Slim removed:    ${stats.slimRemoved}`);
+  console.log(`    Packs cleaned:   ${stats.packsRemoved}`);
+  console.log(`    Space freed:     ${(stats.bytesFreed / 1024).toFixed(0)} KB`);
+  console.log(`    Active kept:     ${stats.activeKept}`);
+}
+
 // src/cli.ts
 var program = new Command();
 program.name("skilldb").description("SkillDB CLI \u2014 discover, install, and manage AI agent skills").version("0.3.0");
-program.command("init").description("Initialize SkillDB in this project (detect IDE, create .skilldb/)").action(initCommand);
+program.command("init").description("Initialize SkillDB in this project (detect IDE, choose install mode)").option("-t, --target <mode>", "Install mode: mcp, skills-dir, claude-md, hybrid").action((opts) => initCommand(opts));
 program.command("login").description("Save your SkillDB API key").action(loginCommand);
 program.command("search <query...>").description("Search skills by keyword(s)").option("-c, --category <name>", "Filter by category").option("-l, --limit <n>", "Max results", "20").action((queryParts, options) => {
   searchCommand(queryParts.join(" "), options);
 });
 program.command("list").description("List skills, optionally filtered").option("-c, --category <name>", "Filter by category").option("-p, --pack <name>", "Filter by pack").option("-l, --limit <n>", "Max results", "50").action(listCommand);
 program.command("get <id>").description('Download a single skill to .skilldb/skills/ (e.g. "software-skills/code-review")').action(getCommand);
-program.command("add <pack>").description("Download an entire skill pack to local .skilldb/skills/ cache").action(addCommand);
+program.command("add <pack>").description("Download skills (use --target to choose where)").option("-t, --target <mode>", "Where to install: cache (default), skills-dir, hybrid").action((pack, opts) => addCommand(pack, opts));
 program.command("info <id>").description('Show metadata and preview for a skill (e.g. "software-skills/code-review")').action(infoCommand);
 program.command("use [profile]").description("Activate a skill profile (frontend, backend, devops, security, data, fullstack, mobile, ai-agent, auto, none)").option("--list", "List available profiles").option("--current", "Show active profile").action((profile, options) => {
   if (!profile && !options.list && !options.current) {
@@ -1668,5 +1971,8 @@ program.command("stats").description("Show local statistics and coverage").actio
 program.command("diff [target]").description("Compare local skills with latest remote versions").action((target) => {
   diffCommand(target);
 });
+program.command("purge").description("Remove cached skills to free disk space").option("-a, --all", "Remove ALL cached skills (including active)").option("-i, --inactive", "Remove only inactive skills").option("-s, --slim", "Also remove slim summaries").option("-n, --dry-run", "Show what would be removed without deleting").option("-f, --force", "Skip confirmation prompt").action((opts) => {
+  purgeCommand(opts);
+});
 program.parse();
 //# sourceMappingURL=cli.js.map