skilldb 0.1.4 → 0.2.0

package/dist/cli.js

@@ -105,8 +105,9 @@ var SkillDBClient = class {
   /** Validate that the configured API key works. */
   async validate() {
     try {
-      await this.list({ limit: 1 });
-      return true;
+      const url = `${this.baseUrl}/keys/usage`;
+      const res = await fetch(url, { headers: this.headers() });
+      return res.ok;
     } catch {
       return false;
     }
@@ -433,9 +434,9 @@ function getIntegrationSnippet(ide) {
 ## 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>\`
-Search skills: \`skilldb search <query>\`
 `.trim();
   return `
 
@@ -495,7 +496,7 @@ async function initCommand() {
   }
   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 solana                      ${pc6.dim("# find skills")}`);
+  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")}`);
 }
@@ -537,9 +538,1087 @@ async function loginCommand() {
   }
 }
 
+// src/commands/use.ts
+import fs4 from "fs";
+import path4 from "path";
+import pc8 from "picocolors";
+var SKILLDB_DIR2 = ".skilldb";
+var ACTIVE_DIR = "active";
+var CONFIG_FILE = "config.json";
+var PROFILES = {
+  frontend: ["react-patterns-skills", "web-polish-skills", "typescript-skills", "css-skills"],
+  backend: ["software-skills", "api-design-skills", "database-skills", "nodejs-skills"],
+  devops: ["devops-skills", "docker-skills", "ci-cd-skills", "infrastructure-skills"],
+  security: ["security-skills", "appsec-skills", "auth-skills"],
+  data: ["data-engineering-skills", "sql-skills", "analytics-skills"],
+  fullstack: ["react-patterns-skills", "software-skills", "typescript-skills", "api-design-skills"],
+  mobile: ["react-native-skills", "mobile-skills", "ios-skills", "android-skills"],
+  "ai-agent": ["ai-agent-skills", "prompt-engineering-skills", "llm-skills"]
+};
+function readConfig(cwd) {
+  const p = path4.join(cwd, SKILLDB_DIR2, CONFIG_FILE);
+  try {
+    return JSON.parse(fs4.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");
+}
+function autoDetect(cwd) {
+  const has = (f) => fs4.existsSync(path4.join(cwd, f));
+  let pkgDeps = [];
+  try {
+    const pkg = JSON.parse(fs4.readFileSync(path4.join(cwd, "package.json"), "utf-8"));
+    pkgDeps = Object.keys({ ...pkg.dependencies, ...pkg.devDependencies });
+  } catch {
+  }
+  if (pkgDeps.some((d) => ["react-native", "expo"].includes(d))) return "mobile";
+  if (pkgDeps.some((d) => ["react", "next", "vue", "svelte", "angular"].includes(d))) {
+    if (pkgDeps.some((d) => ["express", "fastify", "nestjs", "prisma"].includes(d))) return "fullstack";
+    return "frontend";
+  }
+  if (has("Dockerfile") || has("docker-compose.yml") || has(".github/workflows")) return "devops";
+  if (pkgDeps.some((d) => ["langchain", "openai", "@anthropic-ai/sdk"].includes(d))) return "ai-agent";
+  if (pkgDeps.some((d) => ["express", "fastify", "koa", "nestjs"].includes(d))) return "backend";
+  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 packs = PROFILES[profile] || [];
+  const skillsDir = path4.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));
+      copied++;
+    }
+  }
+  const config = readConfig(cwd);
+  config.activeProfile = profile;
+  writeConfig(cwd, config);
+  console.log(pc8.green(`Profile "${profile}" activated`) + pc8.dim(` (${copied} skills in .skilldb/active/)`));
+  if (copied === 0) {
+    console.log(pc8.yellow("No matching skills found locally. Install packs first:"));
+    for (const pack of packs.slice(0, 3)) {
+      console.log(pc8.dim(`  skilldb add ${pack}`));
+    }
+  }
+}
+async function useCommand(profile, options) {
+  const cwd = process.cwd();
+  if (options.list) {
+    console.log(pc8.bold("Available profiles:\n"));
+    for (const [name, packs] of Object.entries(PROFILES)) {
+      console.log(`  ${pc8.cyan(name.padEnd(12))} ${pc8.dim(packs.join(", "))}`);
+    }
+    console.log(pc8.dim('\nUse "skilldb use auto" to auto-detect from project files.'));
+    return;
+  }
+  if (options.current) {
+    const config = readConfig(cwd);
+    if (config.activeProfile) {
+      console.log(`Active profile: ${pc8.cyan(config.activeProfile)}`);
+    } else {
+      console.log(pc8.dim('No active profile. Run "skilldb use <profile>" to activate.'));
+    }
+    return;
+  }
+  if (profile === "none") {
+    const activeDir = path4.join(cwd, SKILLDB_DIR2, ACTIVE_DIR);
+    if (fs4.existsSync(activeDir)) fs4.rmSync(activeDir, { recursive: true });
+    const config = readConfig(cwd);
+    delete config.activeProfile;
+    writeConfig(cwd, config);
+    console.log(pc8.green("Profile deactivated. Active directory cleared."));
+    return;
+  }
+  if (profile === "auto") {
+    const detected = autoDetect(cwd);
+    console.log(pc8.dim(`Auto-detected profile: ${detected}`));
+    activateProfile(cwd, detected);
+    return;
+  }
+  if (!PROFILES[profile]) {
+    console.error(pc8.red(`Unknown profile "${profile}". Use --list to see available profiles.`));
+    process.exit(1);
+  }
+  activateProfile(cwd, profile);
+}
+
+// src/commands/budget.ts
+import fs5 from "fs";
+import path5 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);
+  try {
+    return JSON.parse(fs5.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");
+}
+function countActiveSkills(cwd) {
+  const activeDir = path5.join(cwd, SKILLDB_DIR3, ACTIVE_DIR2);
+  const files = [];
+  let totalLines = 0;
+  if (!fs5.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);
+      if (entry.isDirectory()) {
+        walk(full);
+        continue;
+      }
+      if (!entry.name.endsWith(".md")) continue;
+      const content = fs5.readFileSync(full, "utf-8");
+      const lines = content.split("\n").length;
+      files.push(path5.relative(path5.join(cwd, SKILLDB_DIR3), full));
+      totalLines += lines;
+    }
+  }
+  walk(activeDir);
+  return { files, totalLines, totalTokens: totalLines * TOKENS_PER_LINE };
+}
+function parseBudget(value) {
+  const lower = value.toLowerCase();
+  if (lower.endsWith("k")) {
+    return { max: parseInt(lower) * 1e3, unit: "tokens" };
+  }
+  const num = parseInt(value);
+  if (num > 1e4) return { max: num, unit: "tokens" };
+  return { max: num, unit: "lines" };
+}
+async function budgetCommand(action, value) {
+  const cwd = process.cwd();
+  const config = readConfig2(cwd);
+  const usage = countActiveSkills(cwd);
+  if (action === "set" && value) {
+    const budget = parseBudget(value);
+    config.budget = budget;
+    writeConfig2(cwd, config);
+    console.log(pc9.green(`Budget set to ${budget.max.toLocaleString()} ${budget.unit}`));
+    return;
+  }
+  if (action === "optimize") {
+    let walk2 = function(dir) {
+      for (const entry of fs5.readdirSync(dir, { withFileTypes: true })) {
+        const full = path5.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;
+        skillFiles.push({ path: full, lines });
+      }
+    };
+    var walk = walk2;
+    if (!config.budget) {
+      console.error(pc9.red('No budget set. Run "skilldb budget set <value>" first.'));
+      process.exit(1);
+    }
+    const budgetValue = config.budget.unit === "tokens" ? usage.totalTokens : usage.totalLines;
+    if (budgetValue <= config.budget.max) {
+      console.log(pc9.green("Already within budget. No changes needed."));
+      return;
+    }
+    const activeDir = path5.join(cwd, SKILLDB_DIR3, ACTIVE_DIR2);
+    const skillFiles = [];
+    walk2(activeDir);
+    skillFiles.sort((a, b) => b.lines - a.lines);
+    let current = config.budget.unit === "tokens" ? usage.totalTokens : usage.totalLines;
+    let removed = 0;
+    for (const sf of skillFiles) {
+      if (current <= config.budget.max) break;
+      fs5.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.green(`
+Optimized: removed ${removed} skill(s) to fit budget.`));
+    return;
+  }
+  console.log(pc9.bold("Budget Status\n"));
+  console.log(`  ${pc9.cyan("Active skills:")}  ${usage.files.length}`);
+  console.log(`  ${pc9.cyan("Total lines:")}    ${usage.totalLines.toLocaleString()}`);
+  console.log(`  ${pc9.cyan("Est. tokens:")}    ${usage.totalTokens.toLocaleString()}`);
+  if (config.budget) {
+    const budgetValue = config.budget.unit === "tokens" ? usage.totalTokens : usage.totalLines;
+    const pct = Math.round(budgetValue / config.budget.max * 100);
+    const color = pct > 100 ? pc9.red : pct > 80 ? pc9.yellow : pc9.green;
+    console.log(`  ${pc9.cyan("Budget:")}         ${config.budget.max.toLocaleString()} ${config.budget.unit}`);
+    console.log(`  ${pc9.cyan("Usage:")}          ${color(`${pct}%`)}`);
+  } else {
+    console.log(pc9.dim('\n  No budget set. Use "skilldb budget set <value>" to set one.'));
+  }
+}
+
+// src/commands/slim.ts
+import fs6 from "fs";
+import path6 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 });
+}
+function slimContent(content, ratio) {
+  const lines = content.split("\n");
+  const kept = [];
+  let inCodeBlock = false;
+  let codeBlockLines = 0;
+  let skipExplanation = false;
+  for (const line of lines) {
+    if (line.startsWith("#")) {
+      kept.push(line);
+      skipExplanation = false;
+      continue;
+    }
+    if (line.startsWith("```")) {
+      if (!inCodeBlock) {
+        inCodeBlock = true;
+        codeBlockLines = 0;
+        kept.push(line);
+      } else {
+        inCodeBlock = false;
+        kept.push(line);
+      }
+      continue;
+    }
+    if (inCodeBlock) {
+      codeBlockLines++;
+      if (codeBlockLines <= 15) kept.push(line);
+      else if (codeBlockLines === 16) kept.push("  // ... (trimmed)");
+      continue;
+    }
+    if (line.match(/^[-*]\s+\[[ x]\]/)) {
+      kept.push(line);
+      continue;
+    }
+    if (line.match(/^[-*]\s+\*\*/)) {
+      kept.push(line);
+      continue;
+    }
+    if (line.match(/^\d+\.\s+\*\*/)) {
+      kept.push(line);
+      continue;
+    }
+    if (line.match(/^[-*]\s+/) && line.length < 120) {
+      kept.push(line);
+      continue;
+    }
+    if (line.match(/^\d+\.\s+/) && line.length < 120) {
+      kept.push(line);
+      continue;
+    }
+    if (line.match(/^\*\*.+\*\*/)) {
+      kept.push(line);
+      continue;
+    }
+    if (line.trim() === "") {
+      if (!skipExplanation) kept.push(line);
+      continue;
+    }
+    if (kept.length / Math.max(lines.length, 1) < ratio) {
+      kept.push(line);
+    } else {
+      skipExplanation = true;
+    }
+  }
+  return kept.join("\n");
+}
+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);
+    if (entry.isDirectory()) {
+      count += processDir(srcPath, path6.join(destDir, entry.name), ratio);
+      continue;
+    }
+    if (!entry.name.endsWith(".md")) continue;
+    const content = fs6.readFileSync(srcPath, "utf-8");
+    const slimmed = slimContent(content, ratio);
+    const footer = `
+
+---
+*Full skill: \`skilldb get ${entry.name.replace(".md", "")}\`*
+`;
+    ensureDir2(destDir);
+    fs6.writeFileSync(path6.join(destDir, entry.name), slimmed + footer);
+    count++;
+    const origLines = content.split("\n").length;
+    const slimLines = slimmed.split("\n").length;
+    console.log(
+      pc10.green(`  slim  ${entry.name}`) + pc10.dim(` ${origLines} \u2192 ${slimLines} lines (${Math.round(slimLines / origLines * 100)}%)`)
+    );
+  }
+  return count;
+}
+async function slimCommand(pack, options) {
+  const cwd = process.cwd();
+  const ratio = options?.ratio ? parseFloat(options.ratio) : 0.3;
+  if (ratio <= 0 || ratio >= 1) {
+    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);
+  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);
+    }
+    if (!fs6.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);
+    }
+  }
+  if (!fs6.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 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 pc11 from "picocolors";
+var TECH_MAP = {
+  react: ["react-patterns-skills", "web-polish-skills"],
+  next: ["react-patterns-skills", "web-polish-skills", "nextjs-skills"],
+  vue: ["vue-skills", "web-polish-skills"],
+  angular: ["angular-skills", "web-polish-skills"],
+  express: ["software-skills", "api-design-skills", "nodejs-skills"],
+  fastify: ["software-skills", "api-design-skills", "nodejs-skills"],
+  nestjs: ["software-skills", "api-design-skills", "nodejs-skills"],
+  prisma: ["database-skills", "software-skills"],
+  typescript: ["typescript-skills", "software-skills"],
+  tailwindcss: ["css-skills", "web-polish-skills"],
+  docker: ["devops-skills", "docker-skills"],
+  openai: ["ai-agent-skills", "prompt-engineering-skills"],
+  "@anthropic-ai/sdk": ["ai-agent-skills", "prompt-engineering-skills"],
+  langchain: ["ai-agent-skills", "llm-skills"],
+  "react-native": ["mobile-skills", "react-native-skills"],
+  expo: ["mobile-skills", "react-native-skills"],
+  jest: ["testing-skills", "software-skills"],
+  vitest: ["testing-skills", "software-skills"]
+};
+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 allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+    for (const dep of Object.keys(allDeps)) {
+      const key = dep.replace(/^@[^/]+\//, "");
+      if (TECH_MAP[dep]) {
+        detected.push(dep);
+        TECH_MAP[dep].forEach((p) => packs.add(p));
+      } else if (TECH_MAP[key]) {
+        detected.push(key);
+        TECH_MAP[key].forEach((p) => packs.add(p));
+      }
+    }
+  } catch {
+  }
+  if (fs7.existsSync(path7.join(cwd, "Dockerfile"))) {
+    detected.push("docker");
+    (TECH_MAP.docker || []).forEach((p) => packs.add(p));
+  }
+  if (fs7.existsSync(path7.join(cwd, "tsconfig.json"))) {
+    detected.push("typescript");
+    (TECH_MAP.typescript || []).forEach((p) => packs.add(p));
+  }
+  packs.add("software-skills");
+  return { detected, packs };
+}
+async function recommendCommand(options) {
+  const cwd = process.cwd();
+  const manifest = readManifest(cwd);
+  const installed = new Set(Object.keys(manifest.installed).map((id) => id.split("/")[0]));
+  console.log(pc11.bold("Scanning project...\n"));
+  const { detected, packs } = scanProject(cwd);
+  if (detected.length > 0) {
+    console.log(pc11.dim("Detected technologies: ") + detected.join(", "));
+    console.log();
+  }
+  const missing = [...packs].filter((p) => !installed.has(p));
+  const existing = [...packs].filter((p) => installed.has(p));
+  if (existing.length > 0) {
+    console.log(pc11.green("Already installed:"));
+    for (const p of existing) {
+      console.log(pc11.dim(`  + ${p}`));
+    }
+    console.log();
+  }
+  if (missing.length === 0) {
+    console.log(pc11.green("You have all recommended packs installed!"));
+    return;
+  }
+  console.log(pc11.yellow("Recommended packs to install:"));
+  for (const p of missing) {
+    console.log(`  ${pc11.cyan(p)}`);
+  }
+  if (!options.install) {
+    console.log(pc11.dim('\nRun "skilldb recommend --install" to auto-install all.'));
+    return;
+  }
+  console.log(pc11.bold("\nInstalling recommended packs...\n"));
+  const client = new SkillDBClient();
+  initCache(cwd);
+  for (const pack of missing) {
+    try {
+      const res = await client.list({ pack, limit: 500, includeContent: true });
+      if (res.skills.length === 0) {
+        console.log(pc11.dim(`  skip  ${pack} (not found)`));
+        continue;
+      }
+      let added = 0;
+      for (const skill of res.skills) {
+        cacheSkill(skill, cwd);
+        added++;
+      }
+      console.log(pc11.green(`  add   ${pack}`) + pc11.dim(` (${added} skills)`));
+    } catch (err) {
+      console.log(pc11.red(`  fail  ${pack}: ${err.message}`));
+    }
+  }
+  console.log(pc11.green('\nDone! Run "skilldb use auto" to activate a profile.'));
+}
+
+// src/commands/doctor.ts
+import fs8 from "fs";
+import path8 from "path";
+import pc12 from "picocolors";
+var SKILLDB_DIR5 = ".skilldb";
+var SKILLS_DIR3 = "skills";
+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);
+  try {
+    return JSON.parse(fs8.readFileSync(p, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function collectFiles(dir) {
+  const result = [];
+  if (!fs8.existsSync(dir)) return result;
+  function walk(d) {
+    for (const entry of fs8.readdirSync(d, { withFileTypes: true })) {
+      const full = path8.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 });
+    }
+  }
+  walk(dir);
+  return result;
+}
+async function doctorCommand() {
+  const cwd = process.cwd();
+  const manifest = readManifest(cwd);
+  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)) {
+    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 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)) {
+      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 activeFiles = collectFiles(activeDir);
+  if (config.activeProfile) {
+    console.log(pc12.green(`  [ok] Active profile: ${config.activeProfile} (${activeFiles.length} skills)`));
+  } else {
+    console.log(pc12.yellow('  [!] No active profile. Run "skilldb use <profile>" to set one.'));
+    issues++;
+  }
+  const activeNames = new Set(activeFiles.map((f) => f.name));
+  const unused = skillFiles.filter((f) => !activeNames.has(f.name));
+  if (unused.length > 0 && config.activeProfile) {
+    console.log(pc12.yellow(`  [!] ${unused.length} installed skill(s) not in active profile`));
+    issues++;
+  }
+  const totalLines = skillFiles.reduce((sum, f) => sum + f.lines, 0);
+  const activeLines = activeFiles.reduce((sum, f) => sum + f.lines, 0);
+  const totalTokens = totalLines * TOKENS_PER_LINE2;
+  const activeTokens = activeLines * TOKENS_PER_LINE2;
+  console.log(pc12.dim("\n  Summary:"));
+  console.log(`    Installed: ${totalLines.toLocaleString()} lines (~${totalTokens.toLocaleString()} tokens)`);
+  console.log(`    Active:    ${activeLines.toLocaleString()} lines (~${activeTokens.toLocaleString()} tokens)`);
+  if (config.budget) {
+    const budgetValue = config.budget.unit === "tokens" ? activeTokens : activeLines;
+    const pct = Math.round(budgetValue / config.budget.max * 100);
+    const color = pct > 100 ? pc12.red : pct > 80 ? pc12.yellow : pc12.green;
+    console.log(`    Budget:    ${color(`${pct}%`)} of ${config.budget.max.toLocaleString()} ${config.budget.unit}`);
+    if (pct > 100) issues++;
+  }
+  const packs = new Set(installedIds.map((id) => id.split("/")[0]));
+  console.log(`    Packs:     ${packs.size} installed`);
+  console.log(
+    issues === 0 ? pc12.green("\nNo issues found!") : pc12.yellow(`
+${issues} issue(s) found. Run suggested commands to fix.`)
+  );
+}
+
+// src/commands/update.ts
+import fs9 from "fs";
+import path9 from "path";
+import pc13 from "picocolors";
+var SKILLDB_DIR6 = ".skilldb";
+var SKILLS_DIR4 = "skills";
+async function updateCommand(pack) {
+  const cwd = process.cwd();
+  const client = new SkillDBClient();
+  const manifest = readManifest(cwd);
+  const installedIds = Object.keys(manifest.installed);
+  if (installedIds.length === 0) {
+    console.log(pc13.yellow('No skills installed. Use "skilldb add <pack>" first.'));
+    return;
+  }
+  const targetIds = pack ? installedIds.filter((id) => id.startsWith(pack + "/")) : installedIds;
+  if (targetIds.length === 0) {
+    console.error(pc13.red(`No installed skills found for pack "${pack}".`));
+    process.exit(1);
+  }
+  console.log(pc13.bold(`Updating ${targetIds.length} skill(s)...
+`));
+  const packGroups = /* @__PURE__ */ new Map();
+  for (const id of targetIds) {
+    const p = id.split("/")[0];
+    if (!packGroups.has(p)) packGroups.set(p, []);
+    packGroups.get(p).push(id);
+  }
+  let updated = 0;
+  let unchanged = 0;
+  let failed = 0;
+  for (const [packName, ids] of packGroups) {
+    try {
+      const res = await client.list({ pack: packName, limit: 500, includeContent: true });
+      const remoteMap = new Map(res.skills.map((s) => [s.id, s]));
+      for (const id of ids) {
+        const remote = remoteMap.get(id);
+        if (!remote) {
+          console.log(pc13.dim(`  skip  ${id} (not found on remote)`));
+          continue;
+        }
+        const localPath = path9.join(
+          cwd,
+          SKILLDB_DIR6,
+          SKILLS_DIR4,
+          packName,
+          id.split("/")[1].replace(".md", "").replace(/[/\\:*?"<>|]/g, "-") + ".md"
+        );
+        let localContent = "";
+        try {
+          localContent = fs9.readFileSync(localPath, "utf-8");
+        } catch {
+        }
+        if (remote.content && remote.content !== localContent) {
+          const oldLines = localContent.split("\n").length;
+          const newLines = remote.content.split("\n").length;
+          const diff = newLines - oldLines;
+          const diffStr = diff > 0 ? `+${diff}` : `${diff}`;
+          cacheSkill(remote, cwd);
+          updated++;
+          console.log(
+            pc13.green(`  update  ${id}`) + pc13.dim(` (${diffStr} lines)`)
+          );
+        } else {
+          unchanged++;
+        }
+      }
+    } catch (err) {
+      failed += ids.length;
+      console.log(pc13.red(`  fail  ${packName}: ${err.message}`));
+    }
+  }
+  console.log(
+    `
+${pc13.green(`${updated} updated`)}` + pc13.dim(`, ${unchanged} unchanged`) + (failed > 0 ? pc13.red(`, ${failed} failed`) : "")
+  );
+}
+
+// src/commands/remove.ts
+import fs10 from "fs";
+import path10 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 result = /* @__PURE__ */ new Set();
+  if (!fs10.existsSync(activeDir)) return result;
+  for (const pack of fs10.readdirSync(activeDir, { withFileTypes: true })) {
+    if (!pack.isDirectory()) continue;
+    for (const file of fs10.readdirSync(path10.join(activeDir, pack.name))) {
+      if (file.endsWith(".md")) {
+        result.add(`${pack.name}/${file}`);
+      }
+    }
+  }
+  return result;
+}
+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);
+    }
+    return true;
+  }
+  return false;
+}
+async function removeCommand(target, options) {
+  const cwd = process.cwd();
+  const manifest = readManifest(cwd);
+  if (options.unused) {
+    const activeSkills2 = collectActiveSkills(cwd);
+    const installedIds = Object.keys(manifest.installed);
+    let removed = 0;
+    for (const id2 of installedIds) {
+      const [pack2, file2] = id2.split("/");
+      const name2 = file2.replace(".md", "").replace(/[/\\:*?"<>|]/g, "-") + ".md";
+      const key = `${pack2}/${name2}`;
+      if (!activeSkills2.has(key)) {
+        removeSkillFile(cwd, id2);
+        delete manifest.installed[id2];
+        removed++;
+        console.log(pc14.yellow(`  remove  ${id2}`));
+      }
+    }
+    writeManifest(manifest, cwd);
+    console.log(
+      removed > 0 ? pc14.green(`
+${removed} unused skill(s) removed.`) : pc14.dim("No unused skills found.")
+    );
+    return;
+  }
+  if (!target.includes("/")) {
+    const packIds = Object.keys(manifest.installed).filter((id2) => id2.startsWith(target + "/"));
+    if (packIds.length === 0) {
+      console.error(pc14.red(`No installed skills found for "${target}".`));
+      process.exit(1);
+    }
+    const activeSkills2 = collectActiveSkills(cwd);
+    let activeWarning = false;
+    for (const id2 of packIds) {
+      const [pack2, file2] = id2.split("/");
+      const name2 = file2.replace(".md", "").replace(/[/\\:*?"<>|]/g, "-") + ".md";
+      if (activeSkills2.has(`${pack2}/${name2}`)) activeWarning = true;
+      removeSkillFile(cwd, id2);
+      delete manifest.installed[id2];
+      console.log(pc14.yellow(`  remove  ${id2}`));
+    }
+    writeManifest(manifest, cwd);
+    console.log(pc14.green(`
+${packIds.length} skill(s) from "${target}" removed.`));
+    if (activeWarning) {
+      console.log(pc14.yellow("Warning: Some removed skills were in your active profile."));
+      console.log(pc14.yellow('Run "skilldb use <profile>" to refresh.'));
+    }
+    return;
+  }
+  let id = target;
+  if (!id.includes(".md")) id = id + ".md";
+  if (!(id in manifest.installed)) {
+    console.error(pc14.red(`Skill "${id}" is not installed.`));
+    process.exit(1);
+  }
+  const activeSkills = collectActiveSkills(cwd);
+  const [pack, file] = id.split("/");
+  const name = file.replace(".md", "").replace(/[/\\:*?"<>|]/g, "-") + ".md";
+  removeSkillFile(cwd, id);
+  delete manifest.installed[id];
+  writeManifest(manifest, cwd);
+  console.log(pc14.green(`Removed ${id}`));
+  if (activeSkills.has(`${pack}/${name}`)) {
+    console.log(pc14.yellow('Warning: This skill was in your active profile. Run "skilldb use <profile>" to refresh.'));
+  }
+}
+
+// src/commands/export.ts
+import fs11 from "fs";
+import path11 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);
+  try {
+    return JSON.parse(fs11.readFileSync(p, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function collectActiveSkills2(cwd) {
+  const activeDir = path11.join(cwd, SKILLDB_DIR8, ACTIVE_DIR6);
+  const result = [];
+  if (!fs11.existsSync(activeDir)) return result;
+  for (const pack of fs11.readdirSync(activeDir, { withFileTypes: true })) {
+    if (!pack.isDirectory()) continue;
+    for (const file of fs11.readdirSync(path11.join(activeDir, pack.name))) {
+      if (file.endsWith(".md")) {
+        result.push({
+          pack: pack.name,
+          name: file.replace(".md", ""),
+          path: path11.join(activeDir, pack.name, file)
+        });
+      }
+    }
+  }
+  return result;
+}
+function exportClaude(cwd) {
+  const skills = collectActiveSkills2(cwd);
+  if (skills.length === 0) {
+    console.error(pc15.red('No active skills. Run "skilldb use <profile>" first.'));
+    process.exit(1);
+  }
+  const lines = ["<!-- skilldb:start -->", "## SkillDB Active Skills\n"];
+  lines.push("Reference these skills from `.skilldb/active/` when working on tasks:\n");
+  for (const s of skills) {
+    lines.push(`- \`.skilldb/active/${s.pack}/${s.name}.md\``);
+  }
+  lines.push("", "<!-- skilldb:end -->");
+  const output = lines.join("\n");
+  console.log(output);
+  console.log(pc15.dim("\n--- Copy the above into your CLAUDE.md ---"));
+}
+function exportCursor(cwd) {
+  const skills = collectActiveSkills2(cwd);
+  if (skills.length === 0) {
+    console.error(pc15.red('No active skills. Run "skilldb use <profile>" first.'));
+    process.exit(1);
+  }
+  const lines = ["# SkillDB Active Skills", ""];
+  lines.push("Reference these skills from `.skilldb/active/` when working on tasks:", "");
+  for (const s of skills) {
+    lines.push(`@file .skilldb/active/${s.pack}/${s.name}.md`);
+  }
+  const output = lines.join("\n");
+  console.log(output);
+  console.log(pc15.dim("\n--- Copy the above into your .cursorrules ---"));
+}
+function exportProfile(cwd) {
+  const config = readConfig4(cwd);
+  const manifest = readManifest(cwd);
+  const profile = {
+    profile: config.activeProfile || "custom",
+    budget: config.budget || null,
+    skills: Object.keys(manifest.installed),
+    exportedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const filename = ".skilldb-profile.json";
+  fs11.writeFileSync(path11.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"'));
+}
+function exportInject(cwd, id) {
+  if (!id.includes(".md")) id = id + ".md";
+  const cachedPath = getCachedPath(id, cwd);
+  if (!cachedPath) {
+    console.error(pc15.red(`Skill "${id}" not found locally. Run "skilldb get ${id}" first.`));
+    process.exit(1);
+  }
+  const content = fs11.readFileSync(cachedPath, "utf-8");
+  process.stdout.write(content);
+}
+async function exportCommand(format, target) {
+  const cwd = process.cwd();
+  switch (format) {
+    case "claude":
+      exportClaude(cwd);
+      break;
+    case "cursor":
+      exportCursor(cwd);
+      break;
+    case "profile":
+      exportProfile(cwd);
+      break;
+    case "inject":
+      if (!target) {
+        console.error(pc15.red("Usage: skilldb export inject <skill-id>"));
+        process.exit(1);
+      }
+      exportInject(cwd, target);
+      break;
+    default:
+      console.error(pc15.red(`Unknown format "${format}". Use: claude, cursor, profile, inject`));
+      process.exit(1);
+  }
+}
+
+// src/commands/stats.ts
+import fs12 from "fs";
+import path12 from "path";
+import pc16 from "picocolors";
+var SKILLDB_DIR9 = ".skilldb";
+var SKILLS_DIR6 = "skills";
+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);
+  try {
+    return JSON.parse(fs12.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 (!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))) {
+      if (!file.endsWith(".md")) continue;
+      result.files++;
+      result.lines += fs12.readFileSync(path12.join(dir, pack.name, file), "utf-8").split("\n").length;
+    }
+  }
+  return result;
+}
+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 installed = countDir(skillsDir);
+  const active = countDir(activeDir);
+  console.log(pc16.bold("SkillDB Stats\n"));
+  console.log(pc16.cyan("Installed:"));
+  console.log(`  Skills:     ${installed.files}`);
+  console.log(`  Packs:      ${installed.packs.size}` + (installed.packs.size > 0 ? pc16.dim(` (${[...installed.packs].join(", ")})`) : ""));
+  console.log(`  Lines:      ${installed.lines.toLocaleString()}`);
+  console.log(`  Est tokens: ${(installed.lines * TOKENS_PER_LINE3).toLocaleString()}`);
+  console.log(pc16.cyan("\nActive:"));
+  if (config.activeProfile) {
+    console.log(`  Profile:    ${config.activeProfile}`);
+  } else {
+    console.log(`  Profile:    ${pc16.dim("none")}`);
+  }
+  console.log(`  Skills:     ${active.files}`);
+  console.log(`  Lines:      ${active.lines.toLocaleString()}`);
+  console.log(`  Est tokens: ${(active.lines * TOKENS_PER_LINE3).toLocaleString()}`);
+  if (config.budget) {
+    const budgetValue = config.budget.unit === "tokens" ? active.lines * TOKENS_PER_LINE3 : active.lines;
+    const pct = Math.round(budgetValue / config.budget.max * 100);
+    const color = pct > 100 ? pc16.red : pct > 80 ? pc16.yellow : pc16.green;
+    console.log(pc16.cyan("\nBudget:"));
+    console.log(`  Limit:      ${config.budget.max.toLocaleString()} ${config.budget.unit}`);
+    console.log(`  Usage:      ${color(`${pct}%`)}`);
+  }
+  console.log(pc16.cyan("\nCoverage:"));
+  console.log(`  Categories: ${installed.categories.size} covered`);
+  const manifestPacks = new Set(Object.keys(manifest.installed).map((id) => id.split("/")[0]));
+  const activePacks = active.packs;
+  const unusedPacks = [...manifestPacks].filter((p) => !activePacks.has(p));
+  if (unusedPacks.length > 0) {
+    console.log(pc16.yellow(`
+  Installed but not active: ${unusedPacks.join(", ")}`));
+  }
+}
+
+// src/commands/diff.ts
+import fs13 from "fs";
+import path13 from "path";
+import pc17 from "picocolors";
+var SKILLDB_DIR10 = ".skilldb";
+var SKILLS_DIR7 = "skills";
+function diffLines(local, remote) {
+  const localLines = local.split("\n");
+  const remoteLines = remote.split("\n");
+  let added = 0;
+  let removed = 0;
+  const localSet = new Set(localLines);
+  const remoteSet = new Set(remoteLines);
+  for (const line of remoteLines) {
+    if (!localSet.has(line)) added++;
+  }
+  for (const line of localLines) {
+    if (!remoteSet.has(line)) removed++;
+  }
+  return { added, removed, changed: added > 0 || removed > 0 };
+}
+function showDiff(id, local, remote) {
+  const result = diffLines(local, remote);
+  if (!result.changed) {
+    console.log(pc17.dim(`  ${id}: up to date`));
+    return;
+  }
+  console.log(pc17.bold(`  ${id}:`));
+  if (result.added > 0) console.log(pc17.green(`    +${result.added} lines added`));
+  if (result.removed > 0) console.log(pc17.red(`    -${result.removed} lines removed`));
+  const localLines = local.split("\n");
+  const remoteLines = remote.split("\n");
+  const localSet = new Set(localLines);
+  const remoteSet = new Set(remoteLines);
+  let shown = 0;
+  for (const line of remoteLines) {
+    if (!localSet.has(line) && line.trim()) {
+      console.log(pc17.green(`    + ${line.slice(0, 80)}`));
+      if (++shown >= 3) break;
+    }
+  }
+  shown = 0;
+  for (const line of localLines) {
+    if (!remoteSet.has(line) && line.trim()) {
+      console.log(pc17.red(`    - ${line.slice(0, 80)}`));
+      if (++shown >= 3) break;
+    }
+  }
+}
+async function diffCommand(target) {
+  const cwd = process.cwd();
+  const client = new SkillDBClient();
+  const manifest = readManifest(cwd);
+  const installedIds = Object.keys(manifest.installed);
+  if (installedIds.length === 0) {
+    console.log(pc17.yellow("No skills installed."));
+    return;
+  }
+  if (target) {
+    let id = 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)) {
+      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");
+      if (!remote.content) {
+        console.log(pc17.yellow("Remote content not available (API key required)."));
+        return;
+      }
+      showDiff(id, localContent, remote.content);
+    } catch (err) {
+      console.error(pc17.red(`Error: ${err.message}`));
+      process.exit(1);
+    }
+    return;
+  }
+  console.log(pc17.bold(`Comparing ${installedIds.length} skill(s) with remote...
+`));
+  const packGroups = /* @__PURE__ */ new Map();
+  for (const id of installedIds) {
+    const p = id.split("/")[0];
+    if (!packGroups.has(p)) packGroups.set(p, []);
+    packGroups.get(p).push(id);
+  }
+  let changed = 0;
+  let upToDate = 0;
+  for (const [packName, ids] of packGroups) {
+    try {
+      const res = await client.list({ pack: packName, limit: 500, includeContent: true });
+      const remoteMap = new Map(res.skills.map((s) => [s.id, s]));
+      for (const id of ids) {
+        const remote = remoteMap.get(id);
+        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`);
+        let localContent = "";
+        try {
+          localContent = fs13.readFileSync(localPath, "utf-8");
+        } catch {
+          continue;
+        }
+        const result = diffLines(localContent, remote.content);
+        if (result.changed) {
+          showDiff(id, localContent, remote.content);
+          changed++;
+        } else {
+          upToDate++;
+        }
+      }
+    } catch (err) {
+      console.log(pc17.red(`  Error fetching ${packName}: ${err.message}`));
+    }
+  }
+  console.log(`
+${pc17.green(`${upToDate} up to date`)}` + (changed > 0 ? pc17.yellow(`, ${changed} changed`) : ""));
+  if (changed > 0) {
+    console.log(pc17.dim('Run "skilldb update" to pull latest versions.'));
+  }
+}
+
 // src/cli.ts
 var program = new Command();
-program.name("skilldb").description("SkillDB CLI \u2014 discover, install, and manage AI agent skills").version("0.1.4");
+program.name("skilldb").description("SkillDB CLI \u2014 discover, install, and manage AI agent skills").version("0.1.5");
 program.command("init").description("Initialize SkillDB in this project (detect IDE, create .skilldb/)").action(initCommand);
 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) => {
@@ -549,5 +1628,32 @@ program.command("list").description("List skills, optionally filtered").option("
 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("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) {
+    options.list = true;
+  }
+  useCommand(profile || "", options);
+});
+program.command("budget [action] [value]").description("Manage token/line budget for active skills").action((action, value) => {
+  budgetCommand(action, value);
+});
+program.command("slim [pack]").description("Generate compressed skill summaries").option("-r, --ratio <ratio>", "Keep ratio (0-1, default 0.3)", "0.3").action((pack, options) => {
+  slimCommand(pack, options);
+});
+program.command("recommend").description("Scan project and suggest skill packs").option("-i, --install", "Auto-install recommendations").action(recommendCommand);
+program.command("doctor").description("Run health check and audit on installed skills").action(doctorCommand);
+program.command("update [pack]").description("Update installed skills from remote").action((pack) => {
+  updateCommand(pack);
+});
+program.command("remove <target>").description('Remove a skill or pack (e.g. "software-skills/code-review" or "software-skills")').option("--unused", "Remove skills not in active profile").action((target, options) => {
+  removeCommand(target, options);
+});
+program.command("export <format> [target]").description("Export skills (formats: claude, cursor, profile, inject)").action((format, target) => {
+  exportCommand(format, target);
+});
+program.command("stats").description("Show local statistics and coverage").action(statsCommand);
+program.command("diff [target]").description("Compare local skills with latest remote versions").action((target) => {
+  diffCommand(target);
+});
 program.parse();
 //# sourceMappingURL=cli.js.map