skill-tree 0.1.5 → 0.1.7

package/dist/index.js

@@ -853,15 +853,15 @@ var init_sqlite = __esm({
       /**
        * Get or create a taxonomy node
        */
-      async ensureTaxonomyNode(path11) {
+      async ensureTaxonomyNode(path13) {
         this.ensureInitialized();
         const db = this.getDb();
-        const pathStr = path11.join("/");
+        const pathStr = path13.join("/");
         const existing = db.prepare("SELECT id FROM taxonomy_nodes WHERE path = ?").get(pathStr);
         if (existing) return existing.id;
         const id = `node-${pathStr.replace(/\//g, "-").toLowerCase()}`;
-        const name = path11[path11.length - 1] || "Root";
-        const parentPath = path11.slice(0, -1);
+        const name = path13[path13.length - 1] || "Root";
+        const parentPath = path13.slice(0, -1);
         let parentId = null;
         if (parentPath.length > 0) {
           parentId = await this.ensureTaxonomyNode(parentPath);
@@ -1789,11 +1789,13 @@ __export(index_exports, {
   AgentsParser: () => AgentsParser,
   AgentsSync: () => AgentsSync,
   CachedStorageAdapter: () => CachedStorageAdapter,
+  CatalogRenderer: () => CatalogRenderer,
   ConflictStore: () => ConflictStore,
   DEFAULT_AGENTS_CONFIG: () => DEFAULT_AGENTS_CONFIG,
   FederationManager: () => FederationManager,
   GitSyncAdapter: () => GitSyncAdapter,
   HookRegistry: () => HookRegistry,
+  IndexerService: () => IndexerService,
   LineageTracker: () => LineageTracker,
   LoadoutCompiler: () => LoadoutCompiler,
   Materializer: () => Materializer,
@@ -2934,8 +2936,214 @@ function createSyncManager(options) {
   return new SyncManager(options);
 }
 
-// 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, config) {
+    this.storage = storage;
+    this.overviewCache = null;
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+  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(path13) {
+    if (hasCatalogSupport(this.storage)) {
+      return this.renderCategoryFromTaxonomy(this.storage, path13);
+    }
+    return this.renderCategoryFromTags(path13);
+  }
+  /**
+   * 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, path13) {
+    const tree = await storage.getTaxonomyTree(path13);
+    const pathStr = path13.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 = [...path13, 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(path13) {
+    if (path13.length === 0) {
+      return this.renderOverviewFromTags();
+    }
+    const tag = path13[0];
+    const matching = await this.storage.listSkills({ status: ["active"], tags: [tag] });
+    const pathStr = path13.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
@@ -2944,7 +3152,7 @@ var LoadoutCompiler = class {
   constructor(storage, config) {
     this.storage = storage;
     this.config = {
-      ...DEFAULT_CONFIG,
+      ...DEFAULT_CONFIG2,
       ...config
     };
   }
@@ -3165,11 +3373,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
    */
@@ -3331,71 +3604,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(config) {
-    this.config = { ...DEFAULT_CONFIG2, ...config };
+    this.config = { ...DEFAULT_CONFIG3, ...config };
   }
   /**
    * Render loadout state as OpenSkills-compatible XML
@@ -3422,6 +3639,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);
@@ -3534,23 +3763,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
@@ -3646,7 +3870,7 @@ function listBuiltInProfiles() {
 }
 
 // src/serving/graph-server.ts
-var DEFAULT_CONFIG3 = {
+var DEFAULT_CONFIG4 = {
   agentCanModify: true,
   agentCanSetLoadout: false,
   agentCanSwitchProfile: true,
@@ -3658,24 +3882,29 @@ var DEFAULT_CONFIG3 = {
   persistState: false,
   outputFormat: "xml",
   includeTokenEstimates: false,
+  enableCatalog: true,
   profiles: {}
 };
 var SkillGraphServer = class {
   // Track LRU for eviction
   constructor(storage, config) {
     this.storage = storage;
+    this.catalogRenderer = null;
     this.handlers = /* @__PURE__ */ new Set();
     this.lruOrder = [];
     this.config = {
-      ...DEFAULT_CONFIG3,
+      ...DEFAULT_CONFIG4,
       ...config,
-      profiles: { ...builtInProfiles, ...DEFAULT_CONFIG3.profiles, ...config?.profiles }
+      profiles: { ...builtInProfiles, ...DEFAULT_CONFIG4.profiles, ...config?.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, config?.catalogConfig);
+    }
     this.state = {
       available: /* @__PURE__ */ new Map(),
       expanded: /* @__PURE__ */ new Set(),
@@ -3964,17 +4193,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(path13) {
+    if (!this.catalogRenderer) {
+      return "<error>Catalog browsing is not enabled</error>";
+    }
+    if (!path13 || path13.length === 0) {
+      const result2 = await this.catalogRenderer.renderOverview();
+      if (result2) {
+        this.emit({ type: "catalog:browsed", path: [] });
+      }
+      return result2;
+    }
+    const result = await this.catalogRenderer.renderCategory(path13);
+    this.emit({ type: "catalog:browsed", path: path13 });
+    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);
     }
-    return this.viewRenderer.renderXml(this.state);
+    if (this.catalogRenderer) {
+      const overview = await this.catalogRenderer.renderOverview();
+      if (overview) {
+        prompt += "\n" + overview;
+      }
+    }
+    return prompt;
   }
   /**
    * Estimate total tokens for current loadout
@@ -4345,7 +4627,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"],
@@ -4373,7 +4655,7 @@ function getSkilltreeDir(repoRoot) {
 }
 function getSkillsDir(repoRoot, config) {
   const skilltreeDir = getSkilltreeDir(repoRoot);
-  const paths = config?.paths || DEFAULT_CONFIG4.paths;
+  const paths = config?.paths || DEFAULT_CONFIG5.paths;
   return path4.join(skilltreeDir, paths[0]);
 }
 function parseSkilltreeConfig(content) {
@@ -4386,10 +4668,10 @@ function validateConfig(config) {
   }
   return {
     version: 1,
-    discovery: config.discovery || DEFAULT_CONFIG4.discovery,
-    paths: config.paths || DEFAULT_CONFIG4.paths,
-    exclude: [...DEFAULT_CONFIG4.exclude || [], ...config.exclude || []],
-    skillFilePatterns: config.skillFilePatterns || DEFAULT_CONFIG4.skillFilePatterns,
+    discovery: config.discovery || DEFAULT_CONFIG5.discovery,
+    paths: config.paths || DEFAULT_CONFIG5.paths,
+    exclude: [...DEFAULT_CONFIG5.exclude || [], ...config.exclude || []],
+    skillFilePatterns: config.skillFilePatterns || DEFAULT_CONFIG5.skillFilePatterns,
     namespace: config.namespace
   };
 }
@@ -4400,7 +4682,7 @@ async function loadSkilltreeConfig(repoRoot) {
     return parseSkilltreeConfig(content);
   } catch (error) {
     if (error.code === "ENOENT") {
-      return { ...DEFAULT_CONFIG4 };
+      return { ...DEFAULT_CONFIG5 };
     }
     throw error;
   }
@@ -4435,7 +4717,7 @@ async function initSkilltreeDir(repoRoot, config) {
     );
   }
 }
-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("*")) {
@@ -4468,7 +4750,7 @@ async function discoverSkills(repoRoot) {
   if (config.discovery === "scan") {
     await scanForSkills(skilltreeDir, skilltreeDir, config, discovered);
   } else {
-    const paths = config.paths || DEFAULT_CONFIG4.paths;
+    const paths = config.paths || DEFAULT_CONFIG5.paths;
     for (const searchPath of paths) {
       const fullPath = path4.join(skilltreeDir, searchPath);
       await scanForSkills(skilltreeDir, fullPath, config, discovered);
@@ -8257,6 +8539,1168 @@ function createDefaultSyncConfig(remoteUrl, agentId, options) {
   };
 }
 
+// src/services/indexer.ts
+var path12 = __toESM(require("path"));
+var fs12 = __toESM(require("fs"));
+
+// src/config/types.ts
+var DEFAULT_CONFIG6 = {
+  storage: {
+    path: "~/.skill-tree"
+  },
+  indexer: {
+    sources: [],
+    batch_size: 10,
+    min_confidence: 0.7
+  },
+  matching: {
+    embedding_model: "text-embedding-3-small",
+    similarity_threshold: 0.8
+  },
+  sync: {
+    auto_check: false,
+    check_interval_hours: 24,
+    conflict_resolution: "prompt"
+  },
+  cli: {
+    output_format: "table",
+    color: true,
+    quiet: false
+  },
+  materialization: {
+    enabled: false,
+    mode: "symlink",
+    symlink_paths: [],
+    agents_md_path: "",
+    agents_md_format: "xml",
+    debounce_ms: 500
+  }
+};
+
+// src/config/loader.ts
+var fs11 = __toESM(require("fs"));
+var path11 = __toESM(require("path"));
+var os = __toESM(require("os"));
+var ENV_MAPPINGS = {
+  GITHUB_TOKEN: "indexer.github_token",
+  ANTHROPIC_API_KEY: "indexer.anthropic_key",
+  SKILL_TREE_STORAGE_PATH: "storage.path",
+  SKILL_TREE_OUTPUT_FORMAT: "cli.output_format",
+  SKILL_TREE_QUIET: "cli.quiet",
+  SKILL_TREE_NO_COLOR: "cli.color"
+};
+function getConfigDir() {
+  return path11.join(os.homedir(), ".skill-tree");
+}
+function getConfigPath() {
+  return path11.join(getConfigDir(), "config.yaml");
+}
+function expandPath(filePath) {
+  if (filePath.startsWith("~/")) {
+    return path11.join(os.homedir(), filePath.slice(2));
+  }
+  if (filePath.startsWith("~")) {
+    return path11.join(os.homedir(), filePath.slice(1));
+  }
+  return filePath;
+}
+function substituteEnvVars(value) {
+  let result = value.replace(/\$\{([^}]+)\}/g, (_, varName) => {
+    return process.env[varName] || "";
+  });
+  result = result.replace(/\$([A-Z_][A-Z0-9_]*)/gi, (_, varName) => {
+    return process.env[varName] || "";
+  });
+  return result;
+}
+function substituteEnvVarsInObject(obj) {
+  if (typeof obj === "string") {
+    return substituteEnvVars(obj);
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => substituteEnvVarsInObject(item));
+  }
+  if (obj !== null && typeof obj === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[key] = substituteEnvVarsInObject(value);
+    }
+    return result;
+  }
+  return obj;
+}
+function setNestedProperty(obj, path13, value) {
+  const parts = path13.split(".");
+  let current = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (!(part in current)) {
+      current[part] = {};
+    }
+    current = current[part];
+  }
+  current[parts[parts.length - 1]] = value;
+}
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    const sourceValue = source[key];
+    const targetValue = result[key];
+    if (sourceValue !== void 0 && typeof sourceValue === "object" && sourceValue !== null && !Array.isArray(sourceValue) && typeof targetValue === "object" && targetValue !== null && !Array.isArray(targetValue)) {
+      result[key] = deepMerge(
+        targetValue,
+        sourceValue
+      );
+    } else if (sourceValue !== void 0) {
+      result[key] = sourceValue;
+    }
+  }
+  return result;
+}
+function parseSimpleYaml(content) {
+  const result = {};
+  const lines = content.split("\n");
+  const stack = [{ indent: -1, obj: result }];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+      continue;
+    }
+    const indent = line.search(/\S/);
+    while (stack.length > 1 && stack[stack.length - 1].indent >= indent) {
+      stack.pop();
+    }
+    const parent = stack[stack.length - 1].obj;
+    const colonIndex = trimmed.indexOf(":");
+    if (colonIndex === -1) continue;
+    const key = trimmed.slice(0, colonIndex).trim();
+    let value = trimmed.slice(colonIndex + 1).trim();
+    if (value === "") {
+      const newObj = {};
+      parent[key] = newObj;
+      stack.push({ indent, obj: newObj });
+    } else if (value.startsWith("[") && value.endsWith("]")) {
+      const items = value.slice(1, -1).split(",").map((s) => s.trim()).filter(Boolean);
+      parent[key] = items.map((item) => {
+        if (item.startsWith('"') && item.endsWith('"') || item.startsWith("'") && item.endsWith("'")) {
+          return item.slice(1, -1);
+        }
+        if (item === "true") return true;
+        if (item === "false") return false;
+        const num = Number(item);
+        if (!isNaN(num)) return num;
+        return item;
+      });
+    } else {
+      if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+        value = value.slice(1, -1);
+      }
+      if (value === "true") {
+        parent[key] = true;
+      } else if (value === "false") {
+        parent[key] = false;
+      } else {
+        const num = Number(value);
+        if (!isNaN(num) && value !== "") {
+          parent[key] = num;
+        } else {
+          parent[key] = value;
+        }
+      }
+    }
+  }
+  return result;
+}
+function loadConfigFromFile(configPath) {
+  const expandedPath = expandPath(configPath);
+  if (!fs11.existsSync(expandedPath)) {
+    return null;
+  }
+  try {
+    const content = fs11.readFileSync(expandedPath, "utf-8");
+    const parsed = parseSimpleYaml(content);
+    return substituteEnvVarsInObject(parsed);
+  } catch (error) {
+    console.error(`Warning: Failed to parse config file ${configPath}:`, error);
+    return null;
+  }
+}
+function loadConfigFromEnv() {
+  const config = {};
+  for (const [envVar, configPath] of Object.entries(ENV_MAPPINGS)) {
+    const value = process.env[envVar];
+    if (value !== void 0) {
+      if (envVar === "SKILL_TREE_NO_COLOR") {
+        setNestedProperty(config, configPath, value !== "true" && value !== "1");
+      } else if (envVar === "SKILL_TREE_QUIET") {
+        setNestedProperty(config, configPath, value === "true" || value === "1");
+      } else {
+        setNestedProperty(config, configPath, value);
+      }
+    }
+  }
+  return config;
+}
+var ConfigLoader = class {
+  constructor(configPath) {
+    this.loaded = false;
+    this.configPath = configPath || getConfigPath();
+    this.config = { ...DEFAULT_CONFIG6 };
+  }
+  /**
+   * Load configuration from all sources
+   * Priority (highest to lowest):
+   * 1. Environment variables
+   * 2. Config file
+   * 3. Default values
+   */
+  load() {
+    if (this.loaded) {
+      return this.config;
+    }
+    let config = deepMerge({}, DEFAULT_CONFIG6);
+    const fileConfig = loadConfigFromFile(this.configPath);
+    if (fileConfig) {
+      config = deepMerge(config, fileConfig);
+    }
+    const envConfig = loadConfigFromEnv();
+    config = deepMerge(config, envConfig);
+    config.storage.path = expandPath(config.storage.path);
+    this.config = config;
+    this.loaded = true;
+    return this.config;
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    if (!this.loaded) {
+      return this.load();
+    }
+    return this.config;
+  }
+  /**
+   * Override configuration with partial values
+   */
+  override(overrides) {
+    this.config = deepMerge(this.getConfig(), overrides);
+    return this.config;
+  }
+  /**
+   * Get a specific config value by path
+   */
+  get(path13) {
+    const parts = path13.split(".");
+    let current = this.getConfig();
+    for (const part of parts) {
+      if (current === null || typeof current !== "object") {
+        return void 0;
+      }
+      current = current[part];
+    }
+    return current;
+  }
+  /**
+   * Check if config file exists
+   */
+  configFileExists() {
+    return fs11.existsSync(expandPath(this.configPath));
+  }
+  /**
+   * Create default config file
+   */
+  createDefaultConfigFile() {
+    const configDir = path11.dirname(expandPath(this.configPath));
+    if (!fs11.existsSync(configDir)) {
+      fs11.mkdirSync(configDir, { recursive: true });
+    }
+    const configContent = `# Skill Tree Configuration
+# Generated by skill-tree
+
+storage:
+  # Path to .skilltree directory (skills stored as files, SQLite cache auto-generated)
+  path: ~/.skill-tree
+
+indexer:
+  # GitHub token for API access (or use GITHUB_TOKEN env var)
+  github_token: \${GITHUB_TOKEN}
+  # Anthropic API key for classification (or use ANTHROPIC_API_KEY env var)
+  anthropic_key: \${ANTHROPIC_API_KEY}
+  sources: []
+  batch_size: 10
+  min_confidence: 0.7
+
+matching:
+  embedding_model: text-embedding-3-small
+  similarity_threshold: 0.8
+
+sync:
+  auto_check: false
+  check_interval_hours: 24
+  conflict_resolution: prompt
+
+cli:
+  output_format: table
+  color: true
+  quiet: false
+
+materialization:
+  # Enable automatic materialization to agent-discoverable paths
+  enabled: false
+  # Mode: 'symlink' (default) or 'copy'
+  mode: symlink
+  # Directories to expose skills in (e.g. .claude/skills, .agent/skills)
+  symlink_paths: []
+  # Path to auto-generate AGENTS.md (empty = disabled)
+  agents_md_path: ""
+  # Format for AGENTS.md: xml, markdown, json
+  agents_md_format: xml
+  # Debounce interval in ms for batch updates
+  debounce_ms: 500
+`;
+    fs11.writeFileSync(expandPath(this.configPath), configContent);
+  }
+};
+var globalConfig = null;
+function getConfigLoader(configPath) {
+  if (!globalConfig) {
+    globalConfig = new ConfigLoader(configPath);
+  }
+  return globalConfig;
+}
+function loadConfig(configPath) {
+  return getConfigLoader(configPath).load();
+}
+
+// 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");
+  }
+  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 };
+}
+
+// src/services/indexer.ts
+function hasIndexerSupport(storage) {
+  const s = storage;
+  return typeof s.addRelationship === "function" && typeof s.getTaxonomyTree === "function";
+}
+var IndexerService = class {
+  constructor(config = {}, skillBank) {
+    this.initialized = false;
+    this.globalConfig = loadConfig();
+    this.serviceConfig = {
+      githubToken: config.githubToken || this.globalConfig.indexer.github_token,
+      anthropicApiKey: config.anthropicApiKey || this.globalConfig.indexer.anthropic_key,
+      batchSize: config.batchSize || this.globalConfig.indexer.batch_size,
+      minConfidence: config.minConfidence || this.globalConfig.indexer.min_confidence,
+      concurrency: config.concurrency || 3,
+      cacheTtlSeconds: config.cacheTtlSeconds || 3600,
+      databasePath: config.databasePath,
+      cacheDir: config.cacheDir,
+      claudeModel: config.claudeModel,
+      scraperModules: config.scraperModules
+    };
+    this.skillBank = skillBank;
+  }
+  /**
+   * Get effective configuration
+   */
+  getConfig() {
+    return { ...this.serviceConfig };
+  }
+  /**
+   * 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: (config) => {
+              const scraperConfig = {
+                githubToken: config.githubToken || "",
+                cacheEnabled: true,
+                cacheDir: config.cacheDir || path12.join(process.cwd(), ".cache/scraper"),
+                cacheTtlSeconds: config.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: (config) => {
+              const classifier = new mod.SkillClassifier(config);
+              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;
+    }
+  }
+  /**
+   * Check if the indexer is available
+   */
+  isAvailable() {
+    return this.initialized && !!this.scraperModule;
+  }
+  /**
+   * Check if running in degraded mode (no scraper modules)
+   */
+  isDegradedMode() {
+    return this.initialized && !this.scraperModule;
+  }
+  /**
+   * 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"
+      );
+    }
+    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}`);
+    }
+    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"
+      );
+    }
+    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}`);
+    }
+    return result;
+  }
+  /**
+   * 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;
+    }
+    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;
+  }
+  /**
+   * 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(" > ")}`
+          });
+        }
+      }
+    }
+    return relationships;
+  }
+  /**
+   * 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);
+      }
+    }
+    const skills = this.skillBank ? await this.skillBank.listSkills() : this.db?.getAllSkills?.() || [];
+    return this.buildTaxonomyTreeFromSkills(skills, rootPath);
+  }
+  /**
+   * 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);
+    }
+    return root;
+  }
+  /**
+   * 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)
+      )
+    };
+  }
+  /**
+   * 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;
+  }
+  /**
+   * 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;
+  }
+  /**
+   * 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 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 (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
+    };
+  }
+  /**
+   * 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 count;
+  }
+  /**
+   * 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 });
+    }
+    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
+    };
+  }
+  /**
+   * Import skills from indexer database into SkillBank
+   */
+  async importFromIndexerDb(options) {
+    if (!this.skillBank) {
+      throw new Error("SkillBank not configured. Use integrated mode.");
+    }
+    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?.() || [];
+      }
+      if (options?.limit) {
+        skills = skills.slice(0, options.limit);
+      }
+      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++;
+        }
+      }
+    } 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
+      }));
+    }
+    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();
+    }
+    this.db = void 0;
+    this.initialized = false;
+  }
+};
+
 // src/index.ts
 var VERSION = "0.1.0";
 // Annotate the CommonJS export names for ESM import in node:
@@ -8265,11 +9709,13 @@ var VERSION = "0.1.0";
   AgentsParser,
   AgentsSync,
   CachedStorageAdapter,
+  CatalogRenderer,
   ConflictStore,
   DEFAULT_AGENTS_CONFIG,
   FederationManager,
   GitSyncAdapter,
   HookRegistry,
+  IndexerService,
   LineageTracker,
   LoadoutCompiler,
   Materializer,
@@ -8326,3 +9772,4 @@ var VERSION = "0.1.0";
   testingProfile,
   writeAgentsMd
 });
+//# sourceMappingURL=index.js.map