skill-tree 0.1.5 → 0.1.7

package/dist/cli/index.js

@@ -1777,7 +1777,7 @@ var init_sync = __esm({
 });
 
 // src/cli/index.ts
-var import_commander38 = require("commander");
+var import_commander39 = require("commander");
 
 // src/types.ts
 function hasTaxonomySupport(storage) {
@@ -2852,8 +2852,214 @@ var SyncManager = class {
   }
 };
 
-// src/serving/loadout-compiler.ts
+// src/serving/xml-utils.ts
+function escapeXml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function getSkillSummary(skill, maxLength = 150) {
+  if (skill.serving?.summary) {
+    return skill.serving.summary;
+  }
+  const firstSentence = skill.description.split(/[.!?]/)[0];
+  if (firstSentence.length <= maxLength) {
+    return firstSentence;
+  }
+  return skill.description.substring(0, maxLength - 3) + "...";
+}
+
+// src/serving/catalog-renderer.ts
+function hasCatalogSupport(storage) {
+  const s = storage;
+  return typeof s.getTaxonomyTree === "function" && typeof s.getSkillsInTaxonomyNode === "function";
+}
+var UNTAGGED_CATEGORY = "other";
+var CATALOG_USAGE_LINES = [
+  "  Use skill_browse to explore categories.",
+  "  Use skill_search to find by keyword.",
+  "  Use skill_expand to load a skill into your context."
+];
 var DEFAULT_CONFIG = {
+  maxCategoriesPerLevel: 12,
+  maxSkillsAtLeaf: 8,
+  maxSummaryLength: 80,
+  format: "xml"
+};
+var CatalogRenderer = class _CatalogRenderer {
+  constructor(storage, config2) {
+    this.storage = storage;
+    this.overviewCache = null;
+    this.config = { ...DEFAULT_CONFIG, ...config2 };
+  }
+  static {
+    this.CACHE_TTL_MS = 6e4;
+  }
+  /**
+   * Render level-0 catalog overview for system prompt injection.
+   * Shows top-level categories with counts. ~200 tokens.
+   * Returns empty string if no skills exist.
+   * Results are cached for 60 seconds to avoid repeated storage queries.
+   */
+  async renderOverview() {
+    if (this.overviewCache && Date.now() - this.overviewCache.timestamp < _CatalogRenderer.CACHE_TTL_MS) {
+      return this.overviewCache.value;
+    }
+    let result;
+    if (hasCatalogSupport(this.storage)) {
+      const tree = await this.storage.getTaxonomyTree();
+      if (tree.length > 0) {
+        result = this.renderOverviewFromNodes(tree);
+        this.overviewCache = { value: result, timestamp: Date.now() };
+        return result;
+      }
+    }
+    result = await this.renderOverviewFromTags();
+    this.overviewCache = { value: result, timestamp: Date.now() };
+    return result;
+  }
+  /**
+   * Render a specific category path for browse drill-down.
+   * Shows subcategories at intermediate nodes, or skill summaries at leaf nodes.
+   */
+  async renderCategory(path18) {
+    if (hasCatalogSupport(this.storage)) {
+      return this.renderCategoryFromTaxonomy(this.storage, path18);
+    }
+    return this.renderCategoryFromTags(path18);
+  }
+  /**
+   * Invalidate the overview cache (e.g., after skill changes).
+   */
+  invalidateCache() {
+    this.overviewCache = null;
+  }
+  // ===========================================================================
+  // OVERVIEW RENDERING (shared structure)
+  // ===========================================================================
+  /**
+   * Render the overview XML shell with a list of categories.
+   * Used by both taxonomy-based and tag-based paths.
+   */
+  renderOverviewXml(totalSkills, categories) {
+    const lines = [];
+    lines.push(`<skill_catalog total="${totalSkills}">`);
+    lines.push("  <usage>");
+    lines.push(...CATALOG_USAGE_LINES);
+    lines.push("  </usage>");
+    lines.push("  <categories>");
+    for (const cat of categories) {
+      lines.push(`    <category path="${escapeXml(cat.name)}" count="${cat.count}" />`);
+    }
+    lines.push("  </categories>");
+    lines.push("</skill_catalog>");
+    return lines.join("\n");
+  }
+  // ===========================================================================
+  // TAXONOMY-BASED RENDERING
+  // ===========================================================================
+  renderOverviewFromNodes(roots) {
+    const counted = this.withCounts(roots);
+    const totalSkills = counted.reduce((sum, c) => sum + c.count, 0);
+    const categories = counted.sort((a, b) => b.count - a.count).slice(0, this.config.maxCategoriesPerLevel).map((c) => ({ name: c.node.name, count: c.count }));
+    return this.renderOverviewXml(totalSkills, categories);
+  }
+  async renderCategoryFromTaxonomy(storage, path18) {
+    const tree = await storage.getTaxonomyTree(path18);
+    const pathStr = path18.join("/");
+    if (tree.length > 0 && tree.some((n) => n.children.length > 0)) {
+      const root = tree[0];
+      const rootCount = this.countNodeSkills(root);
+      const counted = this.withCounts(root.children);
+      const children = counted.sort((a, b) => b.count - a.count).slice(0, this.config.maxCategoriesPerLevel);
+      const lines = [];
+      lines.push(`<catalog_browse path="${escapeXml(pathStr)}" count="${rootCount}">`);
+      lines.push("  <subcategories>");
+      for (const { node: child, count } of children) {
+        const childPath = [...path18, child.name].join("/");
+        lines.push(`    <category path="${escapeXml(childPath)}" count="${count}" />`);
+      }
+      lines.push("  </subcategories>");
+      lines.push("</catalog_browse>");
+      return lines.join("\n");
+    }
+    if (tree.length > 0) {
+      const nodeId = tree[0].id;
+      const skills = await storage.getSkillsInTaxonomyNode(nodeId);
+      return this.renderLeafSkills(skills, pathStr, tree[0].skillCount);
+    }
+    return `<catalog_browse path="${escapeXml(pathStr)}" count="0" />`;
+  }
+  // ===========================================================================
+  // TAG-BASED FALLBACK
+  // ===========================================================================
+  async renderOverviewFromTags() {
+    const skills = await this.storage.listSkills({ status: ["active"] });
+    if (skills.length === 0) return "";
+    const tagCounts = this.groupByPrimaryTag(skills);
+    const categories = Array.from(tagCounts.entries()).sort((a, b) => b[1] - a[1]).slice(0, this.config.maxCategoriesPerLevel).map(([name, count]) => ({ name, count }));
+    return this.renderOverviewXml(skills.length, categories);
+  }
+  async renderCategoryFromTags(path18) {
+    if (path18.length === 0) {
+      return this.renderOverviewFromTags();
+    }
+    const tag = path18[0];
+    const matching = await this.storage.listSkills({ status: ["active"], tags: [tag] });
+    const pathStr = path18.join("/");
+    return this.renderLeafSkills(matching, pathStr, matching.length);
+  }
+  // ===========================================================================
+  // SHARED RENDERING HELPERS
+  // ===========================================================================
+  renderLeafSkills(skills, pathStr, totalCount) {
+    const displayed = skills.slice(0, this.config.maxSkillsAtLeaf);
+    const remaining = totalCount - displayed.length;
+    const lines = [];
+    lines.push(`<catalog_browse path="${escapeXml(pathStr)}" count="${totalCount}">`);
+    lines.push("  <skills>");
+    for (const skill of displayed) {
+      const tags = skill.tags.length > 0 ? ` tags="${escapeXml(skill.tags.join(", "))}"` : "";
+      const desc = getSkillSummary(skill, this.config.maxSummaryLength);
+      lines.push(`    <skill id="${escapeXml(skill.id)}"${tags}>`);
+      lines.push(`      ${escapeXml(desc)}`);
+      lines.push("    </skill>");
+    }
+    lines.push("  </skills>");
+    if (remaining > 0) {
+      lines.push(`  <more remaining="${remaining}">`);
+      lines.push("    Use skill_search for more, or skill_expand {id} to load.");
+      lines.push("  </more>");
+    }
+    lines.push("</catalog_browse>");
+    return lines.join("\n");
+  }
+  // ===========================================================================
+  // UTILITIES
+  // ===========================================================================
+  groupByPrimaryTag(skills) {
+    const tagCounts = /* @__PURE__ */ new Map();
+    for (const skill of skills) {
+      const tag = skill.tags[0] || UNTAGGED_CATEGORY;
+      tagCounts.set(tag, (tagCounts.get(tag) || 0) + 1);
+    }
+    return tagCounts;
+  }
+  /**
+   * Pre-compute counts for a list of nodes, avoiding redundant recursive walks.
+   */
+  withCounts(nodes) {
+    return nodes.map((node) => ({ node, count: this.countNodeSkills(node) }));
+  }
+  countNodeSkills(node) {
+    let count = node.skillCount;
+    for (const child of node.children) {
+      count += this.countNodeSkills(child);
+    }
+    return count;
+  }
+};
+
+// src/serving/loadout-compiler.ts
+var DEFAULT_CONFIG2 = {
   defaultMaxSkills: 15,
   defaultStatus: ["active"],
   semanticThreshold: 0.6
@@ -2862,7 +3068,7 @@ var LoadoutCompiler = class {
   constructor(storage, config2) {
     this.storage = storage;
     this.config = {
-      ...DEFAULT_CONFIG,
+      ...DEFAULT_CONFIG2,
       ...config2
     };
   }
@@ -3083,11 +3289,76 @@ var LoadoutCompiler = class {
 // src/serving/project-detector.ts
 var import_fs = require("fs");
 var import_path = require("path");
-var _ProjectDetector = class _ProjectDetector {
+var ProjectDetector = class _ProjectDetector {
   constructor() {
     /** Cache for project context */
     this.cache = /* @__PURE__ */ new Map();
   }
+  static {
+    /** Project type patterns */
+    this.PROJECT_TYPES = [
+      { manifestFile: "package.json", type: "nodejs", tags: ["nodejs", "javascript"], packageManager: "npm" },
+      { manifestFile: "pyproject.toml", type: "python", tags: ["python"], packageManager: "pip" },
+      { manifestFile: "requirements.txt", type: "python", tags: ["python"], packageManager: "pip" },
+      { manifestFile: "Cargo.toml", type: "rust", tags: ["rust"], packageManager: "cargo" },
+      { manifestFile: "go.mod", type: "go", tags: ["go", "golang"] },
+      { manifestFile: "pom.xml", type: "java", tags: ["java", "maven"], packageManager: "maven" },
+      { manifestFile: "build.gradle", type: "java", tags: ["java", "gradle"], packageManager: "gradle" },
+      { manifestFile: "build.gradle.kts", type: "kotlin", tags: ["kotlin", "gradle"], packageManager: "gradle" }
+    ];
+  }
+  static {
+    /** TypeScript detection */
+    this.TYPESCRIPT_FILES = ["tsconfig.json", "tsconfig.base.json"];
+  }
+  static {
+    /** Node.js framework patterns */
+    this.NODE_FRAMEWORKS = [
+      { name: "react", packageName: "react", tags: ["react", "frontend"] },
+      { name: "next", packageName: "next", tags: ["nextjs", "react", "fullstack"] },
+      { name: "vue", packageName: "vue", tags: ["vue", "frontend"] },
+      { name: "nuxt", packageName: "nuxt", tags: ["nuxt", "vue", "fullstack"] },
+      { name: "angular", packageName: "@angular/core", tags: ["angular", "frontend"] },
+      { name: "svelte", packageName: "svelte", tags: ["svelte", "frontend"] },
+      { name: "express", packageName: "express", tags: ["express", "backend", "api"] },
+      { name: "fastify", packageName: "fastify", tags: ["fastify", "backend", "api"] },
+      { name: "nestjs", packageName: "@nestjs/core", tags: ["nestjs", "backend", "api"] },
+      { name: "hono", packageName: "hono", tags: ["hono", "backend", "api"] },
+      { name: "prisma", packageName: "@prisma/client", tags: ["prisma", "database", "orm"] },
+      { name: "drizzle", packageName: "drizzle-orm", tags: ["drizzle", "database", "orm"] },
+      { name: "typeorm", packageName: "typeorm", tags: ["typeorm", "database", "orm"] },
+      { name: "jest", packageName: "jest", tags: ["testing", "jest"] },
+      { name: "vitest", packageName: "vitest", tags: ["testing", "vitest"] },
+      { name: "playwright", packageName: "@playwright/test", tags: ["testing", "e2e", "playwright"] },
+      { name: "cypress", packageName: "cypress", tags: ["testing", "e2e", "cypress"] }
+    ];
+  }
+  static {
+    /** Python framework patterns (from pyproject.toml or requirements.txt) */
+    this.PYTHON_FRAMEWORKS = [
+      { name: "fastapi", packageName: "fastapi", tags: ["fastapi", "backend", "api"] },
+      { name: "django", packageName: "django", tags: ["django", "backend", "fullstack"] },
+      { name: "flask", packageName: "flask", tags: ["flask", "backend", "api"] },
+      { name: "sqlalchemy", packageName: "sqlalchemy", tags: ["sqlalchemy", "database", "orm"] },
+      { name: "pytest", packageName: "pytest", tags: ["testing", "pytest"] },
+      { name: "pydantic", packageName: "pydantic", tags: ["pydantic", "validation"] }
+    ];
+  }
+  static {
+    /** Directory patterns */
+    this.DIRECTORY_PATTERNS = [
+      { pattern: ".github/workflows", feature: "github-actions", tags: ["ci", "github-actions"] },
+      { pattern: ".gitlab-ci.yml", feature: "gitlab-ci", tags: ["ci", "gitlab"] },
+      { pattern: "Dockerfile", feature: "docker", tags: ["docker", "containers"] },
+      { pattern: "docker-compose.yml", feature: "docker-compose", tags: ["docker", "containers"] },
+      { pattern: "docker-compose.yaml", feature: "docker-compose", tags: ["docker", "containers"] },
+      { pattern: "terraform", feature: "terraform", tags: ["terraform", "infrastructure"] },
+      { pattern: "kubernetes", feature: "kubernetes", tags: ["kubernetes", "infrastructure"] },
+      { pattern: "k8s", feature: "kubernetes", tags: ["kubernetes", "infrastructure"] },
+      { pattern: ".env.example", feature: "env-config", tags: ["configuration"] },
+      { pattern: "prisma/schema.prisma", feature: "prisma", tags: ["prisma", "database"] }
+    ];
+  }
   /**
    * Detect project context from a directory
    */
@@ -3249,71 +3520,15 @@ var _ProjectDetector = class _ProjectDetector {
     }
   }
 };
-/** Project type patterns */
-_ProjectDetector.PROJECT_TYPES = [
-  { manifestFile: "package.json", type: "nodejs", tags: ["nodejs", "javascript"], packageManager: "npm" },
-  { manifestFile: "pyproject.toml", type: "python", tags: ["python"], packageManager: "pip" },
-  { manifestFile: "requirements.txt", type: "python", tags: ["python"], packageManager: "pip" },
-  { manifestFile: "Cargo.toml", type: "rust", tags: ["rust"], packageManager: "cargo" },
-  { manifestFile: "go.mod", type: "go", tags: ["go", "golang"] },
-  { manifestFile: "pom.xml", type: "java", tags: ["java", "maven"], packageManager: "maven" },
-  { manifestFile: "build.gradle", type: "java", tags: ["java", "gradle"], packageManager: "gradle" },
-  { manifestFile: "build.gradle.kts", type: "kotlin", tags: ["kotlin", "gradle"], packageManager: "gradle" }
-];
-/** TypeScript detection */
-_ProjectDetector.TYPESCRIPT_FILES = ["tsconfig.json", "tsconfig.base.json"];
-/** Node.js framework patterns */
-_ProjectDetector.NODE_FRAMEWORKS = [
-  { name: "react", packageName: "react", tags: ["react", "frontend"] },
-  { name: "next", packageName: "next", tags: ["nextjs", "react", "fullstack"] },
-  { name: "vue", packageName: "vue", tags: ["vue", "frontend"] },
-  { name: "nuxt", packageName: "nuxt", tags: ["nuxt", "vue", "fullstack"] },
-  { name: "angular", packageName: "@angular/core", tags: ["angular", "frontend"] },
-  { name: "svelte", packageName: "svelte", tags: ["svelte", "frontend"] },
-  { name: "express", packageName: "express", tags: ["express", "backend", "api"] },
-  { name: "fastify", packageName: "fastify", tags: ["fastify", "backend", "api"] },
-  { name: "nestjs", packageName: "@nestjs/core", tags: ["nestjs", "backend", "api"] },
-  { name: "hono", packageName: "hono", tags: ["hono", "backend", "api"] },
-  { name: "prisma", packageName: "@prisma/client", tags: ["prisma", "database", "orm"] },
-  { name: "drizzle", packageName: "drizzle-orm", tags: ["drizzle", "database", "orm"] },
-  { name: "typeorm", packageName: "typeorm", tags: ["typeorm", "database", "orm"] },
-  { name: "jest", packageName: "jest", tags: ["testing", "jest"] },
-  { name: "vitest", packageName: "vitest", tags: ["testing", "vitest"] },
-  { name: "playwright", packageName: "@playwright/test", tags: ["testing", "e2e", "playwright"] },
-  { name: "cypress", packageName: "cypress", tags: ["testing", "e2e", "cypress"] }
-];
-/** Python framework patterns (from pyproject.toml or requirements.txt) */
-_ProjectDetector.PYTHON_FRAMEWORKS = [
-  { name: "fastapi", packageName: "fastapi", tags: ["fastapi", "backend", "api"] },
-  { name: "django", packageName: "django", tags: ["django", "backend", "fullstack"] },
-  { name: "flask", packageName: "flask", tags: ["flask", "backend", "api"] },
-  { name: "sqlalchemy", packageName: "sqlalchemy", tags: ["sqlalchemy", "database", "orm"] },
-  { name: "pytest", packageName: "pytest", tags: ["testing", "pytest"] },
-  { name: "pydantic", packageName: "pydantic", tags: ["pydantic", "validation"] }
-];
-/** Directory patterns */
-_ProjectDetector.DIRECTORY_PATTERNS = [
-  { pattern: ".github/workflows", feature: "github-actions", tags: ["ci", "github-actions"] },
-  { pattern: ".gitlab-ci.yml", feature: "gitlab-ci", tags: ["ci", "gitlab"] },
-  { pattern: "Dockerfile", feature: "docker", tags: ["docker", "containers"] },
-  { pattern: "docker-compose.yml", feature: "docker-compose", tags: ["docker", "containers"] },
-  { pattern: "docker-compose.yaml", feature: "docker-compose", tags: ["docker", "containers"] },
-  { pattern: "terraform", feature: "terraform", tags: ["terraform", "infrastructure"] },
-  { pattern: "kubernetes", feature: "kubernetes", tags: ["kubernetes", "infrastructure"] },
-  { pattern: "k8s", feature: "kubernetes", tags: ["kubernetes", "infrastructure"] },
-  { pattern: ".env.example", feature: "env-config", tags: ["configuration"] },
-  { pattern: "prisma/schema.prisma", feature: "prisma", tags: ["prisma", "database"] }
-];
-var ProjectDetector = _ProjectDetector;
 
 // src/serving/view-renderer.ts
-var DEFAULT_CONFIG2 = {
+var DEFAULT_CONFIG3 = {
   includeTokenEstimates: false,
   maxSummaryLength: 150
 };
 var ViewRenderer = class {
   constructor(config2) {
-    this.config = { ...DEFAULT_CONFIG2, ...config2 };
+    this.config = { ...DEFAULT_CONFIG3, ...config2 };
   }
   /**
    * Render loadout state as OpenSkills-compatible XML
@@ -3340,6 +3555,18 @@ var ViewRenderer = class {
         lines.push("  <content>");
         lines.push(skill.instructions.split("\n").map((line) => "    " + line).join("\n"));
         lines.push("  </content>");
+        if (skill.relationships && skill.relationships.length > 0) {
+          const hints = skill.relationships.filter((r) => r.confidence >= 0.5).sort((a, b) => b.confidence - a.confidence).slice(0, 5);
+          if (hints.length > 0) {
+            lines.push("  <related>");
+            for (const rel of hints) {
+              const relatedSkill = state.available.get(rel.targetSkillId);
+              const desc = relatedSkill ? this.getSummary(relatedSkill) : rel.targetSkillId;
+              lines.push(`    <see_also id="${this.escapeXml(rel.targetSkillId)}" type="${rel.type}">${this.escapeXml(desc)}</see_also>`);
+            }
+            lines.push("  </related>");
+          }
+        }
         lines.push("</skill>");
       } else {
         const summary = this.getSummary(skill);
@@ -3452,23 +3679,18 @@ var ViewRenderer = class {
   // Private helpers
   // ===========================================================================
   /**
-   * Get summary for a skill (short description)
+   * Get summary for a skill (short description).
+   * Delegates to shared getSkillSummary utility.
    */
   getSummary(skill) {
-    if (skill.serving?.summary) {
-      return skill.serving.summary;
-    }
-    const firstSentence = skill.description.split(/[.!?]/)[0];
-    if (firstSentence.length <= this.config.maxSummaryLength) {
-      return firstSentence;
-    }
-    return skill.description.substring(0, this.config.maxSummaryLength - 3) + "...";
+    return getSkillSummary(skill, this.config.maxSummaryLength);
   }
   /**
-   * Escape special XML characters
+   * Escape special XML characters.
+   * Delegates to shared escapeXml utility.
    */
   escapeXml(str) {
-    return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+    return escapeXml(str);
   }
   /**
    * Estimate tokens for a full skill
@@ -3558,7 +3780,7 @@ var builtInProfiles = {
 };
 
 // src/serving/graph-server.ts
-var DEFAULT_CONFIG3 = {
+var DEFAULT_CONFIG4 = {
   agentCanModify: true,
   agentCanSetLoadout: false,
   agentCanSwitchProfile: true,
@@ -3570,24 +3792,29 @@ var DEFAULT_CONFIG3 = {
   persistState: false,
   outputFormat: "xml",
   includeTokenEstimates: false,
+  enableCatalog: true,
   profiles: {}
 };
 var SkillGraphServer = class {
   // Track LRU for eviction
   constructor(storage, config2) {
     this.storage = storage;
+    this.catalogRenderer = null;
     this.handlers = /* @__PURE__ */ new Set();
     this.lruOrder = [];
     this.config = {
-      ...DEFAULT_CONFIG3,
+      ...DEFAULT_CONFIG4,
       ...config2,
-      profiles: { ...builtInProfiles, ...DEFAULT_CONFIG3.profiles, ...config2?.profiles }
+      profiles: { ...builtInProfiles, ...DEFAULT_CONFIG4.profiles, ...config2?.profiles }
     };
     this.compiler = new LoadoutCompiler(storage);
     this.projectDetector = new ProjectDetector();
     this.viewRenderer = new ViewRenderer({
       includeTokenEstimates: this.config.includeTokenEstimates
     });
+    if (this.config.enableCatalog !== false) {
+      this.catalogRenderer = new CatalogRenderer(storage, config2?.catalogConfig);
+    }
     this.state = {
       available: /* @__PURE__ */ new Map(),
       expanded: /* @__PURE__ */ new Set(),
@@ -3876,17 +4103,70 @@ var SkillGraphServer = class {
       profiles: this.getProfiles()
     };
   }
+  /**
+   * Agent browses the skill catalog at a given path.
+   * Returns rendered category view (subcategories or skill summaries at leaf).
+   * Pass no path for the top-level overview.
+   */
+  async agentBrowseCatalog(path18) {
+    if (!this.catalogRenderer) {
+      return "<error>Catalog browsing is not enabled</error>";
+    }
+    if (!path18 || path18.length === 0) {
+      const result2 = await this.catalogRenderer.renderOverview();
+      if (result2) {
+        this.emit({ type: "catalog:browsed", path: [] });
+      }
+      return result2;
+    }
+    const result = await this.catalogRenderer.renderCategory(path18);
+    this.emit({ type: "catalog:browsed", path: path18 });
+    return result;
+  }
+  /**
+   * Agent adds a skill discovered via browsing directly to loadout and expands it.
+   * Bridges browse → loadout: found it in catalog, now load it.
+   */
+  async agentAddFromCatalog(skillId) {
+    if (!this.config.agentCanModify) {
+      return { added: false, pending: false, expanded: false };
+    }
+    if (this.state.available.has(skillId)) {
+      const expanded = this.expandSkill(skillId);
+      return { added: false, pending: false, expanded };
+    }
+    const result = await this.agentRequestSkills([skillId]);
+    if (result.added.length > 0) {
+      const expanded = this.expandSkill(skillId);
+      this.emit({ type: "catalog:added", skillId });
+      return { added: true, pending: false, expanded };
+    }
+    if (result.pending.length > 0) {
+      return { added: false, pending: true, expanded: false };
+    }
+    return { added: false, pending: false, expanded: false };
+  }
   // ===========================================================================
   // RENDERING
   // ===========================================================================
   /**
-   * Render current state as system prompt content
+   * Render current state as system prompt content.
+   * Includes catalog overview when catalog is enabled.
    */
-  renderSystemPrompt() {
+  async renderSystemPrompt() {
+    let prompt;
     if (this.config.outputFormat === "markdown") {
-      return this.viewRenderer.renderMarkdown(this.state);
+      prompt = this.viewRenderer.renderMarkdown(this.state);
+    } else {
+      prompt = this.viewRenderer.renderXml(this.state);
+    }
+    if (this.catalogRenderer) {
+      const overview = await this.catalogRenderer.renderOverview();
+      if (overview) {
+        prompt += "\n" + overview;
+      }
     }
-    return this.viewRenderer.renderXml(this.state);
+    return prompt;
   }
   /**
    * Estimate total tokens for current loadout
@@ -4257,7 +4537,7 @@ function resolveSkilltreeDir(repoRoot) {
   if (fs4.existsSync(swarmDir)) return swarmDir;
   return path4.join(repoRoot, ".skilltree");
 }
-var DEFAULT_CONFIG4 = {
+var DEFAULT_CONFIG5 = {
   version: 1,
   discovery: "default",
   paths: ["skills"],
@@ -4285,7 +4565,7 @@ function getSkilltreeDir(repoRoot) {
 }
 function getSkillsDir(repoRoot, config2) {
   const skilltreeDir = getSkilltreeDir(repoRoot);
-  const paths = config2?.paths || DEFAULT_CONFIG4.paths;
+  const paths = config2?.paths || DEFAULT_CONFIG5.paths;
   return path4.join(skilltreeDir, paths[0]);
 }
 function parseSkilltreeConfig(content) {
@@ -4298,10 +4578,10 @@ function validateConfig(config2) {
   }
   return {
     version: 1,
-    discovery: config2.discovery || DEFAULT_CONFIG4.discovery,
-    paths: config2.paths || DEFAULT_CONFIG4.paths,
-    exclude: [...DEFAULT_CONFIG4.exclude || [], ...config2.exclude || []],
-    skillFilePatterns: config2.skillFilePatterns || DEFAULT_CONFIG4.skillFilePatterns,
+    discovery: config2.discovery || DEFAULT_CONFIG5.discovery,
+    paths: config2.paths || DEFAULT_CONFIG5.paths,
+    exclude: [...DEFAULT_CONFIG5.exclude || [], ...config2.exclude || []],
+    skillFilePatterns: config2.skillFilePatterns || DEFAULT_CONFIG5.skillFilePatterns,
     namespace: config2.namespace
   };
 }
@@ -4312,7 +4592,7 @@ async function loadSkilltreeConfig(repoRoot) {
     return parseSkilltreeConfig(content);
   } catch (error) {
     if (error.code === "ENOENT") {
-      return { ...DEFAULT_CONFIG4 };
+      return { ...DEFAULT_CONFIG5 };
     }
     throw error;
   }
@@ -4347,7 +4627,7 @@ async function initSkilltreeDir(repoRoot, config2) {
     );
   }
 }
-function isSkillFile(filename, patterns = DEFAULT_CONFIG4.skillFilePatterns) {
+function isSkillFile(filename, patterns = DEFAULT_CONFIG5.skillFilePatterns) {
   const lower = filename.toLowerCase();
   for (const pattern of patterns) {
     if (pattern.includes("*")) {
@@ -4380,7 +4660,7 @@ async function discoverSkills(repoRoot) {
   if (config2.discovery === "scan") {
     await scanForSkills(skilltreeDir, skilltreeDir, config2, discovered);
   } else {
-    const paths = config2.paths || DEFAULT_CONFIG4.paths;
+    const paths = config2.paths || DEFAULT_CONFIG5.paths;
     for (const searchPath of paths) {
       const fullPath = path4.join(skilltreeDir, searchPath);
       await scanForSkills(skilltreeDir, fullPath, config2, discovered);
@@ -7496,11 +7776,12 @@ function createDefaultSyncConfig(remoteUrl, agentId, options) {
   };
 }
 
-// src/index.ts
-var VERSION = "0.1.0";
+// src/services/indexer.ts
+var path12 = __toESM(require("path"));
+var fs12 = __toESM(require("fs"));
 
 // src/config/types.ts
-var DEFAULT_CONFIG5 = {
+var DEFAULT_CONFIG6 = {
   storage: {
     path: "~/.skill-tree"
   },
@@ -7701,7 +7982,7 @@ var ConfigLoader = class {
   constructor(configPath) {
     this.loaded = false;
     this.configPath = configPath || getConfigPath();
-    this.config = { ...DEFAULT_CONFIG5 };
+    this.config = { ...DEFAULT_CONFIG6 };
   }
   /**
    * Load configuration from all sources
@@ -7714,7 +7995,7 @@ var ConfigLoader = class {
     if (this.loaded) {
       return this.config;
     }
-    let config2 = deepMerge({}, DEFAULT_CONFIG5);
+    let config2 = deepMerge({}, DEFAULT_CONFIG6);
     const fileConfig = loadConfigFromFile(this.configPath);
     if (fileConfig) {
       config2 = deepMerge(config2, fileConfig);
@@ -7828,1426 +8109,1538 @@ function loadConfig(configPath) {
   return getConfigLoader(configPath).load();
 }
 
-// src/cli/commands/list.ts
-var import_commander = require("commander");
-
-// src/cli/utils/paths.ts
-var fs12 = __toESM(require("fs"));
-var path12 = __toESM(require("path"));
-var os2 = __toESM(require("os"));
-var DEFAULT_PATHS = [
-  ".claude/skills",
-  // Project local (Claude)
-  ".agent/skills",
-  // Project local (universal)
-  "~/.claude/skills",
-  // User global (Claude)
-  "~/.agent/skills"
-  // User global (universal)
-];
-function expandHome(p) {
-  if (p.startsWith("~/")) {
-    return path12.join(os2.homedir(), p.slice(2));
+// src/import/converter.ts
+function convertIndexerSkill(indexerSkill) {
+  const warnings = [];
+  const instructions = indexerSkill.content || "";
+  const hasStructuredContent = instructions.trim().length > 0;
+  if (!hasStructuredContent) {
+    warnings.push("No content found, instructions will be empty");
   }
-  return p;
-}
-function dirExists(p) {
-  try {
-    return fs12.statSync(p).isDirectory();
-  } catch {
-    return false;
+  const tags = [...indexerSkill.tags || []];
+  if (indexerSkill.sourceRepo) {
+    const repoName = indexerSkill.sourceRepo.split("/").pop();
+    if (repoName && !tags.includes(repoName)) {
+      tags.push(repoName);
+    }
   }
+  const status = indexerSkill.status === "indexed" ? "active" : indexerSkill.status === "raw" ? "draft" : "draft";
+  const skill = {
+    id: indexerSkill.slug,
+    name: indexerSkill.displayName || indexerSkill.name,
+    version: indexerSkill.version,
+    description: indexerSkill.description,
+    instructions,
+    author: indexerSkill.author,
+    tags,
+    createdAt: new Date(indexerSkill.scrapedAt),
+    updatedAt: new Date(indexerSkill.updatedAt),
+    status,
+    metrics: {
+      usageCount: 0,
+      successRate: 0,
+      feedbackScores: []
+    },
+    source: {
+      type: "imported",
+      location: indexerSkill.sourceUrl,
+      importedAt: /* @__PURE__ */ new Date()
+    },
+    // Extended fields for indexed skills
+    taxonomy: indexerSkill.primaryPath ? {
+      primaryPath: indexerSkill.primaryPath,
+      secondaryPaths: indexerSkill.secondaryPaths,
+      confidence: indexerSkill.confidence
+    } : void 0,
+    externalSource: {
+      url: indexerSkill.sourceUrl,
+      repo: indexerSkill.sourceRepo,
+      scrapedAt: new Date(indexerSkill.scrapedAt)
+    }
+  };
+  return { skill, warnings, hasStructuredContent };
 }
-function resolveSkillPath(explicitPath) {
-  if (explicitPath) {
-    const resolved = expandHome(explicitPath);
-    return path12.resolve(resolved);
-  }
-  const envPath = process.env.SKILL_TREE_PATH;
-  if (envPath) {
-    return path12.resolve(expandHome(envPath));
+function convertIndexerSkills(skills) {
+  const results = [];
+  const converted = [];
+  for (const skill of skills) {
+    const result = convertIndexerSkill(skill);
+    results.push(result);
+    converted.push(result.skill);
   }
-  for (const defaultPath of DEFAULT_PATHS) {
-    const resolved = path12.resolve(expandHome(defaultPath));
-    if (dirExists(resolved)) {
-      return resolved;
+  return {
+    skills: converted,
+    results,
+    stats: {
+      total: results.length,
+      withStructuredContent: results.filter((r) => r.hasStructuredContent).length,
+      withWarnings: results.filter((r) => r.warnings.length > 0).length
     }
-  }
-  return path12.resolve(".claude/skills");
+  };
 }
-function ensureDir(dir) {
-  if (!dirExists(dir)) {
-    fs12.mkdirSync(dir, { recursive: true });
+function parseIndexerExport(content) {
+  const data = JSON.parse(content);
+  let indexerSkills;
+  let exportMetadata;
+  if (Array.isArray(data)) {
+    indexerSkills = data;
+  } else if (data.skills && Array.isArray(data.skills)) {
+    indexerSkills = data.skills;
+    exportMetadata = {
+      exportedAt: data.exportedAt,
+      originalStats: data.stats
+    };
+  } else {
+    throw new Error("Invalid indexer export format: expected array or object with skills array");
   }
+  const { skills, stats } = convertIndexerSkills(indexerSkills);
+  return { skills, stats, exportMetadata };
 }
 
-// src/cli/utils/skillbank.ts
-function getMaterializationConfig() {
-  const config2 = loadConfig();
-  const mat = config2.materialization;
-  if (!mat?.enabled) return void 0;
-  return {
-    enabled: true,
-    mode: mat.mode ?? "symlink",
-    symlinkPaths: mat.symlink_paths?.length ? mat.symlink_paths : void 0,
-    agentsMdPath: mat.agents_md_path || void 0,
-    agentsMdFormat: mat.agents_md_format ?? "xml",
-    debounceMs: mat.debounce_ms ?? 500
-  };
+// src/services/indexer.ts
+function hasIndexerSupport(storage) {
+  const s = storage;
+  return typeof s.addRelationship === "function" && typeof s.getTaxonomyTree === "function";
 }
-async function createSkillBankFromOptions(options) {
-  const skillPath = resolveSkillPath(options.path);
-  ensureDir(skillPath);
-  const skillBank = new SkillBank({
-    storage: {
-      basePath: skillPath,
-      openSkillsCompatible: true
-    },
-    materialization: getMaterializationConfig()
-  });
-  await skillBank.initialize();
-  return skillBank;
-}
-function getSkillPath(options) {
-  return resolveSkillPath(options.path);
-}
-var getSkillBank = createSkillBankFromOptions;
-
-// src/cli/utils/output.ts
-var import_chalk = __toESM(require("chalk"));
-function formatSkillLine(skill) {
-  const status = formatStatus(skill.status);
-  const version = import_chalk.default.dim(`v${skill.version}`);
-  const id = import_chalk.default.bold(skill.id);
-  const name = skill.name !== skill.id ? import_chalk.default.dim(` (${skill.name})`) : "";
-  const tags = skill.tags.length > 0 ? import_chalk.default.dim(` [${skill.tags.join(", ")}]`) : "";
-  return `${status} ${id}${name} ${version}${tags}`;
-}
-function formatStatus(status) {
-  switch (status) {
-    case "active":
-      return import_chalk.default.green("\u25CF");
-    case "draft":
-      return import_chalk.default.yellow("\u25CB");
-    case "deprecated":
-      return import_chalk.default.red("\u2717");
-    case "experimental":
-      return import_chalk.default.blue("\u25D0");
-    default:
-      return import_chalk.default.gray("?");
-  }
-}
-function formatSkillDetail(skill) {
-  const lines = [];
-  lines.push(import_chalk.default.bold(`${skill.name} v${skill.version}`));
-  lines.push(import_chalk.default.dim("\u2500".repeat(50)));
-  lines.push(`${import_chalk.default.dim("Status:")}    ${formatStatusLabel(skill.status)}`);
-  lines.push(`${import_chalk.default.dim("Author:")}    ${skill.author}`);
-  if (skill.tags.length > 0) {
-    lines.push(`${import_chalk.default.dim("Tags:")}      ${skill.tags.join(", ")}`);
-  }
-  if (skill.parentVersion) {
-    lines.push(`${import_chalk.default.dim("Parent:")}    v${skill.parentVersion}`);
-  }
-  if (skill.derivedFrom && skill.derivedFrom.length > 0) {
-    lines.push(`${import_chalk.default.dim("Derived:")}   ${skill.derivedFrom.join(", ")}`);
-  }
-  const { usageCount, successRate } = skill.metrics;
-  if (usageCount > 0) {
-    lines.push(`${import_chalk.default.dim("Usage:")}     ${usageCount} times, ${Math.round(successRate * 100)}% success`);
-  }
-  lines.push("");
-  lines.push(import_chalk.default.dim("Description"));
-  lines.push(import_chalk.default.dim("\u2500".repeat(50)));
-  lines.push(skill.description);
-  lines.push("");
-  if (skill.instructions) {
-    lines.push(import_chalk.default.dim("Instructions"));
-    lines.push(import_chalk.default.dim("\u2500".repeat(50)));
-    lines.push(skill.instructions);
-  }
-  return lines.join("\n");
-}
-function formatStatusLabel(status) {
-  switch (status) {
-    case "active":
-      return import_chalk.default.green("active");
-    case "draft":
-      return import_chalk.default.yellow("draft");
-    case "deprecated":
-      return import_chalk.default.red("deprecated");
-    case "experimental":
-      return import_chalk.default.blue("experimental");
-    default:
-      return import_chalk.default.gray(status);
-  }
-}
-function formatVersionHistory(versions) {
-  const lines = [];
-  lines.push(import_chalk.default.bold("Version History"));
-  lines.push(import_chalk.default.dim("\u2500".repeat(50)));
-  for (const v of versions.reverse()) {
-    const date = v.createdAt.toISOString().split("T")[0];
-    const hash = import_chalk.default.dim(`#${v.contentHash.slice(0, 7)}`);
-    const changelog = v.changelog ? ` - ${v.changelog}` : "";
-    lines.push(`  ${import_chalk.default.cyan(`v${v.version}`)} ${import_chalk.default.dim(date)} ${hash}${changelog}`);
-  }
-  return lines.join("\n");
-}
-function formatDiff(versionA, versionB, changes) {
-  const lines = [];
-  lines.push(import_chalk.default.bold(`Diff: v${versionA} \u2192 v${versionB}`));
-  lines.push(import_chalk.default.dim("\u2500".repeat(50)));
-  if (changes.modified.length === 0 && changes.added.length === 0 && changes.removed.length === 0) {
-    lines.push(import_chalk.default.dim("No changes"));
-    return lines.join("\n");
-  }
-  for (const mod of changes.modified) {
-    lines.push(import_chalk.default.yellow(`~ ${mod.field}`));
-    lines.push(import_chalk.default.red(`  - ${truncate(mod.oldValue, 60)}`));
-    lines.push(import_chalk.default.green(`  + ${truncate(mod.newValue, 60)}`));
-  }
-  for (const add of changes.added) {
-    lines.push(import_chalk.default.green(`+ ${add.type}: ${add.value}`));
-  }
-  for (const rem of changes.removed) {
-    lines.push(import_chalk.default.red(`- ${rem.type}: ${rem.value}`));
-  }
-  return lines.join("\n");
-}
-function formatStats(stats) {
-  const lines = [];
-  lines.push(import_chalk.default.bold("Skill Bank Statistics"));
-  lines.push(import_chalk.default.dim("\u2500".repeat(50)));
-  lines.push(`${import_chalk.default.dim("Total skills:")}  ${stats.totalSkills}`);
-  lines.push("");
-  lines.push(import_chalk.default.dim("By Status:"));
-  lines.push(`  ${import_chalk.default.green("\u25CF")} Active:       ${stats.byStatus.active}`);
-  lines.push(`  ${import_chalk.default.yellow("\u25CB")} Draft:        ${stats.byStatus.draft}`);
-  lines.push(`  ${import_chalk.default.blue("\u25D0")} Experimental: ${stats.byStatus.experimental}`);
-  lines.push(`  ${import_chalk.default.red("\u2717")} Deprecated:   ${stats.byStatus.deprecated}`);
-  lines.push("");
-  if (Object.keys(stats.byTag).length > 0) {
-    lines.push(import_chalk.default.dim("By Tag:"));
-    const sortedTags = Object.entries(stats.byTag).sort((a, b) => b[1] - a[1]);
-    for (const [tag, count] of sortedTags.slice(0, 10)) {
-      lines.push(`  ${tag}: ${count}`);
-    }
-    lines.push("");
-  }
-  if (stats.totalUsage > 0) {
-    lines.push(import_chalk.default.dim("Usage:"));
-    lines.push(`  Total uses:      ${stats.totalUsage}`);
-    lines.push(`  Avg success:     ${Math.round(stats.avgSuccessRate * 100)}%`);
+var IndexerService = class {
+  constructor(config2 = {}, skillBank) {
+    this.initialized = false;
+    this.globalConfig = loadConfig();
+    this.serviceConfig = {
+      githubToken: config2.githubToken || this.globalConfig.indexer.github_token,
+      anthropicApiKey: config2.anthropicApiKey || this.globalConfig.indexer.anthropic_key,
+      batchSize: config2.batchSize || this.globalConfig.indexer.batch_size,
+      minConfidence: config2.minConfidence || this.globalConfig.indexer.min_confidence,
+      concurrency: config2.concurrency || 3,
+      cacheTtlSeconds: config2.cacheTtlSeconds || 3600,
+      databasePath: config2.databasePath,
+      cacheDir: config2.cacheDir,
+      claudeModel: config2.claudeModel,
+      scraperModules: config2.scraperModules
+    };
+    this.skillBank = skillBank;
   }
-  return lines.join("\n");
-}
-function printError(message) {
-  console.error(import_chalk.default.red(`Error: ${message}`));
-}
-function printSuccess(message) {
-  console.log(import_chalk.default.green(`\u2713 ${message}`));
-}
-function printWarning(message) {
-  console.log(import_chalk.default.yellow(`\u26A0 ${message}`));
-}
-function printInfo(message) {
-  console.log(import_chalk.default.dim(message));
-}
-function truncate(text, maxLength) {
-  const oneLine = text.replace(/\n/g, " ");
-  if (oneLine.length <= maxLength) return oneLine;
-  return oneLine.slice(0, maxLength - 3) + "...";
-}
-
-// src/cli/commands/list.ts
-var listCommand = new import_commander.Command("list").description("List all skills").option("-s, --status <status>", "Filter by status (active, draft, deprecated, experimental)").option("-t, --tag <tag>", "Filter by tag").option("-a, --author <author>", "Filter by author").action(async (options, command) => {
-  const globalOpts = command.optsWithGlobals();
-  try {
-    const skillBank = await createSkillBankFromOptions(globalOpts);
-    const filter = {};
-    if (options.status) {
-      filter.status = [options.status];
-    }
-    if (options.tag) {
-      filter.tags = [options.tag];
-    }
-    if (options.author) {
-      filter.author = options.author;
-    }
-    const skills = await skillBank.listSkills(
-      Object.keys(filter).length > 0 ? filter : void 0
-    );
-    if (globalOpts.json) {
-      console.log(JSON.stringify(skills, null, 2));
-      return;
-    }
-    if (skills.length === 0) {
-      printInfo(`No skills found in ${getSkillPath(globalOpts)}`);
-      return;
-    }
-    if (!globalOpts.quiet) {
-      printInfo(`Skills in ${getSkillPath(globalOpts)}:
-`);
-    }
-    for (const skill of skills) {
-      console.log(formatSkillLine(skill));
-    }
-    if (!globalOpts.quiet) {
-      console.log();
-      printInfo(`${skills.length} skill(s)`);
-    }
-  } catch (error) {
-    printError(error.message);
-    process.exit(1);
+  /**
+   * Get effective configuration
+   */
+  getConfig() {
+    return { ...this.serviceConfig };
   }
-});
-
-// src/cli/commands/show.ts
-var import_commander2 = require("commander");
-var showCommand = new import_commander2.Command("show").description("Show skill details").argument("<id>", "Skill ID").option("-v, --version <version>", "Show specific version").action(async (id, options, command) => {
-  const globalOpts = command.optsWithGlobals();
-  try {
-    const skillBank = await createSkillBankFromOptions(globalOpts);
-    const skill = await skillBank.getSkill(id, options.version);
-    if (!skill) {
-      printError(`Skill not found: ${id}${options.version ? `@${options.version}` : ""}`);
-      process.exit(1);
-    }
-    if (globalOpts.json) {
-      console.log(JSON.stringify(skill, null, 2));
-      return;
+  /**
+   * Initialize the service (lazy load scraper modules)
+   */
+  async initialize() {
+    if (this.initialized) return;
+    try {
+      if (this.serviceConfig.scraperModules) {
+        const mod = this.serviceConfig.scraperModules;
+        this.databaseModule = mod;
+        if (mod.createDatabase) {
+          const dbPath = this.serviceConfig.databasePath || path12.join(process.cwd(), "scraper/data/skills.db");
+          const dbDir = path12.dirname(dbPath);
+          if (!fs12.existsSync(dbDir)) fs12.mkdirSync(dbDir, { recursive: true });
+          this.db = mod.createDatabase({ type: "sqlite", path: dbPath });
+          if (this.db.connect) await this.db.connect();
+          if (this.db.migrate) await this.db.migrate();
+        }
+        const localDb = this.db;
+        if (mod.ScraperService) {
+          this.scraperModule = {
+            createScraper: (config2) => {
+              const scraperConfig = {
+                githubToken: config2.githubToken || "",
+                cacheEnabled: true,
+                cacheDir: config2.cacheDir || path12.join(process.cwd(), ".cache/scraper"),
+                cacheTtlSeconds: config2.cacheTtlSeconds || 3600,
+                requestDelayMs: 100,
+                maxRetries: 3
+              };
+              const svc = new mod.ScraperService(localDb, scraperConfig);
+              let initialized = false;
+              const ensureInit = async () => {
+                if (!initialized) {
+                  await svc.init();
+                  initialized = true;
+                }
+              };
+              return {
+                scrapeAwesomeList: async (url, opts) => {
+                  await ensureInit();
+                  await svc.scrape({ type: "awesome-list", url }, opts);
+                  return await localDb.listSkills() || [];
+                },
+                scrapeRepository: async (url, opts) => {
+                  await ensureInit();
+                  await svc.scrape({ type: "repository", url }, opts);
+                  return await localDb.listSkills() || [];
+                }
+              };
+            }
+          };
+        }
+        if (mod.SkillClassifier) {
+          this.indexerModule = {
+            createIndexer: (config2) => {
+              const classifier = new mod.SkillClassifier(config2);
+              return {
+                classifySkill: async (skill) => {
+                  let tree = null;
+                  if (mod.TaxonomyManager && localDb) {
+                    try {
+                      const tm = new mod.TaxonomyManager(localDb);
+                      tree = await tm.getTree();
+                    } catch {
+                    }
+                  }
+                  return classifier.classify(skill, tree);
+                }
+              };
+            }
+          };
+        }
+        this.initialized = true;
+        return;
+      }
+      const possiblePaths = [
+        // Relative to this file in dist
+        path12.resolve(__dirname, "../../scraper/dist"),
+        // Relative to project root
+        path12.resolve(process.cwd(), "scraper/dist"),
+        // Absolute paths from config
+        this.serviceConfig.cacheDir ? path12.resolve(this.serviceConfig.cacheDir, "../scraper/dist") : null
+      ].filter(Boolean);
+      let scraperBasePath = null;
+      for (const basePath of possiblePaths) {
+        const scraperIndex = path12.join(basePath, "scraper/index.js");
+        if (fs12.existsSync(scraperIndex)) {
+          scraperBasePath = basePath;
+          break;
+        }
+      }
+      if (!scraperBasePath) {
+        throw new Error(
+          "Scraper modules not found. Run `cd scraper && npm run build` first."
+        );
+      }
+      const scraperPath = path12.join(scraperBasePath, "scraper/index.js");
+      const indexerPath = path12.join(scraperBasePath, "indexer/index.js");
+      const databasePath = path12.join(scraperBasePath, "database/index.js");
+      this.scraperModule = await import(
+        /* webpackIgnore: true */
+        scraperPath
+      );
+      this.indexerModule = await import(
+        /* webpackIgnore: true */
+        indexerPath
+      );
+      this.databaseModule = await import(
+        /* webpackIgnore: true */
+        databasePath
+      );
+      if (this.databaseModule.createDatabase) {
+        const dbPath = this.serviceConfig.databasePath || path12.join(process.cwd(), "scraper/data/skills.db");
+        this.db = this.databaseModule.createDatabase(dbPath);
+      }
+      this.initialized = true;
+    } catch (err) {
+      console.warn(`Scraper modules not available: ${err.message}`);
+      console.warn("Some indexer features will be limited.");
+      this.initialized = true;
     }
-    console.log(formatSkillDetail(skill));
-  } catch (error) {
-    printError(error.message);
-    process.exit(1);
   }
-});
-
-// src/cli/commands/search.ts
-var import_commander3 = require("commander");
-var searchCommand = new import_commander3.Command("search").description("Search skills by text").argument("<query>", "Search query").action(async (query, options, command) => {
-  const globalOpts = command.optsWithGlobals();
-  try {
-    const skillBank = await createSkillBankFromOptions(globalOpts);
-    const skills = await skillBank.searchSkills(query);
-    if (globalOpts.json) {
-      console.log(JSON.stringify(skills, null, 2));
-      return;
-    }
-    if (skills.length === 0) {
-      printInfo(`No skills found matching "${query}"`);
-      return;
-    }
-    if (!globalOpts.quiet) {
-      printInfo(`Results for "${query}":
-`);
-    }
-    for (const skill of skills) {
-      console.log(formatSkillLine(skill));
-    }
-    if (!globalOpts.quiet) {
-      console.log();
-      printInfo(`${skills.length} result(s)`);
-    }
-  } catch (error) {
-    printError(error.message);
-    process.exit(1);
+  /**
+   * Check if the indexer is available
+   */
+  isAvailable() {
+    return this.initialized && !!this.scraperModule;
   }
-});
-
-// src/cli/commands/stats.ts
-var import_commander4 = require("commander");
-var statsCommand = new import_commander4.Command("stats").description("Show skill bank statistics").action(async (options, command) => {
-  const globalOpts = command.optsWithGlobals();
-  try {
-    const skillBank = await createSkillBankFromOptions(globalOpts);
-    const stats = await skillBank.getStats();
-    if (globalOpts.json) {
-      console.log(JSON.stringify(stats, null, 2));
-      return;
-    }
-    console.log(formatStats(stats));
-  } catch (error) {
-    printError(error.message);
-    process.exit(1);
+  /**
+   * Check if running in degraded mode (no scraper modules)
+   */
+  isDegradedMode() {
+    return this.initialized && !this.scraperModule;
   }
-});
-
-// src/cli/commands/versions.ts
-var import_commander5 = require("commander");
-var versionsCommand = new import_commander5.Command("versions").description("Show version history for a skill").argument("<id>", "Skill ID").action(async (id, options, command) => {
-  const globalOpts = command.optsWithGlobals();
-  try {
-    const skillBank = await createSkillBankFromOptions(globalOpts);
-    const versions = await skillBank.getVersionHistory(id);
-    if (versions.length === 0) {
-      printInfo(`No version history found for: ${id}`);
-      return;
+  /**
+   * Scrape skills from GitHub sources
+   */
+  async scrape(sources, options) {
+    await this.initialize();
+    if (!this.scraperModule || !this.db) {
+      throw new Error(
+        "Scraper not available. Build the scraper module first: cd scraper && npm run build"
+      );
     }
-    if (globalOpts.json) {
-      console.log(JSON.stringify(versions, null, 2));
-      return;
+    const result = {
+      discovered: 0,
+      scraped: 0,
+      skipped: 0,
+      failed: 0,
+      unchanged: 0,
+      errors: []
+    };
+    try {
+      const scraper = this.scraperModule.createScraper({
+        githubToken: this.serviceConfig.githubToken,
+        cacheDir: this.serviceConfig.cacheDir,
+        cacheTtlSeconds: this.serviceConfig.cacheTtlSeconds
+      });
+      for (const source of sources) {
+        try {
+          let skills;
+          if (source.type === "awesome-list") {
+            skills = await scraper.scrapeAwesomeList(source.url, {
+              force: options?.force
+            });
+          } else {
+            skills = await scraper.scrapeRepository(source.url, {
+              force: options?.force
+            });
+          }
+          result.discovered += skills.length;
+          for (const skill of skills) {
+            try {
+              const existing = this.db.getSkillBySlug?.(skill.slug);
+              if (existing && !options?.force) {
+                result.unchanged++;
+              } else {
+                this.db.saveSkill?.(skill);
+                result.scraped++;
+              }
+            } catch (err) {
+              result.failed++;
+              result.errors.push(
+                `Failed to save skill ${skill.slug}: ${err.message}`
+              );
+            }
+          }
+        } catch (err) {
+          result.failed++;
+          result.errors.push(
+            `Failed to scrape ${source.url}: ${err.message}`
+          );
+        }
+      }
+    } catch (err) {
+      result.errors.push(`Scrape failed: ${err.message}`);
     }
-    console.log(formatVersionHistory(versions));
-  } catch (error) {
-    printError(error.message);
-    process.exit(1);
+    return result;
   }
-});
-
-// src/cli/commands/diff.ts
-var import_commander6 = require("commander");
-var diffCommand = new import_commander6.Command("diff").description("Compare two versions of a skill").argument("<id>", "Skill ID").argument("<version-a>", "First version").argument("<version-b>", "Second version").action(async (id, versionA, versionB, options, command) => {
-  const globalOpts = command.optsWithGlobals();
-  try {
-    const skillBank = await createSkillBankFromOptions(globalOpts);
-    const diff = await skillBank.compareVersions(id, versionA, versionB);
-    if (globalOpts.json) {
-      console.log(JSON.stringify(diff, null, 2));
-      return;
+  /**
+   * Classify unindexed skills using AI
+   */
+  async classify(options) {
+    await this.initialize();
+    if (!this.indexerModule || !this.db) {
+      throw new Error(
+        "Indexer not available. Build the scraper module first: cd scraper && npm run build"
+      );
     }
-    console.log(formatDiff(diff.versionA, diff.versionB, diff.changes));
-  } catch (error) {
-    printError(error.message);
-    process.exit(1);
-  }
-});
-
-// src/cli/commands/rollback.ts
-var import_commander7 = require("commander");
-var rollbackCommand = new import_commander7.Command("rollback").description("Rollback a skill to a previous version").argument("<id>", "Skill ID").requiredOption("--to <version>", "Version to rollback to").action(async (id, options, command) => {
-  const globalOpts = command.optsWithGlobals();
-  try {
-    const skillBank = await createSkillBankFromOptions(globalOpts);
-    const skill = await skillBank.rollbackSkill(id, options.to);
-    if (globalOpts.json) {
-      console.log(JSON.stringify(skill, null, 2));
-      return;
+    const result = {
+      indexed: 0,
+      skipped: 0,
+      failed: 0,
+      errors: []
+    };
+    try {
+      const indexer = this.indexerModule.createIndexer({
+        anthropicApiKey: this.serviceConfig.anthropicApiKey,
+        model: this.serviceConfig.claudeModel || "claude-sonnet-4-20250514",
+        minConfidence: this.serviceConfig.minConfidence
+      });
+      let skills;
+      if (options?.skillId) {
+        const skill = this.db.getSkillBySlug?.(options.skillId);
+        skills = skill ? [skill] : [];
+      } else if (options?.all) {
+        skills = this.db.getAllSkills?.() || [];
+      } else {
+        skills = this.db.getSkillsByStatus?.("raw") || [];
+      }
+      const batchSize = this.serviceConfig.batchSize || 10;
+      for (let i = 0; i < skills.length; i += batchSize) {
+        const batch = skills.slice(i, i + batchSize);
+        for (const skill of batch) {
+          if (skill.status === "indexed" && !options?.all) {
+            result.skipped++;
+            continue;
+          }
+          try {
+            const classification = await indexer.classifySkill(skill);
+            skill.status = "indexed";
+            skill.primaryPath = classification.primaryPath;
+            skill.secondaryPaths = classification.secondaryPaths;
+            skill.confidence = classification.confidence;
+            skill.classificationReasoning = classification.reasoning;
+            skill.indexedAt = (/* @__PURE__ */ new Date()).toISOString();
+            this.db.saveSkill?.(skill);
+            result.indexed++;
+          } catch (err) {
+            result.failed++;
+            result.errors.push(
+              `Failed to classify ${skill.slug}: ${err.message}`
+            );
+          }
+        }
+      }
+    } catch (err) {
+      result.errors.push(`Classification failed: ${err.message}`);
     }
-    printSuccess(`Rolled back ${id} to v${options.to} (new version: v${skill.version})`);
-  } catch (error) {
-    printError(error.message);
-    process.exit(1);
+    return result;
   }
-});
-
-// src/cli/commands/fork.ts
-var import_commander8 = require("commander");
-var forkCommand = new import_commander8.Command("fork").description("Fork a skill to create a variant").argument("<id>", "Skill ID to fork from").requiredOption("--new-id <id>", "ID for the new forked skill").requiredOption("--reason <reason>", "Reason for forking").option("--name <name>", "Name for the forked skill").option("--from-version <version>", "Version to fork from (defaults to latest)").action(async (id, options, command) => {
-  const globalOpts = command.optsWithGlobals();
-  try {
-    const skillBank = await createSkillBankFromOptions(globalOpts);
-    const forked = await skillBank.forkSkill(id, {
-      newId: options.newId,
-      newName: options.name,
-      reason: options.reason,
-      fromVersion: options.fromVersion
-    });
-    if (globalOpts.json) {
-      console.log(JSON.stringify(forked, null, 2));
-      return;
+  /**
+   * Detect relationships between skills
+   */
+  async detectRelationships(options) {
+    await this.initialize();
+    const result = {
+      detected: 0,
+      skipped: 0,
+      errors: []
+    };
+    if (this.skillBank) {
+      try {
+        const storage = this.skillBank.getStorage();
+        if (hasIndexerSupport(storage)) {
+          const skills = await this.skillBank.listSkills();
+          const targetSkills = options?.skillId ? skills.filter((s) => s.id === options.skillId) : skills;
+          for (const skill of targetSkills) {
+            const relationships = this.detectSkillRelationships(skill, skills);
+            for (const rel of relationships) {
+              try {
+                await storage.addRelationship(
+                  skill.id,
+                  rel.targetSkillId,
+                  rel.type,
+                  rel.confidence,
+                  rel.reasoning
+                );
+                result.detected++;
+              } catch (err) {
+                result.skipped++;
+              }
+            }
+          }
+        }
+      } catch (err) {
+        result.errors.push(
+          `Relationship detection failed: ${err.message}`
+        );
+      }
+      return result;
     }
-    printSuccess(`Forked ${id} \u2192 ${forked.id} (v${forked.version})`);
-  } catch (error) {
-    printError(error.message);
-    process.exit(1);
+    if (!this.db) {
+      throw new Error("Neither SkillBank nor scraper database available.");
+    }
+    try {
+      const skills = this.db.getAllSkills?.() || [];
+      const targetSkills = options?.skillId ? skills.filter((s) => s.slug === options.skillId) : skills.filter((s) => s.status === "indexed");
+      for (const skill of targetSkills) {
+        const relationships = this.detectSkillRelationships(skill, skills);
+        for (const rel of relationships) {
+          try {
+            this.db.saveRelationship?.({
+              sourceSkillId: skill.id,
+              ...rel
+            });
+            result.detected++;
+          } catch (err) {
+            result.skipped++;
+          }
+        }
+      }
+    } catch (err) {
+      result.errors.push(
+        `Relationship detection failed: ${err.message}`
+      );
+    }
+    return result;
   }
-});
-
-// src/cli/commands/deprecate.ts
-var import_commander9 = require("commander");
-var deprecateCommand = new import_commander9.Command("deprecate").description("Mark a skill as deprecated").argument("<id>", "Skill ID").action(async (id, options, command) => {
-  const globalOpts = command.optsWithGlobals();
-  try {
-    const skillBank = await createSkillBankFromOptions(globalOpts);
-    const skill = await skillBank.deprecateSkill(id);
-    if (globalOpts.json) {
-      console.log(JSON.stringify(skill, null, 2));
-      return;
+  /**
+   * Detect relationships for a single skill
+   */
+  detectSkillRelationships(skill, allSkills) {
+    const relationships = [];
+    const skillId = skill.id || skill.slug;
+    const skillContent = `${skill.name} ${skill.description} ${skill.instructions || ""} ${skill.content || ""}`.toLowerCase();
+    for (const other of allSkills) {
+      const otherId = other.id || other.slug;
+      if (otherId === skillId) continue;
+      const otherName = (other.name || "").toLowerCase();
+      const dependencyPatterns = [
+        "requires",
+        "depends on",
+        "uses",
+        "needs",
+        "builds on"
+      ];
+      for (const pattern of dependencyPatterns) {
+        if (skillContent.includes(`${pattern} ${otherName}`)) {
+          relationships.push({
+            targetSkillId: otherId,
+            type: "depends_on",
+            confidence: 0.7,
+            reasoning: `Content mentions "${pattern} ${other.name}"`
+          });
+          break;
+        }
+      }
+      const extensionPatterns = [
+        "extends",
+        "improves",
+        "enhances",
+        "builds upon"
+      ];
+      for (const pattern of extensionPatterns) {
+        if (skillContent.includes(`${pattern} ${otherName}`)) {
+          relationships.push({
+            targetSkillId: otherId,
+            type: "extends",
+            confidence: 0.7,
+            reasoning: `Content mentions "${pattern} ${other.name}"`
+          });
+          break;
+        }
+      }
+      const alternativePatterns = [
+        "alternative to",
+        "instead of",
+        "replacement for"
+      ];
+      for (const pattern of alternativePatterns) {
+        if (skillContent.includes(`${pattern} ${otherName}`)) {
+          relationships.push({
+            targetSkillId: otherId,
+            type: "alternative",
+            confidence: 0.6,
+            reasoning: `Content mentions "${pattern} ${other.name}"`
+          });
+          break;
+        }
+      }
+      const skillPath = skill.taxonomy?.primaryPath || skill.primaryPath || [];
+      const otherPath = other.taxonomy?.primaryPath || other.primaryPath || [];
+      if (skillPath.length >= 2 && otherPath.length >= 2) {
+        if (skillPath[0] === otherPath[0] && skillPath[1] === otherPath[1]) {
+          relationships.push({
+            targetSkillId: otherId,
+            type: "related",
+            confidence: 0.5,
+            reasoning: `Same taxonomy category: ${skillPath.slice(0, 2).join(" > ")}`
+          });
+        }
+      }
     }
-    printSuccess(`Deprecated: ${id} (v${skill.version})`);
-  } catch (error) {
-    printError(error.message);
-    process.exit(1);
+    return relationships;
   }
-});
-
-// src/cli/commands/activate.ts
-var import_commander10 = require("commander");
-var activateCommand = new import_commander10.Command("activate").description("Mark a skill as active").argument("<id>", "Skill ID").action(async (id, options, command) => {
-  const globalOpts = command.optsWithGlobals();
-  try {
-    const skillBank = await createSkillBankFromOptions(globalOpts);
-    const skill = await skillBank.getSkill(id);
-    if (!skill) {
-      printError(`Skill not found: ${id}`);
-      process.exit(1);
-    }
-    skill.status = "active";
-    skill.updatedAt = /* @__PURE__ */ new Date();
-    await skillBank.saveSkill(skill);
-    if (globalOpts.json) {
-      console.log(JSON.stringify(skill, null, 2));
-      return;
+  /**
+   * Get taxonomy tree
+   */
+  async getTaxonomyTree(rootPath) {
+    await this.initialize();
+    if (this.skillBank) {
+      const storage = this.skillBank.getStorage();
+      if (hasIndexerSupport(storage)) {
+        const nodes = await storage.getTaxonomyTree(rootPath);
+        return this.wrapTreeNodes(nodes, rootPath);
+      }
     }
-    printSuccess(`Activated: ${id} (v${skill.version})`);
-  } catch (error) {
-    printError(error.message);
-    process.exit(1);
+    const skills = this.skillBank ? await this.skillBank.listSkills() : this.db?.getAllSkills?.() || [];
+    return this.buildTaxonomyTreeFromSkills(skills, rootPath);
   }
-});
-
-// src/cli/commands/delete.ts
-var import_commander11 = require("commander");
-var deleteCommand = new import_commander11.Command("delete").description("Delete a skill").argument("<id>", "Skill ID").option("-f, --force", "Skip confirmation").option("-v, --version <version>", "Delete specific version only").action(async (id, options, command) => {
-  const globalOpts = command.optsWithGlobals();
-  try {
-    const skillBank = await createSkillBankFromOptions(globalOpts);
-    const skill = await skillBank.getSkill(id, options.version);
-    if (!skill) {
-      printError(`Skill not found: ${id}${options.version ? `@${options.version}` : ""}`);
-      process.exit(1);
-    }
-    if (!options.force) {
-      printWarning(`This will permanently delete ${id}${options.version ? `@${options.version}` : " and all versions"}`);
-      printWarning("Use --force to confirm");
-      process.exit(1);
-    }
-    const deleted = await skillBank.deleteSkill(id, options.version);
-    if (!deleted) {
-      printError(`Failed to delete: ${id}`);
-      process.exit(1);
-    }
-    if (globalOpts.json) {
-      console.log(JSON.stringify({ deleted: true, id, version: options.version }));
-      return;
+  /**
+   * Wrap tree nodes returned from SQLite storage into a root node
+   */
+  wrapTreeNodes(nodes, rootPath) {
+    const root = {
+      id: "root",
+      name: rootPath?.join(" > ") || "All Skills",
+      path: rootPath || [],
+      skillCount: 0,
+      children: []
+    };
+    for (const node of nodes) {
+      root.children.push(this.convertToTaxonomyNode(node));
+      root.skillCount += this.countNodeSkills(node);
     }
-    printSuccess(`Deleted: ${id}${options.version ? `@${options.version}` : ""}`);
-  } catch (error) {
-    printError(error.message);
-    process.exit(1);
+    return root;
   }
-});
-
-// src/cli/commands/export.ts
-var import_commander12 = require("commander");
-var fs13 = __toESM(require("fs"));
-var exportCommand = new import_commander12.Command("export").description("Export all skills to JSON").option("-o, --output <file>", "Output file path (defaults to stdout)").action(async (options, command) => {
-  const globalOpts = command.optsWithGlobals();
-  try {
-    const skillBank = await createSkillBankFromOptions(globalOpts);
-    const skills = await skillBank.exportAll();
-    const json = JSON.stringify(skills, null, 2);
-    if (options.output) {
-      fs13.writeFileSync(options.output, json, "utf-8");
-      if (!globalOpts.quiet) {
-        printSuccess(`Exported ${skills.length} skill(s) to ${options.output}`);
-      }
-    } else {
-      console.log(json);
-    }
-  } catch (error) {
-    printError(error.message);
-    process.exit(1);
+  /**
+   * Convert storage tree node to TaxonomyNode format
+   */
+  convertToTaxonomyNode(node) {
+    return {
+      id: node.id,
+      name: node.name,
+      path: Array.isArray(node.path) ? node.path : (node.path || "").split("/"),
+      skillCount: node.skillCount || 0,
+      children: (node.children || []).map(
+        (child) => this.convertToTaxonomyNode(child)
+      )
+    };
   }
-});
-
-// src/cli/commands/import.ts
-var import_commander13 = require("commander");
-var fs14 = __toESM(require("fs"));
-
-// src/import/converter.ts
-function convertIndexerSkill(indexerSkill) {
-  const warnings = [];
-  const instructions = indexerSkill.content || "";
-  const hasStructuredContent = instructions.trim().length > 0;
-  if (!hasStructuredContent) {
-    warnings.push("No content found, instructions will be empty");
+  /**
+   * Count total skills in a node tree
+   */
+  countNodeSkills(node) {
+    let count = node.skillCount || 0;
+    for (const child of node.children || []) {
+      count += this.countNodeSkills(child);
+    }
+    return count;
   }
-  const tags = [...indexerSkill.tags || []];
-  if (indexerSkill.sourceRepo) {
-    const repoName = indexerSkill.sourceRepo.split("/").pop();
-    if (repoName && !tags.includes(repoName)) {
-      tags.push(repoName);
+  /**
+   * Build taxonomy tree from flat nodes
+   */
+  buildTaxonomyTree(nodes, rootPath) {
+    const root = {
+      id: "root",
+      name: rootPath?.join(" > ") || "All Skills",
+      path: rootPath || [],
+      skillCount: 0,
+      children: []
+    };
+    const nodeMap = /* @__PURE__ */ new Map();
+    nodeMap.set("root", root);
+    for (const node of nodes) {
+      const taxNode = {
+        id: node.id,
+        name: node.name,
+        path: node.path,
+        skillCount: node.skillCount || 0,
+        children: []
+      };
+      nodeMap.set(node.id, taxNode);
+    }
+    for (const node of nodes) {
+      const taxNode = nodeMap.get(node.id);
+      const parentId = node.parentId || "root";
+      const parent = nodeMap.get(parentId);
+      if (parent) {
+        parent.children.push(taxNode);
+        parent.skillCount += taxNode.skillCount;
+      }
     }
+    return root;
   }
-  const status = indexerSkill.status === "indexed" ? "active" : indexerSkill.status === "raw" ? "draft" : "draft";
-  const skill = {
-    id: indexerSkill.slug,
-    name: indexerSkill.displayName || indexerSkill.name,
-    version: indexerSkill.version,
-    description: indexerSkill.description,
-    instructions,
-    author: indexerSkill.author,
-    tags,
-    createdAt: new Date(indexerSkill.scrapedAt),
-    updatedAt: new Date(indexerSkill.updatedAt),
-    status,
-    metrics: {
-      usageCount: 0,
-      successRate: 0,
-      feedbackScores: []
-    },
-    source: {
-      type: "imported",
-      location: indexerSkill.sourceUrl,
-      importedAt: /* @__PURE__ */ new Date()
-    },
-    // Extended fields for indexed skills
-    taxonomy: indexerSkill.primaryPath ? {
-      primaryPath: indexerSkill.primaryPath,
-      secondaryPaths: indexerSkill.secondaryPaths,
-      confidence: indexerSkill.confidence
-    } : void 0,
-    externalSource: {
-      url: indexerSkill.sourceUrl,
-      repo: indexerSkill.sourceRepo,
-      scrapedAt: new Date(indexerSkill.scrapedAt)
+  /**
+   * Build taxonomy tree from skills
+   */
+  buildTaxonomyTreeFromSkills(skills, rootPath) {
+    const root = {
+      id: "root",
+      name: rootPath?.join(" > ") || "All Skills",
+      path: rootPath || [],
+      skillCount: 0,
+      children: []
+    };
+    const nodeMap = /* @__PURE__ */ new Map();
+    for (const skill of skills) {
+      const taxonomy = skill.taxonomy || (skill.primaryPath ? { primaryPath: skill.primaryPath } : null);
+      if (!taxonomy?.primaryPath) continue;
+      const skillPath = taxonomy.primaryPath;
+      if (rootPath && rootPath.length > 0) {
+        let matches = true;
+        for (let i = 0; i < rootPath.length; i++) {
+          if (skillPath[i] !== rootPath[i]) {
+            matches = false;
+            break;
+          }
+        }
+        if (!matches) continue;
+      }
+      let currentPath = [];
+      let parent = root;
+      for (const segment of skillPath) {
+        currentPath = [...currentPath, segment];
+        const pathKey = currentPath.join("/");
+        let node = nodeMap.get(pathKey);
+        if (!node) {
+          node = {
+            id: pathKey,
+            name: segment,
+            path: [...currentPath],
+            skillCount: 0,
+            children: []
+          };
+          nodeMap.set(pathKey, node);
+          parent.children.push(node);
+        }
+        parent = node;
+      }
+      parent.skillCount++;
+      root.skillCount++;
     }
-  };
-  return { skill, warnings, hasStructuredContent };
-}
-function convertIndexerSkills(skills) {
-  const results = [];
-  const converted = [];
-  for (const skill of skills) {
-    const result = convertIndexerSkill(skill);
-    results.push(result);
-    converted.push(result.skill);
+    return root;
   }
-  return {
-    skills: converted,
-    results,
-    stats: {
-      total: results.length,
-      withStructuredContent: results.filter((r) => r.hasStructuredContent).length,
-      withWarnings: results.filter((r) => r.warnings.length > 0).length
+  /**
+   * Get indexer statistics
+   */
+  async getStats() {
+    await this.initialize();
+    if (this.skillBank) {
+      const skills = await this.skillBank.listSkills();
+      const storage = this.skillBank.getStorage();
+      let taxonomyNodes = 0;
+      let relationships = 0;
+      let sources = 0;
+      if (storage) {
+        if (hasIndexerSupport(storage)) {
+          const tree = await storage.getTaxonomyTree();
+          taxonomyNodes = this.countTaxonomyNodes(tree);
+          if (storage.getRelationships) {
+            for (const skill of skills) {
+              const rels = await storage.getRelationships(skill.id);
+              relationships += rels.length;
+            }
+          }
+        }
+        const sourceSet = /* @__PURE__ */ new Set();
+        for (const skill of skills) {
+          if (skill.externalSource?.repo) {
+            sourceSet.add(skill.externalSource.repo);
+          }
+          if (skill.source?.type === "imported" && skill.externalSource?.url) {
+            sourceSet.add(skill.externalSource.url);
+          }
+        }
+        sources = sourceSet.size;
+      }
+      const indexed = skills.filter(
+        (s) => s.status === "active" && (s.taxonomy || s.source?.type === "imported")
+      ).length;
+      return {
+        totalSkills: skills.length,
+        indexedSkills: indexed,
+        rawSkills: skills.filter((s) => s.status === "draft").length,
+        failedSkills: skills.filter((s) => s.status === "deprecated").length,
+        taxonomyNodes,
+        relationships,
+        sources
+      };
     }
-  };
-}
-function parseIndexerExport(content) {
-  const data = JSON.parse(content);
-  let indexerSkills;
-  let exportMetadata;
-  if (Array.isArray(data)) {
-    indexerSkills = data;
-  } else if (data.skills && Array.isArray(data.skills)) {
-    indexerSkills = data.skills;
-    exportMetadata = {
-      exportedAt: data.exportedAt,
-      originalStats: data.stats
+    if (this.db) {
+      const stats = this.db.getStats?.() || {};
+      return {
+        totalSkills: stats.totalSkills || 0,
+        indexedSkills: stats.indexedSkills || 0,
+        rawSkills: stats.rawSkills || 0,
+        failedSkills: stats.failedSkills || 0,
+        taxonomyNodes: stats.taxonomyNodes || 0,
+        relationships: stats.relationships || 0,
+        sources: stats.sources || 0
+      };
+    }
+    return {
+      totalSkills: 0,
+      indexedSkills: 0,
+      rawSkills: 0,
+      failedSkills: 0,
+      taxonomyNodes: 0,
+      relationships: 0,
+      sources: 0
     };
-  } else {
-    throw new Error("Invalid indexer export format: expected array or object with skills array");
   }
-  const { skills, stats } = convertIndexerSkills(indexerSkills);
-  return { skills, stats, exportMetadata };
-}
-
-// src/import/detect.ts
-function isSkillTreeSkill(obj) {
-  if (typeof obj !== "object" || obj === null) return false;
-  const skill = obj;
-  return typeof skill.id === "string" && typeof skill.name === "string" && typeof skill.version === "string" && typeof skill.instructions === "string" && typeof skill.metrics === "object";
-}
-function isIndexerSkill(obj) {
-  if (typeof obj !== "object" || obj === null) return false;
-  const skill = obj;
-  return typeof skill.slug === "string" && typeof skill.sourceRepo === "string" && typeof skill.sourcePath === "string" && typeof skill.sourceUrl === "string" && typeof skill.content === "string" && typeof skill.scrapedAt === "string" && (skill.status === "raw" || skill.status === "indexed" || skill.status === "failed");
-}
-function isIndexerExport(obj) {
-  if (typeof obj !== "object" || obj === null) return false;
-  const exp = obj;
-  return typeof exp.exportedAt === "string" && Array.isArray(exp.skills);
-}
-function detectFormat(data) {
-  if (Array.isArray(data)) {
-    if (data.length === 0) {
-      return { format: "unknown", confidence: 0, details: "Empty array" };
-    }
-    const first = data[0];
-    if (isIndexerSkill(first)) {
-      return { format: "indexer", confidence: 0.95, details: "Array of indexer skills" };
-    }
-    if (isSkillTreeSkill(first)) {
-      return { format: "skill-tree", confidence: 0.95, details: "Array of skill-tree skills" };
+  /**
+   * Count nodes in taxonomy tree
+   */
+  countTaxonomyNodes(nodes) {
+    let count = 0;
+    for (const node of nodes) {
+      count++;
+      if (node.children) {
+        count += this.countTaxonomyNodes(node.children);
+      }
     }
-    return { format: "unknown", confidence: 0.3, details: "Array of unknown objects" };
+    return count;
   }
-  if (typeof data === "object" && data !== null) {
-    if (isIndexerExport(data)) {
-      return { format: "indexer-export", confidence: 0.98, details: "Indexer export with metadata" };
+  /**
+   * Scrape and index skills directly into SkillBank
+   * This is the streamlined workflow for integrated mode
+   */
+  async scrapeAndIndex(sources, options) {
+    if (!this.skillBank) {
+      throw new Error(
+        "SkillBank required for scrapeAndIndex. Use integrated mode."
+      );
     }
-    if (isIndexerSkill(data)) {
-      return { format: "indexer", confidence: 0.9, details: "Single indexer skill" };
+    await this.initialize();
+    const skillsAdded = [];
+    const scraped = await this.scrape(sources, { force: options?.force });
+    let indexed = {
+      indexed: 0,
+      skipped: 0,
+      failed: 0,
+      errors: []
+    };
+    if (options?.autoClassify !== false) {
+      indexed = await this.classify({ all: options?.force });
     }
-    if (isSkillTreeSkill(data)) {
-      return { format: "skill-tree", confidence: 0.9, details: "Single skill-tree skill" };
+    if (this.db) {
+      const skills = await (this.db.getAllSkills?.() || this.db.listSkills?.()) || [];
+      for (const skill of skills) {
+        if (skill.status !== "indexed" && !options?.force && !options?.importAll) continue;
+        try {
+          const converted = convertIndexerSkill(skill);
+          await this.skillBank.saveSkill(converted.skill);
+          skillsAdded.push(converted.skill.id);
+        } catch (err) {
+          indexed.errors.push(
+            `Failed to import ${skill.slug}: ${err.message}`
+          );
+        }
+      }
     }
+    let relationships = {
+      detected: 0,
+      skipped: 0,
+      errors: []
+    };
+    if (options?.detectRelationships !== false) {
+      relationships = await this.detectRelationships();
+    }
+    return {
+      scraped,
+      indexed,
+      relationships,
+      skillsAdded
+    };
   }
-  return { format: "unknown", confidence: 0, details: "Unrecognized format" };
-}
-function detectFormatFromString(content) {
-  try {
-    const data = JSON.parse(content);
-    return detectFormat(data);
-  } catch {
-    return { format: "unknown", confidence: 0, details: "Invalid JSON" };
-  }
-}
-function isLikelyIndexerFormat(content) {
-  const result = detectFormatFromString(content);
-  return result.format === "indexer" || result.format === "indexer-export";
-}
-
-// src/cli/commands/import.ts
-var importCommand = new import_commander13.Command("import").description("Import skills from JSON file").argument("<file>", "JSON file to import").option("--from-indexer", "Import from skill-indexer export format").option("--auto-detect", "Auto-detect format (default: true)", true).action(async (file, options, command) => {
-  const globalOpts = command.optsWithGlobals();
-  try {
-    if (!fs14.existsSync(file)) {
-      printError(`File not found: ${file}`);
-      process.exit(1);
+  /**
+   * Import skills from indexer database into SkillBank
+   */
+  async importFromIndexerDb(options) {
+    if (!this.skillBank) {
+      throw new Error("SkillBank not configured. Use integrated mode.");
     }
-    const content = fs14.readFileSync(file, "utf-8");
-    let skills;
-    const isIndexerFormat = options.fromIndexer || options.autoDetect !== false && isLikelyIndexerFormat(content);
-    if (isIndexerFormat) {
-      if (!globalOpts.quiet) {
-        printInfo("Detected skill-indexer format, converting...");
-      }
-      try {
-        const { skills: converted, stats, exportMetadata } = parseIndexerExport(content);
-        skills = converted;
-        if (!globalOpts.quiet) {
-          printInfo(`Converted ${stats.total} skills (${stats.withStructuredContent} with structured content)`);
-          if (exportMetadata) {
-            printInfo(`Original export from: ${exportMetadata.exportedAt}`);
-          }
-        }
-      } catch (err) {
-        printError(`Failed to parse indexer export: ${err.message}`);
-        process.exit(1);
+    await this.initialize();
+    if (!this.db) {
+      throw new Error(
+        "Scraper database not available. Build the scraper module first."
+      );
+    }
+    const result = { imported: 0, failed: 0, skills: [] };
+    try {
+      let skills;
+      if (options?.status) {
+        skills = this.db.getSkillsByStatus?.(options.status) || [];
+      } else {
+        skills = this.db.getAllSkills?.() || [];
       }
-    } else {
-      try {
-        const parsed = JSON.parse(content);
-        skills = Array.isArray(parsed) ? parsed : [parsed];
-      } catch {
-        printError("Invalid JSON file");
-        process.exit(1);
+      if (options?.limit) {
+        skills = skills.slice(0, options.limit);
       }
       for (const skill of skills) {
-        skill.createdAt = new Date(skill.createdAt);
-        skill.updatedAt = new Date(skill.updatedAt);
-        if (skill.metrics.lastUsed) {
-          skill.metrics.lastUsed = new Date(skill.metrics.lastUsed);
-        }
-        if (skill.source?.importedAt) {
-          skill.source.importedAt = new Date(skill.source.importedAt);
-        }
-        if (skill.externalSource?.scrapedAt) {
-          skill.externalSource.scrapedAt = new Date(skill.externalSource.scrapedAt);
+        try {
+          const converted = convertIndexerSkill(skill);
+          await this.skillBank.saveSkill(converted.skill);
+          result.imported++;
+          result.skills.push(converted.skill);
+        } catch (err) {
+          result.failed++;
         }
       }
+    } catch (err) {
+      throw new Error(`Import failed: ${err.message}`);
     }
-    const skillBank = await createSkillBankFromOptions(globalOpts);
-    const result = await skillBank.importSkills(skills);
-    if (globalOpts.json) {
-      console.log(JSON.stringify({
-        ...result,
-        format: isIndexerFormat ? "indexer" : "skill-tree"
-      }, null, 2));
-      return;
+    return result;
+  }
+  /**
+   * Get default skill sources from config
+   */
+  getDefaultSources() {
+    const configSources = this.globalConfig.indexer.sources;
+    if (configSources.length > 0) {
+      return configSources.map((url) => ({
+        type: "awesome-list",
+        url
+      }));
     }
-    printSuccess(`Imported ${result.imported} skill(s)`);
-    if (result.failed > 0) {
-      printWarning(`Failed to import ${result.failed} skill(s)`);
+    return [
+      {
+        type: "awesome-list",
+        url: "https://github.com/VoltAgent/awesome-agent-skills"
+      }
+    ];
+  }
+  /**
+   * Close database connections
+   */
+  async close() {
+    if (this.db && typeof this.db.close === "function") {
+      this.db.close();
     }
-  } catch (error) {
-    printError(error.message);
-    process.exit(1);
+    this.db = void 0;
+    this.initialized = false;
   }
-});
+};
+function createIntegratedIndexer(skillBank, config2 = {}) {
+  return new IndexerService(config2, skillBank);
+}
 
-// src/cli/commands/indexer/index.ts
-var import_commander20 = require("commander");
+// src/index.ts
+var VERSION = "0.1.0";
 
-// src/cli/commands/indexer/scrape.ts
-var import_commander14 = require("commander");
-var import_child_process2 = require("child_process");
+// src/cli/commands/list.ts
+var import_commander = require("commander");
 
-// src/services/indexer.ts
+// src/cli/utils/paths.ts
+var fs13 = __toESM(require("fs"));
 var path13 = __toESM(require("path"));
-var fs15 = __toESM(require("fs"));
-function hasIndexerSupport(storage) {
-  const s = storage;
-  return typeof s.addRelationship === "function" && typeof s.getTaxonomyTree === "function";
+var os2 = __toESM(require("os"));
+var DEFAULT_PATHS = [
+  ".claude/skills",
+  // Project local (Claude)
+  ".agent/skills",
+  // Project local (universal)
+  "~/.claude/skills",
+  // User global (Claude)
+  "~/.agent/skills"
+  // User global (universal)
+];
+function expandHome(p) {
+  if (p.startsWith("~/")) {
+    return path13.join(os2.homedir(), p.slice(2));
+  }
+  return p;
 }
-var IndexerService = class {
-  constructor(config2 = {}, skillBank) {
-    this.initialized = false;
-    this.globalConfig = loadConfig();
-    this.serviceConfig = {
-      githubToken: config2.githubToken || this.globalConfig.indexer.github_token,
-      anthropicApiKey: config2.anthropicApiKey || this.globalConfig.indexer.anthropic_key,
-      batchSize: config2.batchSize || this.globalConfig.indexer.batch_size,
-      minConfidence: config2.minConfidence || this.globalConfig.indexer.min_confidence,
-      concurrency: config2.concurrency || 3,
-      cacheTtlSeconds: config2.cacheTtlSeconds || 3600,
-      databasePath: config2.databasePath,
-      cacheDir: config2.cacheDir,
-      claudeModel: config2.claudeModel
-    };
-    this.skillBank = skillBank;
+function dirExists(p) {
+  try {
+    return fs13.statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function resolveSkillPath(explicitPath) {
+  if (explicitPath) {
+    const resolved = expandHome(explicitPath);
+    return path13.resolve(resolved);
+  }
+  const envPath = process.env.SKILL_TREE_PATH;
+  if (envPath) {
+    return path13.resolve(expandHome(envPath));
+  }
+  for (const defaultPath of DEFAULT_PATHS) {
+    const resolved = path13.resolve(expandHome(defaultPath));
+    if (dirExists(resolved)) {
+      return resolved;
+    }
+  }
+  return path13.resolve(".claude/skills");
+}
+function ensureDir(dir) {
+  if (!dirExists(dir)) {
+    fs13.mkdirSync(dir, { recursive: true });
+  }
+}
+
+// src/cli/utils/skillbank.ts
+function getMaterializationConfig() {
+  const config2 = loadConfig();
+  const mat = config2.materialization;
+  if (!mat?.enabled) return void 0;
+  return {
+    enabled: true,
+    mode: mat.mode ?? "symlink",
+    symlinkPaths: mat.symlink_paths?.length ? mat.symlink_paths : void 0,
+    agentsMdPath: mat.agents_md_path || void 0,
+    agentsMdFormat: mat.agents_md_format ?? "xml",
+    debounceMs: mat.debounce_ms ?? 500
+  };
+}
+async function createSkillBankFromOptions(options) {
+  const skillPath = resolveSkillPath(options.path);
+  ensureDir(skillPath);
+  const skillBank = new SkillBank({
+    storage: {
+      basePath: skillPath,
+      openSkillsCompatible: true
+    },
+    materialization: getMaterializationConfig()
+  });
+  await skillBank.initialize();
+  return skillBank;
+}
+function getSkillPath(options) {
+  return resolveSkillPath(options.path);
+}
+var getSkillBank = createSkillBankFromOptions;
+
+// src/cli/utils/output.ts
+var import_chalk = __toESM(require("chalk"));
+function formatSkillLine(skill) {
+  const status = formatStatus(skill.status);
+  const version = import_chalk.default.dim(`v${skill.version}`);
+  const id = import_chalk.default.bold(skill.id);
+  const name = skill.name !== skill.id ? import_chalk.default.dim(` (${skill.name})`) : "";
+  const tags = skill.tags.length > 0 ? import_chalk.default.dim(` [${skill.tags.join(", ")}]`) : "";
+  return `${status} ${id}${name} ${version}${tags}`;
+}
+function formatStatus(status) {
+  switch (status) {
+    case "active":
+      return import_chalk.default.green("\u25CF");
+    case "draft":
+      return import_chalk.default.yellow("\u25CB");
+    case "deprecated":
+      return import_chalk.default.red("\u2717");
+    case "experimental":
+      return import_chalk.default.blue("\u25D0");
+    default:
+      return import_chalk.default.gray("?");
+  }
+}
+function formatSkillDetail(skill) {
+  const lines = [];
+  lines.push(import_chalk.default.bold(`${skill.name} v${skill.version}`));
+  lines.push(import_chalk.default.dim("\u2500".repeat(50)));
+  lines.push(`${import_chalk.default.dim("Status:")}    ${formatStatusLabel(skill.status)}`);
+  lines.push(`${import_chalk.default.dim("Author:")}    ${skill.author}`);
+  if (skill.tags.length > 0) {
+    lines.push(`${import_chalk.default.dim("Tags:")}      ${skill.tags.join(", ")}`);
+  }
+  if (skill.parentVersion) {
+    lines.push(`${import_chalk.default.dim("Parent:")}    v${skill.parentVersion}`);
+  }
+  if (skill.derivedFrom && skill.derivedFrom.length > 0) {
+    lines.push(`${import_chalk.default.dim("Derived:")}   ${skill.derivedFrom.join(", ")}`);
+  }
+  const { usageCount, successRate } = skill.metrics;
+  if (usageCount > 0) {
+    lines.push(`${import_chalk.default.dim("Usage:")}     ${usageCount} times, ${Math.round(successRate * 100)}% success`);
+  }
+  lines.push("");
+  lines.push(import_chalk.default.dim("Description"));
+  lines.push(import_chalk.default.dim("\u2500".repeat(50)));
+  lines.push(skill.description);
+  lines.push("");
+  if (skill.instructions) {
+    lines.push(import_chalk.default.dim("Instructions"));
+    lines.push(import_chalk.default.dim("\u2500".repeat(50)));
+    lines.push(skill.instructions);
+  }
+  return lines.join("\n");
+}
+function formatStatusLabel(status) {
+  switch (status) {
+    case "active":
+      return import_chalk.default.green("active");
+    case "draft":
+      return import_chalk.default.yellow("draft");
+    case "deprecated":
+      return import_chalk.default.red("deprecated");
+    case "experimental":
+      return import_chalk.default.blue("experimental");
+    default:
+      return import_chalk.default.gray(status);
+  }
+}
+function formatVersionHistory(versions) {
+  const lines = [];
+  lines.push(import_chalk.default.bold("Version History"));
+  lines.push(import_chalk.default.dim("\u2500".repeat(50)));
+  for (const v of versions.reverse()) {
+    const date = v.createdAt.toISOString().split("T")[0];
+    const hash = import_chalk.default.dim(`#${v.contentHash.slice(0, 7)}`);
+    const changelog = v.changelog ? ` - ${v.changelog}` : "";
+    lines.push(`  ${import_chalk.default.cyan(`v${v.version}`)} ${import_chalk.default.dim(date)} ${hash}${changelog}`);
+  }
+  return lines.join("\n");
+}
+function formatDiff(versionA, versionB, changes) {
+  const lines = [];
+  lines.push(import_chalk.default.bold(`Diff: v${versionA} \u2192 v${versionB}`));
+  lines.push(import_chalk.default.dim("\u2500".repeat(50)));
+  if (changes.modified.length === 0 && changes.added.length === 0 && changes.removed.length === 0) {
+    lines.push(import_chalk.default.dim("No changes"));
+    return lines.join("\n");
   }
-  /**
-   * Get effective configuration
-   */
-  getConfig() {
-    return { ...this.serviceConfig };
+  for (const mod of changes.modified) {
+    lines.push(import_chalk.default.yellow(`~ ${mod.field}`));
+    lines.push(import_chalk.default.red(`  - ${truncate(mod.oldValue, 60)}`));
+    lines.push(import_chalk.default.green(`  + ${truncate(mod.newValue, 60)}`));
   }
-  /**
-   * Initialize the service (lazy load scraper modules)
-   */
-  async initialize() {
-    if (this.initialized) return;
-    try {
-      const possiblePaths = [
-        // Relative to this file in dist
-        path13.resolve(__dirname, "../../scraper/dist"),
-        // Relative to project root
-        path13.resolve(process.cwd(), "scraper/dist"),
-        // Absolute paths from config
-        this.serviceConfig.cacheDir ? path13.resolve(this.serviceConfig.cacheDir, "../scraper/dist") : null
-      ].filter(Boolean);
-      let scraperBasePath = null;
-      for (const basePath of possiblePaths) {
-        const scraperIndex = path13.join(basePath, "scraper/index.js");
-        if (fs15.existsSync(scraperIndex)) {
-          scraperBasePath = basePath;
-          break;
-        }
-      }
-      if (!scraperBasePath) {
-        throw new Error("Scraper modules not found. Run `cd scraper && npm run build` first.");
-      }
-      const scraperPath = path13.join(scraperBasePath, "scraper/index.js");
-      const indexerPath = path13.join(scraperBasePath, "indexer/index.js");
-      const databasePath = path13.join(scraperBasePath, "database/index.js");
-      this.scraperModule = await import(
-        /* webpackIgnore: true */
-        scraperPath
-      );
-      this.indexerModule = await import(
-        /* webpackIgnore: true */
-        indexerPath
-      );
-      this.databaseModule = await import(
-        /* webpackIgnore: true */
-        databasePath
-      );
-      if (this.databaseModule.createDatabase) {
-        const dbPath = this.serviceConfig.databasePath || path13.join(process.cwd(), "scraper/data/skills.db");
-        this.db = this.databaseModule.createDatabase(dbPath);
-      }
-      this.initialized = true;
-    } catch (err) {
-      console.warn(`Scraper modules not available: ${err.message}`);
-      console.warn("Some indexer features will be limited.");
-      this.initialized = true;
-    }
+  for (const add of changes.added) {
+    lines.push(import_chalk.default.green(`+ ${add.type}: ${add.value}`));
   }
-  /**
-   * Check if the indexer is available
-   */
-  isAvailable() {
-    return this.initialized && !!this.scraperModule;
+  for (const rem of changes.removed) {
+    lines.push(import_chalk.default.red(`- ${rem.type}: ${rem.value}`));
   }
-  /**
-   * Check if running in degraded mode (no scraper modules)
-   */
-  isDegradedMode() {
-    return this.initialized && !this.scraperModule;
+  return lines.join("\n");
+}
+function formatStats(stats) {
+  const lines = [];
+  lines.push(import_chalk.default.bold("Skill Bank Statistics"));
+  lines.push(import_chalk.default.dim("\u2500".repeat(50)));
+  lines.push(`${import_chalk.default.dim("Total skills:")}  ${stats.totalSkills}`);
+  lines.push("");
+  lines.push(import_chalk.default.dim("By Status:"));
+  lines.push(`  ${import_chalk.default.green("\u25CF")} Active:       ${stats.byStatus.active}`);
+  lines.push(`  ${import_chalk.default.yellow("\u25CB")} Draft:        ${stats.byStatus.draft}`);
+  lines.push(`  ${import_chalk.default.blue("\u25D0")} Experimental: ${stats.byStatus.experimental}`);
+  lines.push(`  ${import_chalk.default.red("\u2717")} Deprecated:   ${stats.byStatus.deprecated}`);
+  lines.push("");
+  if (Object.keys(stats.byTag).length > 0) {
+    lines.push(import_chalk.default.dim("By Tag:"));
+    const sortedTags = Object.entries(stats.byTag).sort((a, b) => b[1] - a[1]);
+    for (const [tag, count] of sortedTags.slice(0, 10)) {
+      lines.push(`  ${tag}: ${count}`);
+    }
+    lines.push("");
   }
-  /**
-   * Scrape skills from GitHub sources
-   */
-  async scrape(sources, options) {
-    await this.initialize();
-    if (!this.scraperModule || !this.db) {
-      throw new Error(
-        "Scraper not available. Build the scraper module first: cd scraper && npm run build"
-      );
+  if (stats.totalUsage > 0) {
+    lines.push(import_chalk.default.dim("Usage:"));
+    lines.push(`  Total uses:      ${stats.totalUsage}`);
+    lines.push(`  Avg success:     ${Math.round(stats.avgSuccessRate * 100)}%`);
+  }
+  return lines.join("\n");
+}
+function printError(message) {
+  console.error(import_chalk.default.red(`Error: ${message}`));
+}
+function printSuccess(message) {
+  console.log(import_chalk.default.green(`\u2713 ${message}`));
+}
+function printWarning(message) {
+  console.log(import_chalk.default.yellow(`\u26A0 ${message}`));
+}
+function printInfo(message) {
+  console.log(import_chalk.default.dim(message));
+}
+function truncate(text, maxLength) {
+  const oneLine = text.replace(/\n/g, " ");
+  if (oneLine.length <= maxLength) return oneLine;
+  return oneLine.slice(0, maxLength - 3) + "...";
+}
+
+// src/cli/commands/list.ts
+var listCommand = new import_commander.Command("list").description("List all skills").option("-s, --status <status>", "Filter by status (active, draft, deprecated, experimental)").option("-t, --tag <tag>", "Filter by tag").option("-a, --author <author>", "Filter by author").action(async (options, command) => {
+  const globalOpts = command.optsWithGlobals();
+  try {
+    const skillBank = await createSkillBankFromOptions(globalOpts);
+    const filter = {};
+    if (options.status) {
+      filter.status = [options.status];
     }
-    const result = {
-      discovered: 0,
-      scraped: 0,
-      skipped: 0,
-      failed: 0,
-      unchanged: 0,
-      errors: []
-    };
-    try {
-      const scraper = this.scraperModule.createScraper({
-        githubToken: this.serviceConfig.githubToken,
-        cacheDir: this.serviceConfig.cacheDir,
-        cacheTtlSeconds: this.serviceConfig.cacheTtlSeconds
-      });
-      for (const source of sources) {
-        try {
-          let skills;
-          if (source.type === "awesome-list") {
-            skills = await scraper.scrapeAwesomeList(source.url, {
-              force: options?.force
-            });
-          } else {
-            skills = await scraper.scrapeRepository(source.url, {
-              force: options?.force
-            });
-          }
-          result.discovered += skills.length;
-          for (const skill of skills) {
-            try {
-              const existing = this.db.getSkillBySlug?.(skill.slug);
-              if (existing && !options?.force) {
-                result.unchanged++;
-              } else {
-                this.db.saveSkill?.(skill);
-                result.scraped++;
-              }
-            } catch (err) {
-              result.failed++;
-              result.errors.push(`Failed to save skill ${skill.slug}: ${err.message}`);
-            }
-          }
-        } catch (err) {
-          result.failed++;
-          result.errors.push(`Failed to scrape ${source.url}: ${err.message}`);
-        }
-      }
-    } catch (err) {
-      result.errors.push(`Scrape failed: ${err.message}`);
+    if (options.tag) {
+      filter.tags = [options.tag];
     }
-    return result;
-  }
-  /**
-   * Classify unindexed skills using AI
-   */
-  async classify(options) {
-    await this.initialize();
-    if (!this.indexerModule || !this.db) {
-      throw new Error(
-        "Indexer not available. Build the scraper module first: cd scraper && npm run build"
-      );
+    if (options.author) {
+      filter.author = options.author;
     }
-    const result = {
-      indexed: 0,
-      skipped: 0,
-      failed: 0,
-      errors: []
-    };
-    try {
-      const indexer = this.indexerModule.createIndexer({
-        anthropicApiKey: this.serviceConfig.anthropicApiKey,
-        model: this.serviceConfig.claudeModel || "claude-sonnet-4-20250514",
-        minConfidence: this.serviceConfig.minConfidence
-      });
-      let skills;
-      if (options?.skillId) {
-        const skill = this.db.getSkillBySlug?.(options.skillId);
-        skills = skill ? [skill] : [];
-      } else if (options?.all) {
-        skills = this.db.getAllSkills?.() || [];
-      } else {
-        skills = this.db.getSkillsByStatus?.("raw") || [];
-      }
-      const batchSize = this.serviceConfig.batchSize || 10;
-      for (let i = 0; i < skills.length; i += batchSize) {
-        const batch = skills.slice(i, i + batchSize);
-        for (const skill of batch) {
-          if (skill.status === "indexed" && !options?.all) {
-            result.skipped++;
-            continue;
-          }
-          try {
-            const classification = await indexer.classifySkill(skill);
-            skill.status = "indexed";
-            skill.primaryPath = classification.primaryPath;
-            skill.secondaryPaths = classification.secondaryPaths;
-            skill.confidence = classification.confidence;
-            skill.classificationReasoning = classification.reasoning;
-            skill.indexedAt = (/* @__PURE__ */ new Date()).toISOString();
-            this.db.saveSkill?.(skill);
-            result.indexed++;
-          } catch (err) {
-            result.failed++;
-            result.errors.push(`Failed to classify ${skill.slug}: ${err.message}`);
-          }
-        }
-      }
-    } catch (err) {
-      result.errors.push(`Classification failed: ${err.message}`);
+    const skills = await skillBank.listSkills(
+      Object.keys(filter).length > 0 ? filter : void 0
+    );
+    if (globalOpts.json) {
+      console.log(JSON.stringify(skills, null, 2));
+      return;
+    }
+    if (skills.length === 0) {
+      printInfo(`No skills found in ${getSkillPath(globalOpts)}`);
+      return;
+    }
+    if (!globalOpts.quiet) {
+      printInfo(`Skills in ${getSkillPath(globalOpts)}:
+`);
+    }
+    for (const skill of skills) {
+      console.log(formatSkillLine(skill));
+    }
+    if (!globalOpts.quiet) {
+      console.log();
+      printInfo(`${skills.length} skill(s)`);
+    }
+  } catch (error) {
+    printError(error.message);
+    process.exit(1);
+  }
+});
+
+// src/cli/commands/show.ts
+var import_commander2 = require("commander");
+var showCommand = new import_commander2.Command("show").description("Show skill details").argument("<id>", "Skill ID").option("-v, --version <version>", "Show specific version").action(async (id, options, command) => {
+  const globalOpts = command.optsWithGlobals();
+  try {
+    const skillBank = await createSkillBankFromOptions(globalOpts);
+    const skill = await skillBank.getSkill(id, options.version);
+    if (!skill) {
+      printError(`Skill not found: ${id}${options.version ? `@${options.version}` : ""}`);
+      process.exit(1);
     }
-    return result;
+    if (globalOpts.json) {
+      console.log(JSON.stringify(skill, null, 2));
+      return;
+    }
+    console.log(formatSkillDetail(skill));
+  } catch (error) {
+    printError(error.message);
+    process.exit(1);
   }
-  /**
-   * Detect relationships between skills
-   */
-  async detectRelationships(options) {
-    await this.initialize();
-    const result = {
-      detected: 0,
-      skipped: 0,
-      errors: []
-    };
-    if (this.skillBank) {
-      try {
-        const storage = this.skillBank.getStorage();
-        if (hasIndexerSupport(storage)) {
-          const skills = await this.skillBank.listSkills();
-          const targetSkills = options?.skillId ? skills.filter((s) => s.id === options.skillId) : skills;
-          for (const skill of targetSkills) {
-            const relationships = this.detectSkillRelationships(skill, skills);
-            for (const rel of relationships) {
-              try {
-                await storage.addRelationship(
-                  skill.id,
-                  rel.targetSkillId,
-                  rel.type,
-                  rel.confidence,
-                  rel.reasoning
-                );
-                result.detected++;
-              } catch (err) {
-                result.skipped++;
-              }
-            }
-          }
-        }
-      } catch (err) {
-        result.errors.push(`Relationship detection failed: ${err.message}`);
-      }
-      return result;
+});
+
+// src/cli/commands/search.ts
+var import_commander3 = require("commander");
+var searchCommand = new import_commander3.Command("search").description("Search skills by text").argument("<query>", "Search query").action(async (query, options, command) => {
+  const globalOpts = command.optsWithGlobals();
+  try {
+    const skillBank = await createSkillBankFromOptions(globalOpts);
+    const skills = await skillBank.searchSkills(query);
+    if (globalOpts.json) {
+      console.log(JSON.stringify(skills, null, 2));
+      return;
     }
-    if (!this.db) {
-      throw new Error(
-        "Neither SkillBank nor scraper database available."
-      );
+    if (skills.length === 0) {
+      printInfo(`No skills found matching "${query}"`);
+      return;
     }
-    try {
-      const skills = this.db.getAllSkills?.() || [];
-      const targetSkills = options?.skillId ? skills.filter((s) => s.slug === options.skillId) : skills.filter((s) => s.status === "indexed");
-      for (const skill of targetSkills) {
-        const relationships = this.detectSkillRelationships(skill, skills);
-        for (const rel of relationships) {
-          try {
-            this.db.saveRelationship?.({
-              sourceSkillId: skill.id,
-              ...rel
-            });
-            result.detected++;
-          } catch (err) {
-            result.skipped++;
-          }
-        }
-      }
-    } catch (err) {
-      result.errors.push(`Relationship detection failed: ${err.message}`);
+    if (!globalOpts.quiet) {
+      printInfo(`Results for "${query}":
+`);
     }
-    return result;
+    for (const skill of skills) {
+      console.log(formatSkillLine(skill));
+    }
+    if (!globalOpts.quiet) {
+      console.log();
+      printInfo(`${skills.length} result(s)`);
+    }
+  } catch (error) {
+    printError(error.message);
+    process.exit(1);
   }
-  /**
-   * Detect relationships for a single skill
-   */
-  detectSkillRelationships(skill, allSkills) {
-    const relationships = [];
-    const skillId = skill.id || skill.slug;
-    const skillContent = `${skill.name} ${skill.description} ${skill.instructions || ""} ${skill.content || ""}`.toLowerCase();
-    for (const other of allSkills) {
-      const otherId = other.id || other.slug;
-      if (otherId === skillId) continue;
-      const otherName = (other.name || "").toLowerCase();
-      const dependencyPatterns = ["requires", "depends on", "uses", "needs", "builds on"];
-      for (const pattern of dependencyPatterns) {
-        if (skillContent.includes(`${pattern} ${otherName}`)) {
-          relationships.push({
-            targetSkillId: otherId,
-            type: "depends_on",
-            confidence: 0.7,
-            reasoning: `Content mentions "${pattern} ${other.name}"`
-          });
-          break;
-        }
-      }
-      const extensionPatterns = ["extends", "improves", "enhances", "builds upon"];
-      for (const pattern of extensionPatterns) {
-        if (skillContent.includes(`${pattern} ${otherName}`)) {
-          relationships.push({
-            targetSkillId: otherId,
-            type: "extends",
-            confidence: 0.7,
-            reasoning: `Content mentions "${pattern} ${other.name}"`
-          });
-          break;
-        }
-      }
-      const alternativePatterns = ["alternative to", "instead of", "replacement for"];
-      for (const pattern of alternativePatterns) {
-        if (skillContent.includes(`${pattern} ${otherName}`)) {
-          relationships.push({
-            targetSkillId: otherId,
-            type: "alternative",
-            confidence: 0.6,
-            reasoning: `Content mentions "${pattern} ${other.name}"`
-          });
-          break;
-        }
-      }
-      const skillPath = skill.taxonomy?.primaryPath || skill.primaryPath || [];
-      const otherPath = other.taxonomy?.primaryPath || other.primaryPath || [];
-      if (skillPath.length >= 2 && otherPath.length >= 2) {
-        if (skillPath[0] === otherPath[0] && skillPath[1] === otherPath[1]) {
-          relationships.push({
-            targetSkillId: otherId,
-            type: "related",
-            confidence: 0.5,
-            reasoning: `Same taxonomy category: ${skillPath.slice(0, 2).join(" > ")}`
-          });
-        }
-      }
+});
+
+// src/cli/commands/stats.ts
+var import_commander4 = require("commander");
+var statsCommand = new import_commander4.Command("stats").description("Show skill bank statistics").action(async (options, command) => {
+  const globalOpts = command.optsWithGlobals();
+  try {
+    const skillBank = await createSkillBankFromOptions(globalOpts);
+    const stats = await skillBank.getStats();
+    if (globalOpts.json) {
+      console.log(JSON.stringify(stats, null, 2));
+      return;
     }
-    return relationships;
+    console.log(formatStats(stats));
+  } catch (error) {
+    printError(error.message);
+    process.exit(1);
   }
-  /**
-   * Get taxonomy tree
-   */
-  async getTaxonomyTree(rootPath) {
-    await this.initialize();
-    if (this.skillBank) {
-      const storage = this.skillBank.getStorage();
-      if (hasIndexerSupport(storage)) {
-        const nodes = await storage.getTaxonomyTree(rootPath);
-        return this.wrapTreeNodes(nodes, rootPath);
-      }
+});
+
+// src/cli/commands/versions.ts
+var import_commander5 = require("commander");
+var versionsCommand = new import_commander5.Command("versions").description("Show version history for a skill").argument("<id>", "Skill ID").action(async (id, options, command) => {
+  const globalOpts = command.optsWithGlobals();
+  try {
+    const skillBank = await createSkillBankFromOptions(globalOpts);
+    const versions = await skillBank.getVersionHistory(id);
+    if (versions.length === 0) {
+      printInfo(`No version history found for: ${id}`);
+      return;
     }
-    const skills = this.skillBank ? await this.skillBank.listSkills() : this.db?.getAllSkills?.() || [];
-    return this.buildTaxonomyTreeFromSkills(skills, rootPath);
+    if (globalOpts.json) {
+      console.log(JSON.stringify(versions, null, 2));
+      return;
+    }
+    console.log(formatVersionHistory(versions));
+  } catch (error) {
+    printError(error.message);
+    process.exit(1);
   }
-  /**
-   * Wrap tree nodes returned from SQLite storage into a root node
-   */
-  wrapTreeNodes(nodes, rootPath) {
-    const root = {
-      id: "root",
-      name: rootPath?.join(" > ") || "All Skills",
-      path: rootPath || [],
-      skillCount: 0,
-      children: []
-    };
-    for (const node of nodes) {
-      root.children.push(this.convertToTaxonomyNode(node));
-      root.skillCount += this.countNodeSkills(node);
+});
+
+// src/cli/commands/diff.ts
+var import_commander6 = require("commander");
+var diffCommand = new import_commander6.Command("diff").description("Compare two versions of a skill").argument("<id>", "Skill ID").argument("<version-a>", "First version").argument("<version-b>", "Second version").action(async (id, versionA, versionB, options, command) => {
+  const globalOpts = command.optsWithGlobals();
+  try {
+    const skillBank = await createSkillBankFromOptions(globalOpts);
+    const diff = await skillBank.compareVersions(id, versionA, versionB);
+    if (globalOpts.json) {
+      console.log(JSON.stringify(diff, null, 2));
+      return;
+    }
+    console.log(formatDiff(diff.versionA, diff.versionB, diff.changes));
+  } catch (error) {
+    printError(error.message);
+    process.exit(1);
+  }
+});
+
+// src/cli/commands/rollback.ts
+var import_commander7 = require("commander");
+var rollbackCommand = new import_commander7.Command("rollback").description("Rollback a skill to a previous version").argument("<id>", "Skill ID").requiredOption("--to <version>", "Version to rollback to").action(async (id, options, command) => {
+  const globalOpts = command.optsWithGlobals();
+  try {
+    const skillBank = await createSkillBankFromOptions(globalOpts);
+    const skill = await skillBank.rollbackSkill(id, options.to);
+    if (globalOpts.json) {
+      console.log(JSON.stringify(skill, null, 2));
+      return;
     }
-    return root;
+    printSuccess(`Rolled back ${id} to v${options.to} (new version: v${skill.version})`);
+  } catch (error) {
+    printError(error.message);
+    process.exit(1);
   }
-  /**
-   * Convert storage tree node to TaxonomyNode format
-   */
-  convertToTaxonomyNode(node) {
-    return {
-      id: node.id,
-      name: node.name,
-      path: Array.isArray(node.path) ? node.path : (node.path || "").split("/"),
-      skillCount: node.skillCount || 0,
-      children: (node.children || []).map((child) => this.convertToTaxonomyNode(child))
-    };
+});
+
+// src/cli/commands/fork.ts
+var import_commander8 = require("commander");
+var forkCommand = new import_commander8.Command("fork").description("Fork a skill to create a variant").argument("<id>", "Skill ID to fork from").requiredOption("--new-id <id>", "ID for the new forked skill").requiredOption("--reason <reason>", "Reason for forking").option("--name <name>", "Name for the forked skill").option("--from-version <version>", "Version to fork from (defaults to latest)").action(async (id, options, command) => {
+  const globalOpts = command.optsWithGlobals();
+  try {
+    const skillBank = await createSkillBankFromOptions(globalOpts);
+    const forked = await skillBank.forkSkill(id, {
+      newId: options.newId,
+      newName: options.name,
+      reason: options.reason,
+      fromVersion: options.fromVersion
+    });
+    if (globalOpts.json) {
+      console.log(JSON.stringify(forked, null, 2));
+      return;
+    }
+    printSuccess(`Forked ${id} \u2192 ${forked.id} (v${forked.version})`);
+  } catch (error) {
+    printError(error.message);
+    process.exit(1);
   }
-  /**
-   * Count total skills in a node tree
-   */
-  countNodeSkills(node) {
-    let count = node.skillCount || 0;
-    for (const child of node.children || []) {
-      count += this.countNodeSkills(child);
+});
+
+// src/cli/commands/deprecate.ts
+var import_commander9 = require("commander");
+var deprecateCommand = new import_commander9.Command("deprecate").description("Mark a skill as deprecated").argument("<id>", "Skill ID").action(async (id, options, command) => {
+  const globalOpts = command.optsWithGlobals();
+  try {
+    const skillBank = await createSkillBankFromOptions(globalOpts);
+    const skill = await skillBank.deprecateSkill(id);
+    if (globalOpts.json) {
+      console.log(JSON.stringify(skill, null, 2));
+      return;
     }
-    return count;
+    printSuccess(`Deprecated: ${id} (v${skill.version})`);
+  } catch (error) {
+    printError(error.message);
+    process.exit(1);
   }
-  /**
-   * Build taxonomy tree from flat nodes
-   */
-  buildTaxonomyTree(nodes, rootPath) {
-    const root = {
-      id: "root",
-      name: rootPath?.join(" > ") || "All Skills",
-      path: rootPath || [],
-      skillCount: 0,
-      children: []
-    };
-    const nodeMap = /* @__PURE__ */ new Map();
-    nodeMap.set("root", root);
-    for (const node of nodes) {
-      const taxNode = {
-        id: node.id,
-        name: node.name,
-        path: node.path,
-        skillCount: node.skillCount || 0,
-        children: []
-      };
-      nodeMap.set(node.id, taxNode);
+});
+
+// src/cli/commands/activate.ts
+var import_commander10 = require("commander");
+var activateCommand = new import_commander10.Command("activate").description("Mark a skill as active").argument("<id>", "Skill ID").action(async (id, options, command) => {
+  const globalOpts = command.optsWithGlobals();
+  try {
+    const skillBank = await createSkillBankFromOptions(globalOpts);
+    const skill = await skillBank.getSkill(id);
+    if (!skill) {
+      printError(`Skill not found: ${id}`);
+      process.exit(1);
     }
-    for (const node of nodes) {
-      const taxNode = nodeMap.get(node.id);
-      const parentId = node.parentId || "root";
-      const parent = nodeMap.get(parentId);
-      if (parent) {
-        parent.children.push(taxNode);
-        parent.skillCount += taxNode.skillCount;
-      }
+    skill.status = "active";
+    skill.updatedAt = /* @__PURE__ */ new Date();
+    await skillBank.saveSkill(skill);
+    if (globalOpts.json) {
+      console.log(JSON.stringify(skill, null, 2));
+      return;
     }
-    return root;
+    printSuccess(`Activated: ${id} (v${skill.version})`);
+  } catch (error) {
+    printError(error.message);
+    process.exit(1);
   }
-  /**
-   * Build taxonomy tree from skills
-   */
-  buildTaxonomyTreeFromSkills(skills, rootPath) {
-    const root = {
-      id: "root",
-      name: rootPath?.join(" > ") || "All Skills",
-      path: rootPath || [],
-      skillCount: 0,
-      children: []
-    };
-    const nodeMap = /* @__PURE__ */ new Map();
-    for (const skill of skills) {
-      const taxonomy = skill.taxonomy || (skill.primaryPath ? { primaryPath: skill.primaryPath } : null);
-      if (!taxonomy?.primaryPath) continue;
-      const skillPath = taxonomy.primaryPath;
-      if (rootPath && rootPath.length > 0) {
-        let matches = true;
-        for (let i = 0; i < rootPath.length; i++) {
-          if (skillPath[i] !== rootPath[i]) {
-            matches = false;
-            break;
-          }
-        }
-        if (!matches) continue;
-      }
-      let currentPath = [];
-      let parent = root;
-      for (const segment of skillPath) {
-        currentPath = [...currentPath, segment];
-        const pathKey = currentPath.join("/");
-        let node = nodeMap.get(pathKey);
-        if (!node) {
-          node = {
-            id: pathKey,
-            name: segment,
-            path: [...currentPath],
-            skillCount: 0,
-            children: []
-          };
-          nodeMap.set(pathKey, node);
-          parent.children.push(node);
-        }
-        parent = node;
-      }
-      parent.skillCount++;
-      root.skillCount++;
+});
+
+// src/cli/commands/delete.ts
+var import_commander11 = require("commander");
+var deleteCommand = new import_commander11.Command("delete").description("Delete a skill").argument("<id>", "Skill ID").option("-f, --force", "Skip confirmation").option("-v, --version <version>", "Delete specific version only").action(async (id, options, command) => {
+  const globalOpts = command.optsWithGlobals();
+  try {
+    const skillBank = await createSkillBankFromOptions(globalOpts);
+    const skill = await skillBank.getSkill(id, options.version);
+    if (!skill) {
+      printError(`Skill not found: ${id}${options.version ? `@${options.version}` : ""}`);
+      process.exit(1);
     }
-    return root;
-  }
-  /**
-   * Get indexer statistics
-   */
-  async getStats() {
-    await this.initialize();
-    if (this.skillBank) {
-      const skills = await this.skillBank.listSkills();
-      const storage = this.skillBank.getStorage();
-      let taxonomyNodes = 0;
-      let relationships = 0;
-      let sources = 0;
-      if (storage) {
-        if (hasIndexerSupport(storage)) {
-          const tree = await storage.getTaxonomyTree();
-          taxonomyNodes = this.countTaxonomyNodes(tree);
-          if (storage.getRelationships) {
-            for (const skill of skills) {
-              const rels = await storage.getRelationships(skill.id);
-              relationships += rels.length;
-            }
-          }
-        }
-        const sourceSet = /* @__PURE__ */ new Set();
-        for (const skill of skills) {
-          if (skill.externalSource?.repo) {
-            sourceSet.add(skill.externalSource.repo);
-          }
-          if (skill.source?.type === "imported" && skill.externalSource?.url) {
-            sourceSet.add(skill.externalSource.url);
-          }
-        }
-        sources = sourceSet.size;
-      }
-      const indexed = skills.filter(
-        (s) => s.status === "active" && (s.taxonomy || s.source?.type === "imported")
-      ).length;
-      return {
-        totalSkills: skills.length,
-        indexedSkills: indexed,
-        rawSkills: skills.filter((s) => s.status === "draft").length,
-        failedSkills: skills.filter((s) => s.status === "deprecated").length,
-        taxonomyNodes,
-        relationships,
-        sources
-      };
+    if (!options.force) {
+      printWarning(`This will permanently delete ${id}${options.version ? `@${options.version}` : " and all versions"}`);
+      printWarning("Use --force to confirm");
+      process.exit(1);
     }
-    if (this.db) {
-      const stats = this.db.getStats?.() || {};
-      return {
-        totalSkills: stats.totalSkills || 0,
-        indexedSkills: stats.indexedSkills || 0,
-        rawSkills: stats.rawSkills || 0,
-        failedSkills: stats.failedSkills || 0,
-        taxonomyNodes: stats.taxonomyNodes || 0,
-        relationships: stats.relationships || 0,
-        sources: stats.sources || 0
-      };
+    const deleted = await skillBank.deleteSkill(id, options.version);
+    if (!deleted) {
+      printError(`Failed to delete: ${id}`);
+      process.exit(1);
     }
-    return {
-      totalSkills: 0,
-      indexedSkills: 0,
-      rawSkills: 0,
-      failedSkills: 0,
-      taxonomyNodes: 0,
-      relationships: 0,
-      sources: 0
-    };
+    if (globalOpts.json) {
+      console.log(JSON.stringify({ deleted: true, id, version: options.version }));
+      return;
+    }
+    printSuccess(`Deleted: ${id}${options.version ? `@${options.version}` : ""}`);
+  } catch (error) {
+    printError(error.message);
+    process.exit(1);
   }
-  /**
-   * Count nodes in taxonomy tree
-   */
-  countTaxonomyNodes(nodes) {
-    let count = 0;
-    for (const node of nodes) {
-      count++;
-      if (node.children) {
-        count += this.countTaxonomyNodes(node.children);
+});
+
+// src/cli/commands/export.ts
+var import_commander12 = require("commander");
+var fs14 = __toESM(require("fs"));
+var exportCommand = new import_commander12.Command("export").description("Export all skills to JSON").option("-o, --output <file>", "Output file path (defaults to stdout)").action(async (options, command) => {
+  const globalOpts = command.optsWithGlobals();
+  try {
+    const skillBank = await createSkillBankFromOptions(globalOpts);
+    const skills = await skillBank.exportAll();
+    const json = JSON.stringify(skills, null, 2);
+    if (options.output) {
+      fs14.writeFileSync(options.output, json, "utf-8");
+      if (!globalOpts.quiet) {
+        printSuccess(`Exported ${skills.length} skill(s) to ${options.output}`);
       }
+    } else {
+      console.log(json);
     }
-    return count;
+  } catch (error) {
+    printError(error.message);
+    process.exit(1);
   }
-  /**
-   * Scrape and index skills directly into SkillBank
-   * This is the streamlined workflow for integrated mode
-   */
-  async scrapeAndIndex(sources, options) {
-    if (!this.skillBank) {
-      throw new Error("SkillBank required for scrapeAndIndex. Use integrated mode.");
-    }
-    await this.initialize();
-    const skillsAdded = [];
-    const scraped = await this.scrape(sources, { force: options?.force });
-    let indexed = { indexed: 0, skipped: 0, failed: 0, errors: [] };
-    if (options?.autoClassify !== false) {
-      indexed = await this.classify({ all: options?.force });
+});
+
+// src/cli/commands/import.ts
+var import_commander13 = require("commander");
+var fs15 = __toESM(require("fs"));
+
+// src/import/detect.ts
+function isSkillTreeSkill(obj) {
+  if (typeof obj !== "object" || obj === null) return false;
+  const skill = obj;
+  return typeof skill.id === "string" && typeof skill.name === "string" && typeof skill.version === "string" && typeof skill.instructions === "string" && typeof skill.metrics === "object";
+}
+function isIndexerSkill(obj) {
+  if (typeof obj !== "object" || obj === null) return false;
+  const skill = obj;
+  return typeof skill.slug === "string" && typeof skill.sourceRepo === "string" && typeof skill.sourcePath === "string" && typeof skill.sourceUrl === "string" && typeof skill.content === "string" && typeof skill.scrapedAt === "string" && (skill.status === "raw" || skill.status === "indexed" || skill.status === "failed");
+}
+function isIndexerExport(obj) {
+  if (typeof obj !== "object" || obj === null) return false;
+  const exp = obj;
+  return typeof exp.exportedAt === "string" && Array.isArray(exp.skills);
+}
+function detectFormat(data) {
+  if (Array.isArray(data)) {
+    if (data.length === 0) {
+      return { format: "unknown", confidence: 0, details: "Empty array" };
     }
-    if (this.db) {
-      const skills = this.db.getAllSkills?.() || [];
-      for (const skill of skills) {
-        if (skill.status !== "indexed" && !options?.force) continue;
-        try {
-          const converted = convertIndexerSkill(skill);
-          await this.skillBank.saveSkill(converted.skill);
-          skillsAdded.push(converted.skill.id);
-        } catch (err) {
-          indexed.errors.push(`Failed to import ${skill.slug}: ${err.message}`);
-        }
-      }
+    const first = data[0];
+    if (isIndexerSkill(first)) {
+      return { format: "indexer", confidence: 0.95, details: "Array of indexer skills" };
     }
-    let relationships = { detected: 0, skipped: 0, errors: [] };
-    if (options?.detectRelationships !== false) {
-      relationships = await this.detectRelationships();
+    if (isSkillTreeSkill(first)) {
+      return { format: "skill-tree", confidence: 0.95, details: "Array of skill-tree skills" };
     }
-    return {
-      scraped,
-      indexed,
-      relationships,
-      skillsAdded
-    };
+    return { format: "unknown", confidence: 0.3, details: "Array of unknown objects" };
   }
-  /**
-   * Import skills from indexer database into SkillBank
-   */
-  async importFromIndexerDb(options) {
-    if (!this.skillBank) {
-      throw new Error("SkillBank not configured. Use integrated mode.");
+  if (typeof data === "object" && data !== null) {
+    if (isIndexerExport(data)) {
+      return { format: "indexer-export", confidence: 0.98, details: "Indexer export with metadata" };
     }
-    await this.initialize();
-    if (!this.db) {
-      throw new Error(
-        "Scraper database not available. Build the scraper module first."
-      );
+    if (isIndexerSkill(data)) {
+      return { format: "indexer", confidence: 0.9, details: "Single indexer skill" };
     }
-    const result = { imported: 0, failed: 0, skills: [] };
-    try {
-      let skills;
-      if (options?.status) {
-        skills = this.db.getSkillsByStatus?.(options.status) || [];
-      } else {
-        skills = this.db.getAllSkills?.() || [];
+    if (isSkillTreeSkill(data)) {
+      return { format: "skill-tree", confidence: 0.9, details: "Single skill-tree skill" };
+    }
+  }
+  return { format: "unknown", confidence: 0, details: "Unrecognized format" };
+}
+function detectFormatFromString(content) {
+  try {
+    const data = JSON.parse(content);
+    return detectFormat(data);
+  } catch {
+    return { format: "unknown", confidence: 0, details: "Invalid JSON" };
+  }
+}
+function isLikelyIndexerFormat(content) {
+  const result = detectFormatFromString(content);
+  return result.format === "indexer" || result.format === "indexer-export";
+}
+
+// src/cli/commands/import.ts
+var importCommand = new import_commander13.Command("import").description("Import skills from JSON file").argument("<file>", "JSON file to import").option("--from-indexer", "Import from skill-indexer export format").option("--auto-detect", "Auto-detect format (default: true)", true).action(async (file, options, command) => {
+  const globalOpts = command.optsWithGlobals();
+  try {
+    if (!fs15.existsSync(file)) {
+      printError(`File not found: ${file}`);
+      process.exit(1);
+    }
+    const content = fs15.readFileSync(file, "utf-8");
+    let skills;
+    const isIndexerFormat = options.fromIndexer || options.autoDetect !== false && isLikelyIndexerFormat(content);
+    if (isIndexerFormat) {
+      if (!globalOpts.quiet) {
+        printInfo("Detected skill-indexer format, converting...");
       }
-      if (options?.limit) {
-        skills = skills.slice(0, options.limit);
+      try {
+        const { skills: converted, stats, exportMetadata } = parseIndexerExport(content);
+        skills = converted;
+        if (!globalOpts.quiet) {
+          printInfo(`Converted ${stats.total} skills (${stats.withStructuredContent} with structured content)`);
+          if (exportMetadata) {
+            printInfo(`Original export from: ${exportMetadata.exportedAt}`);
+          }
+        }
+      } catch (err) {
+        printError(`Failed to parse indexer export: ${err.message}`);
+        process.exit(1);
+      }
+    } else {
+      try {
+        const parsed = JSON.parse(content);
+        skills = Array.isArray(parsed) ? parsed : [parsed];
+      } catch {
+        printError("Invalid JSON file");
+        process.exit(1);
       }
       for (const skill of skills) {
-        try {
-          const converted = convertIndexerSkill(skill);
-          await this.skillBank.saveSkill(converted.skill);
-          result.imported++;
-          result.skills.push(converted.skill);
-        } catch (err) {
-          result.failed++;
+        skill.createdAt = new Date(skill.createdAt);
+        skill.updatedAt = new Date(skill.updatedAt);
+        if (skill.metrics.lastUsed) {
+          skill.metrics.lastUsed = new Date(skill.metrics.lastUsed);
+        }
+        if (skill.source?.importedAt) {
+          skill.source.importedAt = new Date(skill.source.importedAt);
+        }
+        if (skill.externalSource?.scrapedAt) {
+          skill.externalSource.scrapedAt = new Date(skill.externalSource.scrapedAt);
         }
       }
-    } catch (err) {
-      throw new Error(`Import failed: ${err.message}`);
     }
-    return result;
-  }
-  /**
-   * Get default skill sources from config
-   */
-  getDefaultSources() {
-    const configSources = this.globalConfig.indexer.sources;
-    if (configSources.length > 0) {
-      return configSources.map((url) => ({
-        type: "awesome-list",
-        url
-      }));
+    const skillBank = await createSkillBankFromOptions(globalOpts);
+    const result = await skillBank.importSkills(skills);
+    if (globalOpts.json) {
+      console.log(JSON.stringify({
+        ...result,
+        format: isIndexerFormat ? "indexer" : "skill-tree"
+      }, null, 2));
+      return;
     }
-    return [
-      { type: "awesome-list", url: "https://github.com/VoltAgent/awesome-agent-skills" }
-    ];
-  }
-  /**
-   * Close database connections
-   */
-  async close() {
-    if (this.db && typeof this.db.close === "function") {
-      this.db.close();
+    printSuccess(`Imported ${result.imported} skill(s)`);
+    if (result.failed > 0) {
+      printWarning(`Failed to import ${result.failed} skill(s)`);
     }
-    this.db = void 0;
-    this.initialized = false;
+  } catch (error) {
+    printError(error.message);
+    process.exit(1);
   }
-};
-function createIntegratedIndexer(skillBank, config2 = {}) {
-  return new IndexerService(config2, skillBank);
-}
+});
+
+// src/cli/commands/indexer/index.ts
+var import_commander20 = require("commander");
 
 // src/cli/commands/indexer/scrape.ts
+var import_commander14 = require("commander");
+var import_child_process2 = require("child_process");
 var scrapeCommand = new import_commander14.Command("scrape").description("Scrape skills from GitHub sources").argument("[url]", "Repository or awesome-list URL").option("-d, --discover", "Discover from default sources").option("-f, --force", "Force scrape even if no changes detected").option("--standalone", "Use standalone skillindexer CLI (fallback)").option("--import", "Auto-import scraped skills into skill-tree", true).action(async (url, options, command) => {
   const globalOpts = command.optsWithGlobals();
   if (options.standalone) {
@@ -10314,11 +10707,11 @@ configCommand.command("edit").description("Open configuration file in editor").a
 configCommand.command("defaults").description("Show default configuration values").action(() => {
   const globalOpts = configCommand.parent?.opts() || {};
   if (globalOpts.json) {
-    console.log(JSON.stringify(DEFAULT_CONFIG5, null, 2));
+    console.log(JSON.stringify(DEFAULT_CONFIG6, null, 2));
   } else {
     console.log("Default Configuration:");
     console.log("=".repeat(40));
-    printConfig(DEFAULT_CONFIG5, 0);
+    printConfig(DEFAULT_CONFIG6, 0);
   }
 });
 configCommand.command("validate").description("Validate configuration file").action(() => {
@@ -10838,7 +11231,7 @@ var materializeCommand = new import_commander24.Command("materialize").descripti
 });
 
 // src/cli/commands/loadout/index.ts
-var import_commander37 = require("commander");
+var import_commander38 = require("commander");
 
 // src/cli/commands/loadout/list.ts
 var import_commander25 = require("commander");
@@ -11191,7 +11584,7 @@ var renderSubcommand = new import_commander35.Command("render").description("Ren
       printInfo("Loadout is empty. Nothing to render.");
       return;
     }
-    const output = server.renderSystemPrompt();
+    const output = await server.renderSystemPrompt();
     console.log(output);
   } catch (error) {
     printError(error.message);
@@ -11221,11 +11614,34 @@ var clearSubcommand = new import_commander36.Command("clear").description("Clear
   }
 });
 
+// src/cli/commands/loadout/browse.ts
+var import_commander37 = require("commander");
+var browseSubcommand = new import_commander37.Command("browse").description("Browse the skill catalog by category").argument("[path]", "Category path to browse (e.g., Development/Python)").action(async (pathArg, _options, command) => {
+  const globalOpts = command.optsWithGlobals();
+  try {
+    const { server } = await createLoadoutServer(globalOpts);
+    const path18 = pathArg ? pathArg.split("/").filter(Boolean) : void 0;
+    const output = await server.agentBrowseCatalog(path18);
+    if (globalOpts.json) {
+      console.log(JSON.stringify({ path: path18 ?? [], output }, null, 2));
+      return;
+    }
+    if (!output) {
+      printInfo("No catalog data available.");
+      return;
+    }
+    console.log(output);
+  } catch (error) {
+    printError(error.message);
+    process.exit(1);
+  }
+});
+
 // src/cli/commands/loadout/index.ts
-var loadoutCommand = new import_commander37.Command("loadout").description("Manage skill loadouts for agent sessions").addCommand(listSubcommand).addCommand(searchSubcommand).addCommand(addSubcommand).addCommand(removeSubcommand).addCommand(profileSubcommand).addCommand(setSubcommand).addCommand(expandSubcommand).addCommand(collapseSubcommand).addCommand(useSubcommand).addCommand(getSubcommand).addCommand(renderSubcommand).addCommand(clearSubcommand);
+var loadoutCommand = new import_commander38.Command("loadout").description("Manage skill loadouts for agent sessions").addCommand(listSubcommand).addCommand(searchSubcommand).addCommand(addSubcommand).addCommand(removeSubcommand).addCommand(profileSubcommand).addCommand(setSubcommand).addCommand(expandSubcommand).addCommand(collapseSubcommand).addCommand(useSubcommand).addCommand(getSubcommand).addCommand(renderSubcommand).addCommand(clearSubcommand).addCommand(browseSubcommand);
 
 // src/cli/index.ts
-var program = new import_commander38.Command();
+var program = new import_commander39.Command();
 var config = loadConfig();
 program.name("skill-tree").description("Management CLI for agent skills").version(VERSION).option("-p, --path <dir>", "Skills directory path", config.storage.path).option("-c, --config <file>", "Config file path", getConfigPath()).option("--json", "Output as JSON", config.cli.output_format === "json").option("-q, --quiet", "Suppress non-essential output", config.cli.quiet).option("--no-color", "Disable colored output", !config.cli.color);
 program.addCommand(listCommand);
@@ -11248,3 +11664,4 @@ program.addCommand(readCommand);
 program.addCommand(materializeCommand);
 program.addCommand(loadoutCommand);
 program.parse();
+//# sourceMappingURL=index.js.map