@skill-tools/router 0.2.0

package/dist/index.js

@@ -0,0 +1,950 @@
+import { resolveSkillFiles, parseSkill } from '@skill-tools/core';
+
+// src/bm25/index.ts
+var BM25Index = class {
+  k1;
+  b;
+  documents = [];
+  invertedIndex = /* @__PURE__ */ new Map();
+  idfCache = /* @__PURE__ */ new Map();
+  avgdl = 0;
+  totalDocLength = 0;
+  constructor(options) {
+    this.k1 = options?.k1 ?? 1.2;
+    this.b = options?.b ?? 0.75;
+  }
+  /**
+   * Add documents to the index.
+   * Batch operation — IDF is recomputed once after all documents are added.
+   */
+  add(entries) {
+    if (entries.length === 0) return;
+    for (const entry of entries) {
+      const tokens = tokenize(entry.text);
+      const docIdx = this.documents.length;
+      this.documents.push({
+        id: entry.id,
+        length: tokens.length,
+        metadata: entry.metadata
+      });
+      this.totalDocLength += tokens.length;
+      const termFreq = /* @__PURE__ */ new Map();
+      for (const token of tokens) {
+        termFreq.set(token, (termFreq.get(token) ?? 0) + 1);
+      }
+      for (const [term, tf] of termFreq) {
+        let postings = this.invertedIndex.get(term);
+        if (!postings) {
+          postings = [];
+          this.invertedIndex.set(term, postings);
+        }
+        postings.push({ docIdx, tf });
+      }
+    }
+    this.avgdl = this.totalDocLength / this.documents.length;
+    this.recomputeIDF();
+  }
+  /**
+   * Remove documents by ID.
+   * Rebuilds internal index mappings after removal.
+   */
+  remove(ids) {
+    const idSet = new Set(ids);
+    const removedIndices = /* @__PURE__ */ new Set();
+    for (let i = 0; i < this.documents.length; i++) {
+      if (idSet.has(this.documents[i].id)) {
+        removedIndices.add(i);
+        this.totalDocLength -= this.documents[i].length;
+      }
+    }
+    if (removedIndices.size === 0) return;
+    const newDocuments = [];
+    const indexMap = /* @__PURE__ */ new Map();
+    for (let i = 0; i < this.documents.length; i++) {
+      if (!removedIndices.has(i)) {
+        indexMap.set(i, newDocuments.length);
+        newDocuments.push(this.documents[i]);
+      }
+    }
+    this.documents = newDocuments;
+    for (const [term, postings] of this.invertedIndex) {
+      const filtered = [];
+      for (const p of postings) {
+        if (!removedIndices.has(p.docIdx)) {
+          filtered.push({ docIdx: indexMap.get(p.docIdx), tf: p.tf });
+        }
+      }
+      if (filtered.length === 0) {
+        this.invertedIndex.delete(term);
+      } else {
+        this.invertedIndex.set(term, filtered);
+      }
+    }
+    this.avgdl = this.documents.length > 0 ? this.totalDocLength / this.documents.length : 0;
+    this.recomputeIDF();
+  }
+  /**
+   * Search the index with a query string.
+   *
+   * Returns results sorted by BM25 score (highest first).
+   * Scores are normalized to [0, 1] — the top result gets 1.0.
+   *
+   * Only documents containing at least one query term are scored,
+   * making queries fast even on large indexes.
+   */
+  search(query, topK, threshold = 0) {
+    if (this.documents.length === 0) return [];
+    const queryTokens = tokenize(query);
+    if (queryTokens.length === 0) return [];
+    const scores = new Float64Array(this.documents.length);
+    let hasScores = false;
+    for (const token of queryTokens) {
+      const idf = this.idfCache.get(token);
+      if (idf === void 0 || idf <= 0) continue;
+      const postings = this.invertedIndex.get(token);
+      if (!postings) continue;
+      for (const posting of postings) {
+        const docLen = this.documents[posting.docIdx].length;
+        const tf = posting.tf;
+        const numerator = tf * (this.k1 + 1);
+        const denominator = tf + this.k1 * (1 - this.b + this.b * (docLen / this.avgdl));
+        scores[posting.docIdx] = scores[posting.docIdx] + idf * (numerator / denominator);
+        hasScores = true;
+      }
+    }
+    if (!hasScores) return [];
+    let maxScore = 0;
+    for (let i = 0; i < scores.length; i++) {
+      if (scores[i] > maxScore) maxScore = scores[i];
+    }
+    if (maxScore === 0) return [];
+    const results = [];
+    for (let i = 0; i < scores.length; i++) {
+      const raw = scores[i];
+      if (raw === 0) continue;
+      const normalized = raw / maxScore;
+      if (normalized >= threshold) {
+        results.push({
+          id: this.documents[i].id,
+          score: normalized,
+          metadata: this.documents[i].metadata
+        });
+      }
+    }
+    results.sort((a, b) => b.score - a.score);
+    return results.slice(0, topK);
+  }
+  /** Number of indexed documents */
+  size() {
+    return this.documents.length;
+  }
+  /** Serialize to a JSON-compatible snapshot */
+  serialize() {
+    return {
+      version: 2,
+      documents: this.documents.map((d) => ({
+        id: d.id,
+        length: d.length,
+        metadata: d.metadata
+      })),
+      invertedIndex: Array.from(this.invertedIndex.entries()),
+      idf: Array.from(this.idfCache.entries()),
+      avgdl: this.avgdl,
+      k1: this.k1,
+      b: this.b
+    };
+  }
+  /** Restore from a serialized snapshot */
+  deserialize(data) {
+    const obj = data;
+    if (!obj || typeof obj !== "object") {
+      throw new Error("Invalid BM25 snapshot: expected an object");
+    }
+    if (obj.version !== 2) {
+      throw new Error(`Unsupported BM25 snapshot version: ${obj.version}`);
+    }
+    this.documents = obj.documents.map((d) => ({
+      id: d.id,
+      length: d.length,
+      metadata: d.metadata
+    }));
+    this.invertedIndex = new Map(obj.invertedIndex.map(([k, v]) => [k, [...v]]));
+    this.idfCache = new Map(obj.idf);
+    this.avgdl = obj.avgdl;
+    this.totalDocLength = this.documents.reduce((sum, d) => sum + d.length, 0);
+  }
+  /** Recompute IDF values for all terms in the inverted index */
+  recomputeIDF() {
+    const N = this.documents.length;
+    this.idfCache.clear();
+    for (const [term, postings] of this.invertedIndex) {
+      const df = postings.length;
+      this.idfCache.set(term, Math.log((N - df + 0.5) / (df + 0.5) + 1));
+    }
+  }
+};
+function tokenize(text) {
+  return text.toLowerCase().replace(/[^a-z0-9\s-]/g, " ").split(/\s+/).filter((t) => t.length > 1 && !STOP_WORDS.has(t));
+}
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "the",
+  "is",
+  "are",
+  "was",
+  "were",
+  "be",
+  "been",
+  "being",
+  "have",
+  "has",
+  "had",
+  "do",
+  "does",
+  "did",
+  "will",
+  "would",
+  "could",
+  "should",
+  "may",
+  "might",
+  "shall",
+  "can",
+  "must",
+  "to",
+  "of",
+  "in",
+  "for",
+  "on",
+  "with",
+  "at",
+  "by",
+  "from",
+  "as",
+  "into",
+  "through",
+  "during",
+  "before",
+  "after",
+  "above",
+  "below",
+  "between",
+  "out",
+  "off",
+  "over",
+  "under",
+  "again",
+  "further",
+  "then",
+  "once",
+  "here",
+  "there",
+  "when",
+  "where",
+  "why",
+  "how",
+  "all",
+  "each",
+  "every",
+  "both",
+  "few",
+  "more",
+  "most",
+  "other",
+  "some",
+  "such",
+  "no",
+  "nor",
+  "not",
+  "only",
+  "own",
+  "same",
+  "so",
+  "than",
+  "too",
+  "very",
+  "and",
+  "but",
+  "or",
+  "if",
+  "it",
+  "its",
+  "this",
+  "that",
+  "these",
+  "those",
+  "he",
+  "she",
+  "they",
+  "we",
+  "you",
+  "i",
+  "me",
+  "my",
+  "your",
+  "his",
+  "her",
+  "their",
+  "our",
+  "what",
+  "which",
+  "who",
+  "whom"
+]);
+
+// src/context/extractor.ts
+var MAX_CONTEXT_TOKENS = 80;
+function extractContext(skill) {
+  const terms = [];
+  const nameParts = skill.name.split(/[-_]/).map((p) => p.toLowerCase()).filter((p) => p.length > 1);
+  terms.push(...nameParts);
+  if (skill.sections) {
+    for (const section of skill.sections) {
+      const headingWords = section.heading.toLowerCase().replace(/[^a-z0-9\s-]/g, " ").split(/\s+/).filter((w) => w.length > 1);
+      terms.push(...headingWords);
+    }
+  }
+  if (skill.body) {
+    const codeRefs = extractCodeRefs(skill.body);
+    terms.push(...codeRefs);
+  }
+  if (skill.sections) {
+    for (const section of skill.sections) {
+      const contentWords = section.content.toLowerCase().replace(/[^a-z0-9\s-]/g, " ").split(/\s+/).filter((w) => w.length > 3 && !COMMON_WORDS.has(w));
+      terms.push(...contentWords);
+    }
+  }
+  const descLower = skill.description.toLowerCase();
+  const descTokens = new Set(
+    descLower.replace(/[^a-z0-9\s-]/g, " ").split(/\s+/).filter((t) => t.length > 0)
+  );
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const term of terms) {
+    const lower = term.toLowerCase();
+    if (lower.length < 2) continue;
+    if (seen.has(lower)) continue;
+    if (descTokens.has(lower)) continue;
+    seen.add(lower);
+    unique.push(lower);
+  }
+  return truncateTokens(unique, MAX_CONTEXT_TOKENS).join(" ");
+}
+function extractCodeRefs(body) {
+  const refs = [];
+  const pattern = /`([^`\n]+)`/g;
+  for (const match of body.matchAll(pattern)) {
+    const code = match[1].trim();
+    const parts = code.split(/\s+/).map((p) => p.replace(/^-+/, "").toLowerCase()).filter((p) => p.length > 1);
+    refs.push(...parts);
+  }
+  return refs;
+}
+function truncateTokens(tokens, max) {
+  if (tokens.length <= max) return tokens;
+  return tokens.slice(0, max);
+}
+var COMMON_WORDS = /* @__PURE__ */ new Set([
+  "also",
+  "about",
+  "after",
+  "again",
+  "been",
+  "before",
+  "being",
+  "between",
+  "both",
+  "check",
+  "could",
+  "does",
+  "done",
+  "down",
+  "each",
+  "even",
+  "every",
+  "first",
+  "following",
+  "from",
+  "have",
+  "here",
+  "into",
+  "just",
+  "know",
+  "like",
+  "make",
+  "many",
+  "might",
+  "more",
+  "most",
+  "much",
+  "must",
+  "need",
+  "only",
+  "other",
+  "over",
+  "same",
+  "should",
+  "some",
+  "such",
+  "sure",
+  "take",
+  "than",
+  "that",
+  "them",
+  "then",
+  "there",
+  "these",
+  "they",
+  "this",
+  "those",
+  "through",
+  "under",
+  "very",
+  "want",
+  "well",
+  "were",
+  "what",
+  "when",
+  "where",
+  "which",
+  "while",
+  "will",
+  "with",
+  "would",
+  "your"
+]);
+
+// src/embeddings/local.ts
+var LocalEmbeddingProvider = class {
+  name = "local-tfidf";
+  dimensions;
+  vocabulary = /* @__PURE__ */ new Map();
+  idfValues = /* @__PURE__ */ new Map();
+  isBuilt = false;
+  constructor(dimensions = 256) {
+    this.dimensions = dimensions;
+  }
+  /**
+   * Build the vocabulary and IDF values from a corpus.
+   * Call this once after indexing all skill descriptions.
+   */
+  buildVocabulary(texts) {
+    const docCount = texts.length;
+    const termDocFreq = /* @__PURE__ */ new Map();
+    for (const text of texts) {
+      const tokens = new Set(tokenize2(text));
+      for (const token of tokens) {
+        termDocFreq.set(token, (termDocFreq.get(token) ?? 0) + 1);
+      }
+    }
+    for (const [term, df] of termDocFreq) {
+      this.idfValues.set(term, Math.log((docCount + 1) / (df + 1)) + 1);
+    }
+    const sorted = Array.from(this.idfValues.entries()).sort((a, b) => b[1] - a[1]);
+    let idx = 0;
+    for (const [term] of sorted) {
+      this.vocabulary.set(term, idx % this.dimensions);
+      idx++;
+    }
+    this.isBuilt = true;
+  }
+  async embed(texts) {
+    return texts.map((text) => this.embedSingle(text));
+  }
+  embedSingle(text) {
+    const vector = new Float64Array(this.dimensions);
+    const tokens = tokenize2(text);
+    const termFreq = /* @__PURE__ */ new Map();
+    for (const token of tokens) {
+      termFreq.set(token, (termFreq.get(token) ?? 0) + 1);
+    }
+    for (const [term, tf] of termFreq) {
+      const idf = this.idfValues.get(term) ?? 1;
+      const tfidf = (1 + Math.log(tf)) * idf;
+      if (this.isBuilt) {
+        const idx = this.vocabulary.get(term);
+        if (idx !== void 0) {
+          vector[idx] = (vector[idx] ?? 0) + tfidf;
+        }
+      } else {
+        const idx = hashToIndex(term, this.dimensions);
+        vector[idx] = (vector[idx] ?? 0) + tfidf;
+      }
+    }
+    return l2Normalize(Array.from(vector));
+  }
+};
+function tokenize2(text) {
+  return text.toLowerCase().replace(/[^a-z0-9\s-]/g, " ").split(/\s+/).filter((t) => t.length > 1 && !STOP_WORDS2.has(t));
+}
+function hashToIndex(str, size) {
+  let hash = 2166136261;
+  for (let i = 0; i < str.length; i++) {
+    hash ^= str.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return Math.abs(hash) % size;
+}
+function l2Normalize(vector) {
+  let sum = 0;
+  for (const v of vector) {
+    sum += v * v;
+  }
+  const magnitude = Math.sqrt(sum);
+  if (magnitude === 0) return vector;
+  return vector.map((v) => v / magnitude);
+}
+var STOP_WORDS2 = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "the",
+  "is",
+  "are",
+  "was",
+  "were",
+  "be",
+  "been",
+  "being",
+  "have",
+  "has",
+  "had",
+  "do",
+  "does",
+  "did",
+  "will",
+  "would",
+  "could",
+  "should",
+  "may",
+  "might",
+  "shall",
+  "can",
+  "must",
+  "to",
+  "of",
+  "in",
+  "for",
+  "on",
+  "with",
+  "at",
+  "by",
+  "from",
+  "as",
+  "into",
+  "through",
+  "during",
+  "before",
+  "after",
+  "above",
+  "below",
+  "between",
+  "out",
+  "off",
+  "over",
+  "under",
+  "again",
+  "further",
+  "then",
+  "once",
+  "here",
+  "there",
+  "when",
+  "where",
+  "why",
+  "how",
+  "all",
+  "each",
+  "every",
+  "both",
+  "few",
+  "more",
+  "most",
+  "other",
+  "some",
+  "such",
+  "no",
+  "nor",
+  "not",
+  "only",
+  "own",
+  "same",
+  "so",
+  "than",
+  "too",
+  "very",
+  "and",
+  "but",
+  "or",
+  "if",
+  "it",
+  "its",
+  "this",
+  "that",
+  "these",
+  "those",
+  "he",
+  "she",
+  "they",
+  "we",
+  "you",
+  "i",
+  "me",
+  "my",
+  "your",
+  "his",
+  "her",
+  "their",
+  "our",
+  "what",
+  "which",
+  "who",
+  "whom"
+]);
+
+// src/stores/memory.ts
+var MemoryVectorStore = class {
+  entries = [];
+  async add(entries) {
+    this.entries.push(...entries);
+  }
+  async search(queryVector, topK, threshold = 0) {
+    const scored = this.entries.map((entry) => ({
+      id: entry.id,
+      score: cosineSimilarity(queryVector, entry.vector),
+      metadata: entry.metadata
+    }));
+    return scored.filter((r) => r.score >= threshold).sort((a, b) => b.score - a.score).slice(0, topK);
+  }
+  async remove(ids) {
+    const idSet = new Set(ids);
+    this.entries = this.entries.filter((e) => !idSet.has(e.id));
+  }
+  size() {
+    return this.entries.length;
+  }
+  serialize() {
+    return {
+      version: 1,
+      entries: this.entries.map((e) => ({
+        id: e.id,
+        vector: e.vector,
+        metadata: e.metadata
+      }))
+    };
+  }
+  deserialize(data) {
+    if (!data || typeof data !== "object") {
+      throw new Error("Invalid snapshot: expected an object");
+    }
+    const obj = data;
+    if (obj.version !== 1) {
+      throw new Error(`Unsupported vector store version: ${obj.version}`);
+    }
+    if (!Array.isArray(obj.entries)) {
+      throw new Error("Invalid snapshot: entries must be an array");
+    }
+    for (const entry of obj.entries) {
+      if (!entry || typeof entry !== "object") {
+        throw new Error("Invalid snapshot: each entry must be an object");
+      }
+      const e = entry;
+      if (typeof e.id !== "string") {
+        throw new Error("Invalid snapshot: entry id must be a string");
+      }
+      if (!Array.isArray(e.vector) || !e.vector.every((v) => typeof v === "number")) {
+        throw new Error("Invalid snapshot: entry vector must be an array of numbers");
+      }
+    }
+    this.entries = obj.entries;
+  }
+};
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length) {
+    throw new Error(`Vector dimension mismatch: ${a.length} vs ${b.length}`);
+  }
+  let dotProduct = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dotProduct += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  const denominator = Math.sqrt(normA) * Math.sqrt(normB);
+  if (denominator === 0) return 0;
+  return dotProduct / denominator;
+}
+
+// src/router.ts
+var SkillRouter = class _SkillRouter {
+  /** BM25 index — used when no external embedding provider is configured */
+  bm25;
+  /** Embedding provider — used with custom/openai/ollama providers */
+  embedding;
+  /** Vector store — used alongside embedding provider */
+  store;
+  /** Whether the router uses the BM25 engine (true) or embedding+store (false) */
+  usesBM25;
+  /** Whether contextual retrieval is enabled */
+  contextEnabled;
+  skillNames = /* @__PURE__ */ new Set();
+  constructor(options) {
+    const embeddingConfig = options?.embedding ?? "local";
+    this.contextEnabled = options?.context !== false;
+    if (embeddingConfig === "local") {
+      this.bm25 = new BM25Index(options?.bm25);
+      this.embedding = null;
+      this.store = null;
+      this.usesBM25 = true;
+    } else {
+      this.embedding = createEmbeddingProvider(embeddingConfig);
+      this.store = new MemoryVectorStore();
+      this.bm25 = null;
+      this.usesBM25 = false;
+    }
+  }
+  /**
+   * Index a list of skill entries.
+   * With BM25 (default): indexes description text directly.
+   * With embeddings: embeds descriptions and stores vectors.
+   */
+  async indexSkills(skills) {
+    if (skills.length === 0) return;
+    if (this.usesBM25 && this.bm25) {
+      this.bm25.add(
+        skills.map((s) => ({
+          id: s.name,
+          text: this.enrichText(s),
+          metadata: {
+            description: s.description,
+            path: s.path,
+            ...s.metadata
+          }
+        }))
+      );
+    } else if (this.embedding && this.store) {
+      const descriptions = skills.map((s) => this.enrichText(s));
+      if (this.embedding instanceof LocalEmbeddingProvider) {
+        this.embedding.buildVocabulary(descriptions);
+      }
+      const vectors = await this.embedding.embed(descriptions);
+      const entries = skills.map((skill, i) => ({
+        id: skill.name,
+        vector: vectors[i],
+        metadata: {
+          description: skill.description,
+          path: skill.path,
+          ...skill.metadata
+        }
+      }));
+      await this.store.add(entries);
+    }
+    for (const skill of skills) {
+      this.skillNames.add(skill.name);
+    }
+  }
+  /**
+   * Index all SKILL.md files in a directory.
+   * Parses each file and indexes its description.
+   */
+  async indexDirectory(dirPath) {
+    const locations = await resolveSkillFiles(dirPath);
+    const skills = [];
+    for (const location of locations) {
+      const result = await parseSkill(location.skillFile);
+      if (result.ok && result.skill.metadata.description) {
+        skills.push({
+          name: result.skill.metadata.name ?? location.dirName,
+          description: result.skill.metadata.description,
+          path: location.skillFile,
+          body: result.skill.body,
+          sections: result.skill.sections
+        });
+      }
+    }
+    await this.indexSkills(skills);
+    return skills.length;
+  }
+  /**
+   * Select the most relevant skills for a query.
+   */
+  async select(query, options) {
+    const topK = options?.topK ?? 5;
+    const threshold = options?.threshold ?? 0;
+    const boost = new Set(options?.boost ?? []);
+    const exclude = options?.exclude ?? [];
+    let results;
+    if (this.usesBM25 && this.bm25) {
+      results = this.bm25.search(query, topK * 2, threshold);
+    } else if (this.embedding && this.store) {
+      const [queryVector] = await this.embedding.embed([query]);
+      if (!queryVector) {
+        throw new Error("Embedding provider returned empty result for query");
+      }
+      results = await this.store.search(queryVector, topK * 2, threshold);
+    } else {
+      return [];
+    }
+    if (exclude.length > 0) {
+      results = results.filter((r) => {
+        return !exclude.some((pattern) => {
+          if (pattern.endsWith("*")) {
+            return r.id.startsWith(pattern.slice(0, -1));
+          }
+          return r.id === pattern;
+        });
+      });
+    }
+    if (boost.size > 0) {
+      results = results.map((r) => ({
+        ...r,
+        score: boost.has(r.id) ? r.score * 1.2 : r.score
+      }));
+      results.sort((a, b) => b.score - a.score);
+    }
+    return results.slice(0, topK).map((r) => ({
+      skill: r.id,
+      score: r.score,
+      metadata: r.metadata
+    }));
+  }
+  /**
+   * Detect skills with overlapping descriptions.
+   */
+  async detectConflicts(threshold = 0.85) {
+    const conflicts = [];
+    const names = Array.from(this.skillNames);
+    if (this.usesBM25 && this.bm25) {
+      for (const name of names) {
+        const results = this.bm25.search(name, names.length, threshold);
+        const similar = results.filter((r) => r.id !== name && r.score >= threshold).map((r) => r.id);
+        if (similar.length > 0) {
+          const existing = conflicts.find(
+            (c) => c.skills.includes(name) || similar.some((s) => c.skills.includes(s))
+          );
+          if (!existing) {
+            conflicts.push({
+              skills: [name, ...similar],
+              similarity: results.find((r) => r.id !== name)?.score ?? threshold,
+              suggestion: "These skills have highly similar descriptions. Consider differentiating their trigger contexts."
+            });
+          }
+        }
+      }
+    } else if (this.embedding && this.store) {
+      for (const name of names) {
+        const results = await this.store.search(
+          (await this.embedding.embed([name]))[0],
+          names.length,
+          threshold
+        );
+        const similar = results.filter((r) => r.id !== name && r.score >= threshold).map((r) => r.id);
+        if (similar.length > 0) {
+          const existing = conflicts.find(
+            (c) => c.skills.includes(name) || similar.some((s) => c.skills.includes(s))
+          );
+          if (!existing) {
+            conflicts.push({
+              skills: [name, ...similar],
+              similarity: results.find((r) => r.id !== name)?.score ?? threshold,
+              suggestion: "These skills have highly similar descriptions. Consider differentiating their trigger contexts."
+            });
+          }
+        }
+      }
+    }
+    return conflicts;
+  }
+  /**
+   * Build the text to index for a skill entry.
+   * When contextual retrieval is enabled and the skill has body/sections,
+   * prepends extracted context to the description.
+   */
+  enrichText(skill) {
+    if (this.contextEnabled && (skill.body || skill.sections)) {
+      const ctx = extractContext(skill);
+      if (ctx) return `${ctx} ${skill.description}`;
+    }
+    return skill.description;
+  }
+  /**
+   * Get the number of indexed skills.
+   */
+  get count() {
+    if (this.usesBM25 && this.bm25) {
+      return this.bm25.size();
+    }
+    return this.store?.size() ?? 0;
+  }
+  /**
+   * Save the index to a JSON-serializable object.
+   */
+  save() {
+    if (this.usesBM25 && this.bm25) {
+      return {
+        version: 1,
+        embeddingProvider: "bm25",
+        dimensions: 0,
+        store: this.bm25.serialize(),
+        skillNames: Array.from(this.skillNames)
+      };
+    }
+    return {
+      version: 1,
+      embeddingProvider: this.embedding.name,
+      dimensions: this.embedding.dimensions,
+      store: this.store.serialize(),
+      skillNames: Array.from(this.skillNames)
+    };
+  }
+  /**
+   * Load a previously saved index.
+   * Validates that the snapshot format matches the current engine.
+   */
+  load(snapshot) {
+    if (this.usesBM25 && this.bm25) {
+      if (snapshot.embeddingProvider !== "bm25") {
+        throw new Error(
+          `Cannot load snapshot from provider "${snapshot.embeddingProvider}" into BM25 router. Create the router with a matching embedding config.`
+        );
+      }
+      this.bm25.deserialize(snapshot.store);
+    } else if (this.embedding && this.store) {
+      if (snapshot.dimensions !== this.embedding.dimensions) {
+        throw new Error(
+          `Snapshot dimensions (${snapshot.dimensions}) don't match current provider dimensions (${this.embedding.dimensions})`
+        );
+      }
+      this.store.deserialize(snapshot.store);
+    }
+    this.skillNames = new Set(snapshot.skillNames);
+  }
+  /**
+   * Create a SkillRouter from a saved snapshot.
+   */
+  static fromSnapshot(snapshot, options) {
+    const router = new _SkillRouter(options);
+    router.load(snapshot);
+    return router;
+  }
+};
+function createEmbeddingProvider(config) {
+  if (config === "local") {
+    return new LocalEmbeddingProvider();
+  }
+  if (config.provider === "custom") {
+    return {
+      name: "custom",
+      dimensions: config.dimensions,
+      embed: config.embed
+    };
+  }
+  throw new Error(
+    `Embedding provider "${config.provider}" requires additional setup. Install the appropriate SDK and configure an API key. See: https://github.com/skill-tools/skill-tools#embedding-providers`
+  );
+}
+
+export { BM25Index, LocalEmbeddingProvider, MemoryVectorStore, SkillRouter, extractContext };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map