@theglitchking/semantic-memory 1.0.0

package/dist/chunk-25EIQWXL.js

@@ -0,0 +1,651 @@
+// src/core/embedder.ts
+import { AutoTokenizer } from "@huggingface/transformers";
+import { readFile, writeFile, mkdir, rename, unlink } from "fs/promises";
+import { join, dirname } from "path";
+import { existsSync, createWriteStream } from "fs";
+import { homedir } from "os";
+import { Readable } from "stream";
+import { pipeline as streamPipeline } from "stream/promises";
+import { Worker } from "worker_threads";
+import { fileURLToPath } from "url";
+var DEFAULT_MODEL = "sentence-transformers/all-MiniLM-L6-v2";
+var CACHE_DIR = join(homedir(), ".semantic-sidekick", "models");
+var DEFAULT_WORKERS = 1;
+var DEFAULT_BATCH_SIZE = 16;
+var DEFAULT_QUANTIZED = false;
+var ONNX_MODEL_PATHS = {
+  "nomic-ai/nomic-embed-text-v1.5": "onnx/model.onnx",
+  "sentence-transformers/all-MiniLM-L6-v2": "onnx/model.onnx"
+};
+var ONNX_QUANTIZED_MODEL_PATHS = {
+  "nomic-ai/nomic-embed-text-v1.5": "onnx/model_quantized.onnx",
+  "sentence-transformers/all-MiniLM-L6-v2": "onnx/model_quantized.onnx"
+};
+async function resolveOnnxRuntime() {
+  try {
+    const ort = await import("onnxruntime-node");
+    return { ort, label: "native" };
+  } catch {
+    const ort = await import("onnxruntime-web");
+    return { ort, label: "wasm" };
+  }
+}
+async function downloadFile(url, destPath) {
+  const response = await fetch(url);
+  if (!response.ok) throw new Error(`Download failed (${response.status}): ${url}`);
+  if (!response.body) throw new Error(`No response body: ${url}`);
+  const tempPath = `${destPath}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    const fileStream = createWriteStream(tempPath);
+    await streamPipeline(Readable.fromWeb(response.body), fileStream);
+    await rename(tempPath, destPath);
+  } catch (err) {
+    try {
+      await unlink(tempPath);
+    } catch {
+    }
+    throw err;
+  }
+}
+var Embedder = class {
+  model;
+  session = null;
+  tokenizer = null;
+  ort = null;
+  dimensions = 0;
+  runtimeLabel = "wasm";
+  initialized = false;
+  numWorkers;
+  batchSize;
+  quantized;
+  modelPath = "";
+  constructor(model = DEFAULT_MODEL, numWorkers = DEFAULT_WORKERS, batchSize = DEFAULT_BATCH_SIZE, quantized = DEFAULT_QUANTIZED) {
+    this.model = model;
+    this.numWorkers = numWorkers;
+    this.batchSize = batchSize;
+    this.quantized = quantized;
+  }
+  async init() {
+    if (this.initialized) return;
+    const modelDir = join(CACHE_DIR, this.model.replace(/\//g, "--"));
+    await mkdir(modelDir, { recursive: true });
+    const { ort, label } = await resolveOnnxRuntime();
+    this.ort = ort;
+    this.runtimeLabel = label;
+    let useQuantized = this.quantized;
+    const modelFileName = useQuantized ? "model_quantized.onnx" : "model.onnx";
+    this.modelPath = join(modelDir, modelFileName);
+    const modelPath = this.modelPath;
+    if (!existsSync(modelPath)) {
+      const pathMap = useQuantized ? ONNX_QUANTIZED_MODEL_PATHS : ONNX_MODEL_PATHS;
+      const onnxSubpath = pathMap[this.model] ?? (useQuantized ? "onnx/model_quantized.onnx" : "onnx/model.onnx");
+      const url = `https://huggingface.co/${this.model}/resolve/main/${onnxSubpath}`;
+      process.stderr.write(`Downloading ONNX model: ${this.model} (${useQuantized ? "quantized" : "fp32"})...
+`);
+      try {
+        await downloadFile(url, modelPath);
+      } catch (err) {
+        if (useQuantized && err?.message?.includes("404")) {
+          process.stderr.write(`Quantized model not available, falling back to fp32
+`);
+          useQuantized = false;
+          this.modelPath = join(modelDir, "model.onnx");
+          const fp32Subpath = ONNX_MODEL_PATHS[this.model] ?? "onnx/model.onnx";
+          const fp32Url = `https://huggingface.co/${this.model}/resolve/main/${fp32Subpath}`;
+          process.stderr.write(`Downloading ONNX model: ${this.model} (fp32)...
+`);
+          await downloadFile(fp32Url, this.modelPath);
+        } else {
+          throw err;
+        }
+      }
+      process.stderr.write(`Model downloaded to ${modelDir}
+`);
+    }
+    this.tokenizer = await AutoTokenizer.from_pretrained(this.model, {
+      cache_dir: CACHE_DIR
+    });
+    this.session = await ort.InferenceSession.create(this.modelPath, {
+      executionProviders: [label === "native" ? "cpu" : "wasm"]
+    });
+    const test = await this.embed("test");
+    this.dimensions = test.length;
+    this.initialized = true;
+    const modelShort = this.model.split("/").pop() ?? this.model;
+    process.stderr.write(`Embedder ready (${modelShort}, ${label}, ${this.dimensions}d, batch=${this.batchSize})
+`);
+  }
+  async embed(text) {
+    if (!this.session || !this.tokenizer || !this.ort)
+      throw new Error("Embedder not initialized. Call init() first.");
+    const encoded = await this.tokenizer(text, {
+      padding: true,
+      truncation: true,
+      max_length: 512,
+      return_tensor: false
+    });
+    const inputIdsRaw = Array.from(encoded.input_ids.data ?? encoded.input_ids);
+    const attentionMaskRaw = Array.from(encoded.attention_mask.data ?? encoded.attention_mask);
+    const seqLen = inputIdsRaw.length;
+    const inputIds = new this.ort.Tensor(
+      "int64",
+      BigInt64Array.from(inputIdsRaw.map(BigInt)),
+      [1, seqLen]
+    );
+    const attentionMask = new this.ort.Tensor(
+      "int64",
+      BigInt64Array.from(attentionMaskRaw.map(BigInt)),
+      [1, seqLen]
+    );
+    const feeds = { input_ids: inputIds, attention_mask: attentionMask };
+    if (this.session.inputNames.includes("token_type_ids")) {
+      feeds.token_type_ids = new this.ort.Tensor(
+        "int64",
+        new BigInt64Array(seqLen),
+        [1, seqLen]
+      );
+    }
+    const output = await this.session.run(feeds);
+    const outputTensor = output[this.session.outputNames[0]];
+    const hiddenSize = outputTensor.dims[outputTensor.dims.length - 1];
+    return this.meanPoolAndNormalize(outputTensor.data, attentionMaskRaw, seqLen, hiddenSize);
+  }
+  meanPoolAndNormalize(embeddings, attentionMask, seqLen, hiddenSize) {
+    const result = new Float32Array(hiddenSize);
+    let maskSum = 0;
+    for (let t = 0; t < seqLen; t++) {
+      const mask = attentionMask[t];
+      maskSum += mask;
+      const offset = t * hiddenSize;
+      for (let d = 0; d < hiddenSize; d++) {
+        result[d] += embeddings[offset + d] * mask;
+      }
+    }
+    if (maskSum > 0) {
+      for (let d = 0; d < hiddenSize; d++) result[d] /= maskSum;
+    }
+    let norm = 0;
+    for (let d = 0; d < hiddenSize; d++) norm += result[d] * result[d];
+    norm = Math.sqrt(norm);
+    if (norm > 0) {
+      for (let d = 0; d < hiddenSize; d++) result[d] /= norm;
+    }
+    return result;
+  }
+  // Mean pool + L2 normalize the output of a batched ONNX forward pass.
+  // outputData: flat Float32Array of shape [batchSize, seqLen, hiddenSize]
+  // maskData:   flat number[] of shape [batchSize, seqLen]
+  meanPoolAndNormalizeMany(outputData, maskData, batchSize, seqLen, hiddenSize) {
+    const results = [];
+    for (let b = 0; b < batchSize; b++) {
+      const result = new Float32Array(hiddenSize);
+      let maskSum = 0;
+      for (let t = 0; t < seqLen; t++) {
+        const mask = maskData[b * seqLen + t];
+        maskSum += mask;
+        const offset = (b * seqLen + t) * hiddenSize;
+        for (let d = 0; d < hiddenSize; d++) {
+          result[d] += outputData[offset + d] * mask;
+        }
+      }
+      if (maskSum > 0) {
+        for (let d = 0; d < hiddenSize; d++) result[d] /= maskSum;
+      }
+      let norm = 0;
+      for (let d = 0; d < hiddenSize; d++) norm += result[d] * result[d];
+      norm = Math.sqrt(norm);
+      if (norm > 0) {
+        for (let d = 0; d < hiddenSize; d++) result[d] /= norm;
+      }
+      results.push(result);
+    }
+    return results;
+  }
+  // Embed a sub-batch of texts (length <= batchSize) in a single ONNX forward pass.
+  //
+  // Tokenizes each text individually (well-defined output format for all HF versions),
+  // then manually pads to the longest sequence in the batch and builds a [n, seqLen]
+  // tensor for one ONNX call. The speedup is from batching the ONNX inference —
+  // individual tokenization is negligible (<1ms each).
+  async embedSubBatch(texts) {
+    if (!this.session || !this.tokenizer || !this.ort)
+      throw new Error("Embedder not initialized. Call init() first.");
+    const n = texts.length;
+    const encodings = await Promise.all(
+      texts.map(
+        (text) => this.tokenizer(text, {
+          padding: false,
+          truncation: true,
+          max_length: 512,
+          return_tensor: false
+        })
+      )
+    );
+    const tokenized = encodings.map((enc) => ({
+      ids: Array.from(enc.input_ids.data ?? enc.input_ids),
+      mask: Array.from(enc.attention_mask.data ?? enc.attention_mask)
+    }));
+    const seqLen = Math.max(...tokenized.map((t) => t.ids.length));
+    const flatIds = new BigInt64Array(n * seqLen);
+    const flatMask = new BigInt64Array(n * seqLen);
+    const flatMaskNums = new Array(n * seqLen).fill(0);
+    for (let i = 0; i < n; i++) {
+      const { ids, mask } = tokenized[i];
+      for (let j = 0; j < ids.length; j++) {
+        flatIds[i * seqLen + j] = BigInt(ids[j]);
+        flatMask[i * seqLen + j] = BigInt(mask[j]);
+        flatMaskNums[i * seqLen + j] = mask[j];
+      }
+    }
+    const inputIds = new this.ort.Tensor("int64", flatIds, [n, seqLen]);
+    const attentionMask = new this.ort.Tensor("int64", flatMask, [n, seqLen]);
+    const feeds = { input_ids: inputIds, attention_mask: attentionMask };
+    if (this.session.inputNames.includes("token_type_ids")) {
+      feeds.token_type_ids = new this.ort.Tensor(
+        "int64",
+        new BigInt64Array(n * seqLen),
+        [n, seqLen]
+      );
+    }
+    const output = await this.session.run(feeds);
+    const outputTensor = output[this.session.outputNames[0]];
+    const hiddenSize = outputTensor.dims[outputTensor.dims.length - 1];
+    return this.meanPoolAndNormalizeMany(
+      outputTensor.data,
+      flatMaskNums,
+      n,
+      seqLen,
+      hiddenSize
+    );
+  }
+  async embedBatch(texts, onProgress) {
+    if (this.numWorkers > 1 && texts.length >= this.numWorkers * 2) {
+      return this.embedBatchParallel(texts, onProgress);
+    }
+    const results = [];
+    for (let i = 0; i < texts.length; i += this.batchSize) {
+      const subBatch = texts.slice(i, i + this.batchSize);
+      const embeddings = await this.embedSubBatch(subBatch);
+      results.push(...embeddings);
+      await onProgress?.(Math.min(i + subBatch.length, texts.length), texts.length, embeddings);
+    }
+    return results;
+  }
+  async embedBatchParallel(texts, onProgress) {
+    const thisDir = dirname(fileURLToPath(import.meta.url));
+    let workerPath = join(thisDir, "embed-worker.js");
+    if (!existsSync(workerPath)) {
+      workerPath = join(thisDir, "core", "embed-worker.js");
+    }
+    if (!existsSync(workerPath)) {
+      process.stderr.write("Worker script not found, falling back to batched embedding\n");
+      return this.embedBatch(texts, onProgress);
+    }
+    const chunkSize = Math.ceil(texts.length / this.numWorkers);
+    const chunks = [];
+    for (let i = 0; i < texts.length; i += chunkSize) {
+      chunks.push({ texts: texts.slice(i, i + chunkSize), startIndex: i });
+    }
+    const allResults = new Array(texts.length);
+    let totalDone = 0;
+    const workerPromises = chunks.map((chunk) => {
+      return new Promise((resolve, reject) => {
+        const worker = new Worker(workerPath, {
+          workerData: {
+            modelPath: this.modelPath,
+            modelName: this.model,
+            cacheDir: CACHE_DIR,
+            runtimeLabel: this.runtimeLabel,
+            batchSize: this.batchSize
+          }
+        });
+        worker.on("message", (msg) => {
+          if (msg.type === "ready") {
+            worker.postMessage({ type: "embed", texts: chunk.texts, startIndex: chunk.startIndex });
+          } else if (msg.type === "progress") {
+            totalDone++;
+            onProgress?.(totalDone, texts.length);
+          } else if (msg.type === "result") {
+            for (let i = 0; i < msg.embeddings.length; i++) {
+              allResults[chunk.startIndex + i] = new Float32Array(msg.embeddings[i]);
+            }
+            worker.terminate();
+            resolve();
+          } else if (msg.type === "error") {
+            worker.terminate();
+            reject(new Error(msg.error));
+          }
+        });
+        worker.on("error", (err) => {
+          worker.terminate();
+          reject(err);
+        });
+      });
+    });
+    await Promise.all(workerPromises);
+    return allResults;
+  }
+  getDimensions() {
+    return this.dimensions;
+  }
+  getModel() {
+    return this.model;
+  }
+  getRuntime() {
+    return this.runtimeLabel;
+  }
+  async saveEmbeddings(embeddings, indexPath) {
+    const entries = [];
+    for (const [key, vec] of embeddings) {
+      entries.push({ key, data: Array.from(vec) });
+    }
+    await writeFile(join(indexPath, "embeddings.json"), JSON.stringify(entries));
+  }
+  async loadEmbeddings(indexPath) {
+    const filePath = join(indexPath, "embeddings.json");
+    if (!existsSync(filePath)) return /* @__PURE__ */ new Map();
+    const raw = await readFile(filePath, "utf-8");
+    const entries = JSON.parse(raw);
+    const map = /* @__PURE__ */ new Map();
+    for (const entry of entries) {
+      map.set(entry.key, new Float32Array(entry.data));
+    }
+    return map;
+  }
+};
+
+// src/core/graph.ts
+import Graph from "graphology";
+import { bfsFromNode } from "graphology-traversal";
+import { bidirectional } from "graphology-shortest-path";
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { join as join2 } from "path";
+import { existsSync as existsSync2 } from "fs";
+var TAG_EDGE_MAX_DOCS = 15;
+var GraphBuilder = class {
+  graph;
+  constructor() {
+    this.graph = new Graph({ type: "directed", multi: false });
+  }
+  buildFromDocuments(documents) {
+    this.graph.clear();
+    for (const doc of documents) {
+      this.graph.addNode(doc.path, {
+        title: doc.title,
+        tags: doc.tags,
+        ...doc.status !== void 0 && { status: doc.status },
+        ...doc.loadPriority !== void 0 && { loadPriority: doc.loadPriority }
+      });
+    }
+    const pathLookup = /* @__PURE__ */ new Map();
+    for (const doc of documents) {
+      const nameNoExt = doc.path.replace(/\.md$/, "");
+      const basename = nameNoExt.split("/").pop();
+      pathLookup.set(basename.toLowerCase(), doc.path);
+      pathLookup.set(nameNoExt.toLowerCase(), doc.path);
+    }
+    for (const doc of documents) {
+      for (const link of doc.wikilinks) {
+        const target = pathLookup.get(link.toLowerCase());
+        if (target && target !== doc.path && !this.graph.hasEdge(doc.path, target)) {
+          this.graph.addEdge(doc.path, target, { type: "wikilink", weight: 1 });
+        }
+      }
+    }
+    for (const doc of documents) {
+      if (!doc.relatedDocs?.length) continue;
+      for (const ref of doc.relatedDocs) {
+        const normalized = ref.replace(/\.md$/, "").toLowerCase();
+        const base = normalized.split("/").pop();
+        const target = pathLookup.get(normalized) ?? pathLookup.get(base);
+        if (target && target !== doc.path && !this.graph.hasEdge(doc.path, target)) {
+          this.graph.addEdge(doc.path, target, { type: "related", weight: 1 });
+        }
+      }
+    }
+    const tagToNotes = /* @__PURE__ */ new Map();
+    for (const doc of documents) {
+      for (const tag of doc.tags) {
+        const notes = tagToNotes.get(tag) ?? [];
+        notes.push(doc.path);
+        tagToNotes.set(tag, notes);
+      }
+    }
+    for (const [, notes] of tagToNotes) {
+      if (notes.length >= TAG_EDGE_MAX_DOCS) continue;
+      for (let i = 0; i < notes.length; i++) {
+        for (let j = i + 1; j < notes.length; j++) {
+          if (!this.graph.hasEdge(notes[i], notes[j])) {
+            this.graph.addEdge(notes[i], notes[j], { type: "tag", weight: 0.5 });
+          }
+          if (!this.graph.hasEdge(notes[j], notes[i])) {
+            this.graph.addEdge(notes[j], notes[i], { type: "tag", weight: 0.5 });
+          }
+        }
+      }
+    }
+  }
+  backlinks(notePath) {
+    if (!this.graph.hasNode(notePath)) return [];
+    return this.graph.inNeighbors(notePath).map((n) => this.nodeToGraphNode(n));
+  }
+  forwardlinks(notePath) {
+    if (!this.graph.hasNode(notePath)) return [];
+    return this.graph.outNeighbors(notePath).map((n) => this.nodeToGraphNode(n));
+  }
+  findPath(from, to) {
+    if (!this.graph.hasNode(from) || !this.graph.hasNode(to)) return null;
+    const path = bidirectional(this.graph, from, to);
+    return path;
+  }
+  searchGraph(concept, maxDepth = 2, limit = 20) {
+    const lc = concept.toLowerCase();
+    const directMatches = new Set(
+      this.graph.nodes().filter((n) => {
+        const attrs = this.graph.getNodeAttributes(n);
+        const title = typeof attrs.title === "string" ? attrs.title : String(attrs.title ?? "");
+        return n.toLowerCase().includes(lc) || title.toLowerCase().includes(lc) || attrs.tags?.some((t) => t.toLowerCase().includes(lc));
+      })
+    );
+    const visited = /* @__PURE__ */ new Set();
+    for (const start of directMatches) {
+      bfsFromNode(this.graph, start, (_node, _attr, depth) => {
+        if (visited.size >= limit * 3) return true;
+        visited.add(_node);
+        return depth >= maxDepth;
+      });
+    }
+    const ranked = [...visited].sort((a, b) => {
+      const aAttrs = this.graph.getNodeAttributes(a);
+      const bAttrs = this.graph.getNodeAttributes(b);
+      const aDeprecated = aAttrs.status === "deprecated" || aAttrs.status === "archived" ? 1 : 0;
+      const bDeprecated = bAttrs.status === "deprecated" || bAttrs.status === "archived" ? 1 : 0;
+      if (aDeprecated !== bDeprecated) return aDeprecated - bDeprecated;
+      const aDirect = directMatches.has(a) ? 0 : 1;
+      const bDirect = directMatches.has(b) ? 0 : 1;
+      if (aDirect !== bDirect) return aDirect - bDirect;
+      const aPriority = aAttrs.loadPriority ?? 5;
+      const bPriority = bAttrs.loadPriority ?? 5;
+      if (aPriority !== bPriority) return bPriority - aPriority;
+      return this.graph.degree(b) - this.graph.degree(a);
+    });
+    return ranked.slice(0, limit).map((n) => this.nodeToGraphNode(n));
+  }
+  statistics() {
+    const nodes = this.graph.order;
+    const edges = this.graph.size;
+    const orphans = this.graph.nodes().filter(
+      (n) => this.graph.degree(n) === 0
+    );
+    const connections = this.graph.nodes().map((n) => ({
+      path: n,
+      connections: this.graph.degree(n)
+    }));
+    connections.sort((a, b) => b.connections - a.connections);
+    const maxPossibleEdges = nodes * (nodes - 1);
+    const density = maxPossibleEdges > 0 ? edges / maxPossibleEdges : 0;
+    return {
+      totalNodes: nodes,
+      totalEdges: edges,
+      orphanCount: orphans.length,
+      mostConnected: connections.slice(0, 10),
+      density
+    };
+  }
+  nodeToGraphNode(nodePath) {
+    const attrs = this.graph.getNodeAttributes(nodePath);
+    return {
+      path: nodePath,
+      title: typeof attrs.title === "string" ? attrs.title : nodePath,
+      tags: attrs.tags || [],
+      linkCount: this.graph.outDegree(nodePath),
+      backlinkCount: this.graph.inDegree(nodePath),
+      ...attrs.loadPriority !== void 0 && { loadPriority: attrs.loadPriority },
+      ...attrs.status !== void 0 && { status: attrs.status }
+    };
+  }
+  async save(indexPath) {
+    const data = this.graph.export();
+    await writeFile2(join2(indexPath, "graph.json"), JSON.stringify(data));
+  }
+  async load(indexPath) {
+    const filePath = join2(indexPath, "graph.json");
+    if (!existsSync2(filePath)) return false;
+    const raw = await readFile2(filePath, "utf-8");
+    const data = JSON.parse(raw);
+    this.graph.import(data);
+    return true;
+  }
+  getGraph() {
+    return this.graph;
+  }
+};
+
+// src/core/vector.ts
+import hnswlib from "hnswlib-node";
+import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import { join as join3 } from "path";
+import { existsSync as existsSync3 } from "fs";
+var { HierarchicalNSW } = hnswlib;
+var VectorIndex = class {
+  index = null;
+  dimensions;
+  chunkMeta = [];
+  constructor(dimensions) {
+    this.dimensions = dimensions;
+  }
+  build(embeddings, meta) {
+    if (embeddings.length === 0) {
+      this.index = null;
+      this.chunkMeta = [];
+      return;
+    }
+    this.index = new HierarchicalNSW("cosine", this.dimensions);
+    this.index.initIndex(embeddings.length);
+    for (let i = 0; i < embeddings.length; i++) {
+      this.index.addPoint(Array.from(embeddings[i]), i);
+    }
+    this.chunkMeta = meta;
+  }
+  search(queryEmbedding, k = 10) {
+    if (!this.index || this.chunkMeta.length === 0) return [];
+    const numResults = Math.min(k, this.chunkMeta.length);
+    const result = this.index.searchKnn(Array.from(queryEmbedding), numResults);
+    const seen = /* @__PURE__ */ new Set();
+    const results = [];
+    for (let i = 0; i < result.neighbors.length; i++) {
+      const idx = result.neighbors[i];
+      const meta = this.chunkMeta[idx];
+      if (!meta || seen.has(meta.docPath)) continue;
+      seen.add(meta.docPath);
+      results.push({
+        path: meta.docPath,
+        title: meta.docPath,
+        score: 1 - result.distances[i],
+        snippet: meta.text.slice(0, 200),
+        matchedChunk: meta.text
+      });
+    }
+    return results;
+  }
+  async save(indexPath) {
+    if (!this.index) return;
+    this.index.writeIndexSync(join3(indexPath, "hnsw.bin"));
+    await writeFile3(
+      join3(indexPath, "hnsw-meta.json"),
+      JSON.stringify(this.chunkMeta)
+    );
+  }
+  async load(indexPath) {
+    const hnswPath = join3(indexPath, "hnsw.bin");
+    const metaPath = join3(indexPath, "hnsw-meta.json");
+    if (!existsSync3(hnswPath) || !existsSync3(metaPath)) return false;
+    const raw = await readFile3(metaPath, "utf-8");
+    this.chunkMeta = JSON.parse(raw);
+    this.index = new HierarchicalNSW("cosine", this.dimensions);
+    this.index.initIndex(this.chunkMeta.length);
+    this.index.readIndexSync(hnswPath);
+    return true;
+  }
+  getChunkMeta() {
+    return this.chunkMeta;
+  }
+};
+
+// src/core/search-text.ts
+import { minimatch } from "minimatch";
+var TextSearch = class {
+  documents = [];
+  setDocuments(documents) {
+    this.documents = documents;
+  }
+  search(options) {
+    const { pattern, regex, caseSensitive, pathGlob, tagFilter, limit = 20 } = options;
+    let matcher;
+    if (regex) {
+      const flags = caseSensitive ? "g" : "gi";
+      const re = new RegExp(pattern, flags);
+      matcher = (text) => {
+        re.lastIndex = 0;
+        const m = re.exec(text);
+        return { matched: !!m, index: m?.index ?? -1 };
+      };
+    } else {
+      const needle = caseSensitive ? pattern : pattern.toLowerCase();
+      matcher = (text) => {
+        const haystack = caseSensitive ? text : text.toLowerCase();
+        const idx = haystack.indexOf(needle);
+        return { matched: idx >= 0, index: idx };
+      };
+    }
+    const results = [];
+    for (const doc of this.documents) {
+      if (pathGlob && !minimatch(doc.path, pathGlob)) continue;
+      if (tagFilter?.length) {
+        const hasTag = tagFilter.some((t) => doc.tags.includes(t));
+        if (!hasTag) continue;
+      }
+      const { matched, index } = matcher(doc.content);
+      if (!matched) continue;
+      const snippetStart = Math.max(0, index - 80);
+      const snippetEnd = Math.min(doc.content.length, index + 120);
+      const snippet = doc.content.slice(snippetStart, snippetEnd).trim();
+      results.push({
+        path: doc.path,
+        title: doc.title,
+        score: 1,
+        snippet: (snippetStart > 0 ? "..." : "") + snippet + (snippetEnd < doc.content.length ? "..." : "")
+      });
+      if (results.length >= limit) break;
+    }
+    return results;
+  }
+};
+
+export {
+  Embedder,
+  GraphBuilder,
+  VectorIndex,
+  TextSearch
+};
+//# sourceMappingURL=chunk-25EIQWXL.js.map