@neuralsea/workspace-indexer 0.1.0

package/dist/chunk-QPQCSCBN.js

@@ -0,0 +1,2374 @@
+// src/vector/factory.ts
+import path4 from "path";
+import { pathToFileURL } from "url";
+
+// src/util.ts
+import crypto from "crypto";
+import os from "os";
+import path from "path";
+function sha256Hex(data) {
+  return crypto.createHash("sha256").update(data).digest("hex");
+}
+function defaultCacheDir() {
+  const home = os.homedir();
+  return path.join(home, ".cache", "petri");
+}
+function fromPosixPath(p) {
+  return p.split("/").join(path.sep);
+}
+function estimateTokens(text) {
+  return Math.max(1, Math.ceil(text.length / 4));
+}
+function normalise(vec) {
+  let sumSq = 0;
+  for (let i = 0; i < vec.length; i++) sumSq += vec[i] * vec[i];
+  const norm = Math.sqrt(sumSq) || 1;
+  const out = new Float32Array(vec.length);
+  for (let i = 0; i < vec.length; i++) out[i] = vec[i] / norm;
+  return out;
+}
+function dot(a, b) {
+  const n = Math.min(a.length, b.length);
+  let s = 0;
+  for (let i = 0; i < n; i++) s += a[i] * b[i];
+  return s;
+}
+function clamp(x, lo, hi) {
+  return Math.min(hi, Math.max(lo, x));
+}
+function makePreview(text, maxLen = 240) {
+  const oneLine = text.replace(/\s+/g, " ").trim();
+  return oneLine.length <= maxLen ? oneLine : oneLine.slice(0, maxLen - 1) + "\u2026";
+}
+function nowMs() {
+  return Date.now();
+}
+function recencyScore(fileMtimeMs, halfLifeDays = 14) {
+  const ageMs = Math.max(0, nowMs() - fileMtimeMs);
+  const halfLifeMs = halfLifeDays * 24 * 60 * 60 * 1e3;
+  const score = Math.pow(0.5, ageMs / Math.max(1, halfLifeMs));
+  return clamp(score, 0, 1);
+}
+
+// src/vector/bruteforce.ts
+var BruteForceVectorIndex = class {
+  kind = "bruteforce";
+  metric = "cosine";
+  dimension = 0;
+  ids = [];
+  vecs = [];
+  pos = /* @__PURE__ */ new Map();
+  async init(init) {
+    this.metric = init.metric;
+    this.dimension = init.dimension;
+  }
+  async upsert(points) {
+    for (const p of points) this.upsertOne(p.id, p.vector);
+  }
+  upsertOne(id, vec) {
+    const v = normalise(vec);
+    const existing = this.pos.get(id);
+    if (existing !== void 0) {
+      this.vecs[existing] = v;
+      return;
+    }
+    this.pos.set(id, this.ids.length);
+    this.ids.push(id);
+    this.vecs.push(v);
+  }
+  async remove(ids) {
+    for (const id of ids) this.removeOne(id);
+  }
+  removeOne(id) {
+    const i = this.pos.get(id);
+    if (i === void 0) return;
+    const last = this.ids.length - 1;
+    if (i !== last) {
+      const lastId = this.ids[last];
+      this.ids[i] = lastId;
+      this.vecs[i] = this.vecs[last];
+      this.pos.set(lastId, i);
+    }
+    this.ids.pop();
+    this.vecs.pop();
+    this.pos.delete(id);
+  }
+  async rebuild(points) {
+    this.ids = [];
+    this.vecs = [];
+    this.pos = /* @__PURE__ */ new Map();
+    for (const p of points) this.upsertOne(p.id, p.vector);
+  }
+  async search(query, k) {
+    const q = normalise(query);
+    const top = [];
+    for (let i = 0; i < this.ids.length; i++) {
+      const s = dot(q, this.vecs[i]);
+      if (top.length < k) {
+        top.push({ id: this.ids[i], score: s });
+        top.sort((a, b) => b.score - a.score);
+      } else if (s > top[top.length - 1].score) {
+        top[top.length - 1] = { id: this.ids[i], score: s };
+        top.sort((a, b) => b.score - a.score);
+      }
+    }
+    return top;
+  }
+  async count() {
+    return this.ids.length;
+  }
+  async flush() {
+  }
+  async close() {
+  }
+};
+
+// src/vector/faiss.ts
+import fs from "fs";
+import path2 from "path";
+async function importFaiss() {
+  const modName = "faiss-node";
+  try {
+    const mod = await import(modName);
+    const ns = mod?.Index ? mod : mod?.default;
+    if (!ns?.Index) throw new Error("faiss-node did not export Index");
+    return ns;
+  } catch (e) {
+    const hint = "To use the 'faiss' provider, install the optional dependency: npm i faiss-node";
+    throw new Error(`${String(e?.message ?? e)}
+${hint}`);
+  }
+}
+function safeReadJson(p) {
+  try {
+    return JSON.parse(fs.readFileSync(p, "utf8"));
+  } catch {
+    return null;
+  }
+}
+var FaissVectorIndex = class {
+  kind = "faiss";
+  metric = "cosine";
+  dimension = 0;
+  cfg;
+  index = null;
+  labelToId = [];
+  points = /* @__PURE__ */ new Map();
+  dirty = false;
+  readyForIncremental = false;
+  indexPath = "";
+  mapPath = "";
+  constructor(cfg = {}) {
+    this.cfg = {
+      descriptor: cfg.descriptor ?? "HNSW,Flat",
+      persist: cfg.persist ?? true,
+      persistDebounceMs: cfg.persistDebounceMs ?? 2e3,
+      rebuildStrategy: cfg.rebuildStrategy ?? "lazy"
+    };
+  }
+  async init(init) {
+    this.metric = init.metric;
+    this.dimension = init.dimension;
+    const baseDir = path2.join(init.cacheDir, "vector", init.repoId);
+    fs.mkdirSync(baseDir, { recursive: true });
+    this.indexPath = path2.join(baseDir, `${init.commit}.faiss.idx`);
+    this.mapPath = path2.join(baseDir, `${init.commit}.faiss.map.json`);
+    if (this.cfg.persist && fs.existsSync(this.indexPath) && fs.existsSync(this.mapPath)) {
+      const map = safeReadJson(this.mapPath);
+      if (map && map.version === 1 && map.dimension === this.dimension && map.metric === this.metric) {
+        const { Index } = await importFaiss();
+        this.index = Index.read(this.indexPath);
+        this.labelToId = map.labelToId;
+      }
+    }
+  }
+  async rebuild(points) {
+    this.points = new Map(points.map((p) => [p.id, p.vector]));
+    this.readyForIncremental = true;
+    await this.rebuildFromPoints();
+  }
+  async rebuildFromPoints() {
+    const { Index, MetricType } = await importFaiss();
+    const metric = this.metric === "l2" ? MetricType.METRIC_L2 : MetricType.METRIC_INNER_PRODUCT;
+    const idx = Index.fromFactory(this.dimension, this.cfg.descriptor, metric);
+    const ids = [];
+    const flat = [];
+    for (const [id, v] of this.points.entries()) {
+      ids.push(id);
+      const vec = this.metric === "cosine" ? normalise(v) : v;
+      for (let i = 0; i < vec.length; i++) flat.push(vec[i]);
+    }
+    if (flat.length > 0) {
+      if (typeof idx.isTrained === "function" && !idx.isTrained()) {
+        idx.train(flat);
+      }
+      idx.add(flat);
+    }
+    this.index = idx;
+    this.labelToId = ids;
+    this.dirty = false;
+    if (this.cfg.persist) {
+      const map = {
+        version: 1,
+        dimension: this.dimension,
+        metric: this.metric,
+        labelToId: ids
+      };
+      fs.writeFileSync(this.mapPath, JSON.stringify(map));
+      idx.write(this.indexPath);
+    }
+  }
+  async upsert(points) {
+    if (!this.readyForIncremental) {
+      throw new Error("FAISS provider requires an initial rebuild() before incremental writes.");
+    }
+    for (const p of points) this.points.set(p.id, p.vector);
+    this.dirty = true;
+    if (this.cfg.rebuildStrategy === "eager") await this.rebuildFromPoints();
+  }
+  async remove(ids) {
+    if (!this.readyForIncremental) {
+      throw new Error("FAISS provider requires an initial rebuild() before incremental writes.");
+    }
+    for (const id of ids) this.points.delete(id);
+    this.dirty = true;
+    if (this.cfg.rebuildStrategy === "eager") await this.rebuildFromPoints();
+  }
+  async search(query, k) {
+    if (this.dirty && this.cfg.rebuildStrategy === "lazy") {
+      await this.rebuildFromPoints();
+    }
+    if (!this.index) return [];
+    const q = this.metric === "cosine" ? Array.from(normalise(query)) : Array.from(query);
+    const res = this.index.search(q, k);
+    const out = [];
+    for (let i = 0; i < res.labels.length; i++) {
+      const label = res.labels[i];
+      if (label < 0) continue;
+      const id = this.labelToId[label];
+      if (!id) continue;
+      const d = res.distances[i];
+      const score = this.metric === "l2" ? -d : d;
+      out.push({ id, score });
+    }
+    out.sort((a, b) => b.score - a.score);
+    return out;
+  }
+  async count() {
+    if (this.index && typeof this.index.ntotal === "function") return this.index.ntotal();
+    return this.labelToId.length;
+  }
+  async flush() {
+  }
+  async close() {
+    if (this.dirty && this.cfg.rebuildStrategy === "lazy") {
+      try {
+        await this.rebuildFromPoints();
+      } catch {
+      }
+    }
+    this.index = null;
+  }
+};
+
+// src/vector/hnswlib.ts
+import fs2 from "fs";
+import path3 from "path";
+async function importHnswlib() {
+  const modName = "hnswlib-node";
+  try {
+    const mod = await import(modName);
+    const ns = mod?.HierarchicalNSW ? mod : mod?.default;
+    if (!ns?.HierarchicalNSW) {
+      throw new Error("hnswlib-node did not export HierarchicalNSW");
+    }
+    return ns;
+  } catch (e) {
+    const hint = "To use the 'hnswlib' provider, install the optional dependency: npm i hnswlib-node";
+    throw new Error(`${String(e?.message ?? e)}
+${hint}`);
+  }
+}
+function safeReadJson2(p) {
+  try {
+    return JSON.parse(fs2.readFileSync(p, "utf8"));
+  } catch {
+    return null;
+  }
+}
+var HnswlibVectorIndex = class {
+  kind = "hnswlib";
+  metric = "cosine";
+  dimension = 0;
+  cfg;
+  index = null;
+  idToLabel = /* @__PURE__ */ new Map();
+  labelToId = /* @__PURE__ */ new Map();
+  nextLabel = 0;
+  indexPath = "";
+  mapPath = "";
+  dirty = false;
+  constructor(cfg = {}) {
+    this.cfg = {
+      maxElements: cfg.maxElements ?? 5e4,
+      m: cfg.m ?? 16,
+      efConstruction: cfg.efConstruction ?? 200,
+      efSearch: cfg.efSearch ?? 64,
+      persist: cfg.persist ?? true,
+      persistDebounceMs: cfg.persistDebounceMs ?? 2e3
+    };
+  }
+  async init(init) {
+    this.metric = init.metric;
+    this.dimension = init.dimension;
+    const baseDir = path3.join(init.cacheDir, "vector", init.repoId);
+    fs2.mkdirSync(baseDir, { recursive: true });
+    this.indexPath = path3.join(baseDir, `${init.commit}.hnsw.dat`);
+    this.mapPath = path3.join(baseDir, `${init.commit}.hnsw.map.json`);
+    if (this.cfg.persist && fs2.existsSync(this.indexPath) && fs2.existsSync(this.mapPath)) {
+      const map = safeReadJson2(this.mapPath);
+      if (map && map.version === 1 && map.dimension === this.dimension && map.metric === this.metric) {
+        const { HierarchicalNSW } = await importHnswlib();
+        const space = this.toHnswSpace(this.metric);
+        const idx = new HierarchicalNSW(space, this.dimension);
+        idx.readIndexSync(this.indexPath, true);
+        if (typeof idx.setEf === "function") idx.setEf(this.cfg.efSearch);
+        this.index = idx;
+        this.idToLabel = new Map(Object.entries(map.idToLabel).map(([id, label]) => [id, label]));
+        this.labelToId = new Map(Array.from(this.idToLabel.entries()).map(([id, label]) => [label, id]));
+        this.nextLabel = Math.max(-1, ...Array.from(this.labelToId.keys())) + 1;
+        return;
+      }
+    }
+    await this.resetEmpty();
+  }
+  async resetEmpty() {
+    const { HierarchicalNSW } = await importHnswlib();
+    const idx = new HierarchicalNSW(this.toHnswSpace(this.metric), this.dimension);
+    idx.initIndex({
+      maxElements: this.cfg.maxElements,
+      m: this.cfg.m,
+      efConstruction: this.cfg.efConstruction,
+      allowReplaceDeleted: true
+    });
+    if (typeof idx.setEf === "function") idx.setEf(this.cfg.efSearch);
+    this.index = idx;
+    this.idToLabel = /* @__PURE__ */ new Map();
+    this.labelToId = /* @__PURE__ */ new Map();
+    this.nextLabel = 0;
+    this.dirty = false;
+  }
+  async rebuild(points) {
+    const desired = Math.max(this.cfg.maxElements, Math.ceil(points.length * 1.1) + 1024);
+    const { HierarchicalNSW } = await importHnswlib();
+    const idx = new HierarchicalNSW(this.toHnswSpace(this.metric), this.dimension);
+    idx.initIndex({
+      maxElements: desired,
+      m: this.cfg.m,
+      efConstruction: this.cfg.efConstruction,
+      allowReplaceDeleted: true
+    });
+    if (typeof idx.setEf === "function") idx.setEf(this.cfg.efSearch);
+    this.index = idx;
+    this.idToLabel = /* @__PURE__ */ new Map();
+    this.labelToId = /* @__PURE__ */ new Map();
+    this.nextLabel = 0;
+    for (const p of points) {
+      const label = this.nextLabel++;
+      this.idToLabel.set(p.id, label);
+      this.labelToId.set(label, p.id);
+      idx.addPoint(Array.from(normalise(p.vector)), label, true);
+    }
+    this.markDirty();
+    await this.flush();
+  }
+  async upsert(points) {
+    if (!this.index) throw new Error("HNSW index not initialised");
+    for (const p of points) {
+      let label = this.idToLabel.get(p.id);
+      if (label === void 0) {
+        label = this.nextLabel++;
+        this.idToLabel.set(p.id, label);
+        this.labelToId.set(label, p.id);
+      } else {
+        if (typeof this.index.unmarkDelete === "function") {
+          try {
+            this.index.unmarkDelete(label);
+          } catch {
+          }
+        }
+      }
+      if (typeof this.index.getMaxElements === "function" && typeof this.index.getCurrentCount === "function") {
+        const max = this.index.getMaxElements();
+        const cur = this.index.getCurrentCount();
+        if (cur + 1 > max && typeof this.index.resizeIndex === "function") {
+          this.index.resizeIndex(Math.ceil((cur + 1) * 1.2) + 1024);
+        }
+      }
+      this.index.addPoint(Array.from(normalise(p.vector)), label, true);
+    }
+    this.markDirty();
+  }
+  async remove(ids) {
+    if (!this.index) throw new Error("HNSW index not initialised");
+    for (const id of ids) {
+      const label = this.idToLabel.get(id);
+      if (label === void 0) continue;
+      if (typeof this.index.markDelete === "function") {
+        try {
+          this.index.markDelete(label);
+        } catch {
+        }
+      }
+    }
+    this.markDirty();
+  }
+  async search(query, k) {
+    if (!this.index) throw new Error("HNSW index not initialised");
+    const q = Array.from(normalise(query));
+    const res = this.index.searchKnn(q, k);
+    const out = [];
+    for (let i = 0; i < res.neighbors.length; i++) {
+      const label = res.neighbors[i];
+      if (label < 0) continue;
+      const id = this.labelToId.get(label);
+      if (!id) continue;
+      const d = res.distances[i];
+      const score = this.metric === "cosine" ? 1 - d : -d;
+      out.push({ id, score });
+    }
+    out.sort((a, b) => b.score - a.score);
+    return out;
+  }
+  async count() {
+    if (!this.index) return 0;
+    if (typeof this.index.getCurrentCount === "function") return this.index.getCurrentCount();
+    return this.idToLabel.size;
+  }
+  markDirty() {
+    if (!this.cfg.persist) return;
+    this.dirty = true;
+  }
+  async flush() {
+    if (!this.cfg.persist) return;
+    if (!this.dirty) return;
+    if (!this.index) return;
+    this.dirty = false;
+    const map = {
+      version: 1,
+      dimension: this.dimension,
+      metric: this.metric,
+      idToLabel: Object.fromEntries(this.idToLabel.entries())
+    };
+    fs2.writeFileSync(this.mapPath, JSON.stringify(map));
+    this.index.writeIndexSync(this.indexPath);
+  }
+  async close() {
+    await this.flush();
+    this.index = null;
+  }
+  toHnswSpace(metric) {
+    if (metric === "l2") return "l2";
+    if (metric === "ip") return "ip";
+    return "cosine";
+  }
+};
+
+// src/vector/qdrant.ts
+import crypto2 from "crypto";
+async function importQdrant() {
+  const modName = "@qdrant/js-client-rest";
+  try {
+    const mod = await import(modName);
+    const ns = mod?.QdrantClient ? mod : mod?.default;
+    if (!ns?.QdrantClient) throw new Error("@qdrant/js-client-rest did not export QdrantClient");
+    return ns;
+  } catch (e) {
+    const hint = "To use the 'qdrant' provider, install the optional dependency: npm i @qdrant/js-client-rest";
+    throw new Error(`${String(e?.message ?? e)}
+${hint}`);
+  }
+}
+var PETRI_UUID_NAMESPACE = "b0f67f3b-2c75-44b8-9b4d-8f71a8a2f3f2";
+function uuidToBytes(uuid) {
+  const hex = uuid.replace(/-/g, "");
+  if (hex.length !== 32) throw new Error(`Invalid UUID: ${uuid}`);
+  const out = new Uint8Array(16);
+  for (let i = 0; i < 16; i++) out[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+  return out;
+}
+function bytesToUuid(b) {
+  const hex = Array.from(b).map((x) => x.toString(16).padStart(2, "0")).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+function uuidv5(name, namespace) {
+  const ns = uuidToBytes(namespace);
+  const nameBytes = Buffer.from(name, "utf8");
+  const hash = crypto2.createHash("sha1").update(ns).update(nameBytes).digest();
+  const out = new Uint8Array(hash.subarray(0, 16));
+  out[6] = out[6] & 15 | 80;
+  out[8] = out[8] & 63 | 128;
+  return bytesToUuid(out);
+}
+function sanitizeCollection(s) {
+  return s.toLowerCase().replace(/[^a-z0-9_\-]/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "").slice(0, 60);
+}
+var QdrantVectorIndex = class {
+  kind = "qdrant";
+  metric = "cosine";
+  dimension = 0;
+  cfg;
+  client = null;
+  collection = "";
+  commit = "";
+  collectionMode = "commit";
+  constructor(cfg = {}) {
+    this.cfg = {
+      url: cfg.url ?? "",
+      host: cfg.host ?? "localhost",
+      port: cfg.port ?? 6333,
+      apiKey: cfg.apiKey ?? "",
+      collectionPrefix: cfg.collectionPrefix ?? "petri",
+      collectionMode: cfg.collectionMode ?? "commit",
+      recreateOnRebuild: cfg.recreateOnRebuild ?? true
+    };
+  }
+  async init(init) {
+    this.metric = init.metric;
+    this.dimension = init.dimension;
+    this.commit = init.commit;
+    this.collectionMode = this.cfg.collectionMode;
+    const { QdrantClient } = await importQdrant();
+    const args = this.cfg.url ? { url: this.cfg.url, apiKey: this.cfg.apiKey || void 0 } : { host: this.cfg.host, port: this.cfg.port, apiKey: this.cfg.apiKey || void 0 };
+    this.client = new QdrantClient(args);
+    const repoPart = sanitizeCollection(init.repoId);
+    const metricPart = this.metric === "cosine" ? "cos" : this.metric;
+    const dimPart = String(this.dimension);
+    const commitPart = init.commit.slice(0, 8);
+    const prefix = sanitizeCollection(this.cfg.collectionPrefix);
+    this.collection = this.collectionMode === "commit" ? sanitizeCollection(`${prefix}_${repoPart}_${commitPart}_${dimPart}_${metricPart}`) : sanitizeCollection(`${prefix}_${repoPart}_${dimPart}_${metricPart}`);
+    await this.ensureCollection();
+  }
+  pointId(chunkId) {
+    const name = this.collectionMode === "commit" ? chunkId : `${this.commit}:${chunkId}`;
+    return uuidv5(name, PETRI_UUID_NAMESPACE);
+  }
+  commitFilter() {
+    return {
+      must: [{ key: "commit", match: { value: this.commit } }]
+    };
+  }
+  distanceName(metric) {
+    if (metric === "l2") return "Euclid";
+    if (metric === "ip") return "Dot";
+    return "Cosine";
+  }
+  async ensureCollection() {
+    if (!this.client) throw new Error("Qdrant client not initialised");
+    const existing = await this.client.getCollections();
+    const names = (existing?.collections ?? existing?.result?.collections ?? []).map((c) => c.name);
+    if (names.includes(this.collection)) return;
+    await this.client.createCollection(this.collection, {
+      vectors: { size: this.dimension, distance: this.distanceName(this.metric) }
+    });
+  }
+  async rebuild(points) {
+    if (!this.client) throw new Error("Qdrant client not initialised");
+    if (this.collectionMode === "commit") {
+      if (this.cfg.recreateOnRebuild) {
+        try {
+          await this.client.deleteCollection(this.collection);
+        } catch {
+        }
+      } else {
+        try {
+          await this.client.delete(this.collection, { filter: {} });
+        } catch {
+        }
+      }
+      await this.ensureCollection();
+    } else {
+      try {
+        await this.client.delete(this.collection, { filter: this.commitFilter() });
+      } catch {
+      }
+    }
+    const batchSize = 256;
+    for (let i = 0; i < points.length; i += batchSize) {
+      const batch = points.slice(i, i + batchSize);
+      await this.upsert(batch);
+    }
+  }
+  async upsert(points) {
+    if (!this.client) throw new Error("Qdrant client not initialised");
+    if (points.length === 0) return;
+    const qPoints = points.map((p) => {
+      const payload = { ...p.payload ?? {}, cid: p.id };
+      if (this.collectionMode === "repo") payload.commit = this.commit;
+      return {
+        id: this.pointId(p.id),
+        vector: Array.from(normalise(p.vector)),
+        payload
+      };
+    });
+    await this.client.upsert(this.collection, { points: qPoints });
+  }
+  async remove(ids) {
+    if (!this.client) throw new Error("Qdrant client not initialised");
+    if (ids.length === 0) return;
+    const pointIds = ids.map((id) => this.pointId(id));
+    await this.client.delete(this.collection, { points: pointIds });
+  }
+  async search(query, k) {
+    if (!this.client) throw new Error("Qdrant client not initialised");
+    const q = Array.from(normalise(query));
+    const req = {
+      query: q,
+      limit: k,
+      with_payload: true
+    };
+    if (this.collectionMode === "repo") req.filter = this.commitFilter();
+    let res;
+    if (typeof this.client.query === "function") {
+      res = await this.client.query(this.collection, req);
+    } else if (typeof this.client.search === "function") {
+      res = await this.client.search(this.collection, { vector: q, limit: k, with_payload: true, filter: req.filter });
+    } else {
+      throw new Error("Qdrant client missing query/search method");
+    }
+    const hits = res?.points ?? res?.result ?? res ?? [];
+    const out = [];
+    for (const h of hits) {
+      const payload = h.payload ?? h?.payloads;
+      const cid = payload?.cid;
+      if (!cid) continue;
+      const score = typeof h.score === "number" ? h.score : typeof h?.result?.score === "number" ? h.result.score : 0;
+      out.push({ id: String(cid), score });
+    }
+    out.sort((a, b) => b.score - a.score);
+    return out;
+  }
+  async count() {
+    if (!this.client) return 0;
+    try {
+      if (this.collectionMode === "repo" && typeof this.client.count === "function") {
+        const res = await this.client.count(this.collection, { filter: this.commitFilter(), exact: false });
+        return Number(res?.count ?? res?.result?.count ?? 0);
+      }
+      const info = await this.client.getCollection(this.collection);
+      const c = info?.points_count ?? info?.result?.points_count;
+      if (typeof c === "number") return c;
+    } catch {
+    }
+    return 0;
+  }
+  async flush() {
+  }
+  async close() {
+    this.client = null;
+  }
+};
+
+// src/vector/factory.ts
+function isVectorIndex(obj) {
+  return obj && typeof obj.init === "function" && typeof obj.rebuild === "function" && typeof obj.upsert === "function" && typeof obj.remove === "function" && typeof obj.search === "function" && typeof obj.count === "function" && typeof obj.flush === "function" && typeof obj.close === "function";
+}
+async function createVectorIndex(vector) {
+  const provider = vector?.provider ?? "bruteforce";
+  if (provider === "bruteforce") return new BruteForceVectorIndex();
+  if (provider === "hnswlib") return new HnswlibVectorIndex(vector?.hnswlib);
+  if (provider === "qdrant") return new QdrantVectorIndex(vector?.qdrant);
+  if (provider === "faiss") return new FaissVectorIndex(vector?.faiss);
+  if (provider === "custom") {
+    const c = vector?.custom;
+    if (!c?.module) {
+      throw new Error("vector.provider=custom requires vector.custom.module");
+    }
+    const abs = path4.isAbsolute(c.module) ? c.module : path4.resolve(process.cwd(), c.module);
+    const url = pathToFileURL(abs).href;
+    const mod = await import(url);
+    const expName = c.export ?? "default";
+    const exp = mod[expName] ?? mod.default ?? mod;
+    const instance = typeof exp === "function" ? (
+      // If it's a class, `new` works; if it's a factory function, it should return a VectorIndex.
+      (() => {
+        try {
+          return new exp(c.options);
+        } catch {
+          return exp(c.options);
+        }
+      })()
+    ) : exp;
+    if (!isVectorIndex(instance)) {
+      throw new Error(
+        `Custom vector provider '${abs}' export '${expName}' did not produce a VectorIndex implementation.`
+      );
+    }
+    return instance;
+  }
+  if (provider === "auto") {
+    if (vector?.qdrant?.url || vector?.qdrant?.host) {
+      try {
+        const q = "@qdrant/js-client-rest";
+        await import(q);
+        return new QdrantVectorIndex(vector.qdrant);
+      } catch {
+      }
+    }
+    try {
+      const modName = "hnswlib-node";
+      await import(modName);
+      return new HnswlibVectorIndex(vector?.hnswlib);
+    } catch {
+      return new BruteForceVectorIndex();
+    }
+  }
+  return new BruteForceVectorIndex();
+}
+
+// src/indexer/repoIndexer.ts
+import fs6 from "fs";
+import path8 from "path";
+import chokidar from "chokidar";
+import pLimit from "p-limit";
+
+// src/git.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+async function git(repoRoot, args) {
+  const { stdout } = await execFileAsync("git", args, { cwd: repoRoot, encoding: "utf8" });
+  return stdout;
+}
+async function getHeadCommit(repoRoot) {
+  return (await git(repoRoot, ["rev-parse", "HEAD"])).trim();
+}
+async function getBranchName(repoRoot) {
+  return (await git(repoRoot, ["rev-parse", "--abbrev-ref", "HEAD"])).trim();
+}
+async function listWorkingFiles(repoRoot) {
+  const out = await git(repoRoot, ["ls-files", "-z", "--cached", "--others", "--exclude-standard"]);
+  const parts = out.split("\0").map((s) => s.trim()).filter(Boolean);
+  const seen = /* @__PURE__ */ new Set();
+  const files = [];
+  for (const p of parts) {
+    if (!seen.has(p)) {
+      seen.add(p);
+      files.push(p);
+    }
+  }
+  return files;
+}
+async function listChangedFiles(repoRoot, baseRef = "HEAD~1") {
+  const out = await git(repoRoot, ["diff", "--name-only", "-z", `${baseRef}...HEAD`]);
+  return out.split("\0").map((s) => s.trim()).filter(Boolean);
+}
+
+// src/ignore.ts
+import fs3 from "fs";
+import path5 from "path";
+import ignore from "ignore";
+function loadExtraIgnore(repoRoot, ignoreFiles) {
+  const ig = ignore();
+  for (const name of ignoreFiles) {
+    const p = path5.join(repoRoot, name);
+    if (!fs3.existsSync(p)) continue;
+    const raw = fs3.readFileSync(p, "utf8");
+    ig.add(raw.split(/\r?\n/));
+  }
+  return (posixRelPath) => ig.ignores(posixRelPath);
+}
+
+// src/optionalTypescript.ts
+import { createRequire } from "module";
+var cached = null;
+var didTryLoad = false;
+function getTypeScript() {
+  if (didTryLoad) return cached;
+  try {
+    const require2 = createRequire(import.meta.url);
+    cached = require2("typescript");
+    didTryLoad = true;
+    return cached;
+  } catch {
+    cached = null;
+    didTryLoad = true;
+    return null;
+  }
+}
+
+// src/chunker.ts
+function languageFromPath(posixPath) {
+  const ext = posixPath.toLowerCase().split(".").pop() ?? "";
+  if (["ts", "tsx"].includes(ext)) return "typescript";
+  if (["js", "jsx", "mjs", "cjs"].includes(ext)) return "javascript";
+  if (["py"].includes(ext)) return "python";
+  if (["go"].includes(ext)) return "go";
+  if (["rs"].includes(ext)) return "rust";
+  if (["java"].includes(ext)) return "java";
+  if (["kt", "kts"].includes(ext)) return "kotlin";
+  if (["cs"].includes(ext)) return "csharp";
+  if (["md"].includes(ext)) return "markdown";
+  if (["json", "yaml", "yml", "toml"].includes(ext)) return "config";
+  return "text";
+}
+function chunkByLines(sourceText, cfg) {
+  const lines = sourceText.split(/\r?\n/);
+  const out = [];
+  const step = Math.max(1, cfg.maxLines - cfg.overlapLines);
+  for (let start = 0; start < lines.length; start += step) {
+    const end = Math.min(lines.length, start + cfg.maxLines);
+    const text = lines.slice(start, end).join("\n");
+    if (!text.trim()) continue;
+    out.push({
+      startLine: start + 1,
+      endLine: end,
+      text,
+      contentHash: sha256Hex(text),
+      tokens: estimateTokens(text)
+    });
+  }
+  return out;
+}
+function splitIfTooLarge(ch, cfg) {
+  if (ch.text.length <= cfg.maxChars) return [ch];
+  return chunkByLines(ch.text, cfg).map((sub) => ({
+    ...sub,
+    startLine: ch.startLine + (sub.startLine - 1),
+    endLine: ch.startLine + (sub.endLine - 1)
+  }));
+}
+function isTopLevelChunkable(tsMod, stmt) {
+  return tsMod.isFunctionDeclaration(stmt) || tsMod.isClassDeclaration(stmt) || tsMod.isInterfaceDeclaration(stmt) || tsMod.isTypeAliasDeclaration(stmt) || tsMod.isEnumDeclaration(stmt) || tsMod.isModuleDeclaration(stmt) || tsMod.isVariableStatement(stmt) || tsMod.isExportAssignment(stmt) || tsMod.isExportDeclaration(stmt);
+}
+function chunkTypeScriptLike(sourceText, virtualFileName, cfg) {
+  const tsMod = getTypeScript();
+  if (!tsMod) return chunkByLines(sourceText, cfg);
+  const sf = tsMod.createSourceFile(
+    virtualFileName,
+    sourceText,
+    tsMod.ScriptTarget.Latest,
+    true
+  );
+  const chunks = [];
+  for (const stmt of sf.statements) {
+    if (!isTopLevelChunkable(tsMod, stmt)) continue;
+    const startPos = stmt.getFullStart();
+    const endPos = stmt.end;
+    const startLC = tsMod.getLineAndCharacterOfPosition(sf, startPos);
+    const endLC = tsMod.getLineAndCharacterOfPosition(sf, endPos);
+    const text = sourceText.slice(startPos, endPos).trimEnd();
+    if (!text.trim()) continue;
+    const base = {
+      startLine: startLC.line + 1,
+      endLine: endLC.line + 1,
+      text,
+      contentHash: sha256Hex(text),
+      tokens: estimateTokens(text)
+    };
+    chunks.push(...splitIfTooLarge(base, cfg));
+  }
+  if (chunks.length === 0) return chunkByLines(sourceText, cfg);
+  return chunks;
+}
+function chunkSource(posixPath, sourceText, cfg) {
+  const language = languageFromPath(posixPath);
+  if (language === "typescript" || language === "javascript") {
+    return { language, chunks: chunkTypeScriptLike(sourceText, posixPath, cfg) };
+  }
+  return { language, chunks: chunkByLines(sourceText, cfg) };
+}
+
+// src/relations.ts
+function extractTsRelations(virtualFileName, sourceText) {
+  const tsMod = getTypeScript();
+  if (!tsMod) return { imports: [], exports: [] };
+  const sf = tsMod.createSourceFile(virtualFileName, sourceText, tsMod.ScriptTarget.Latest, true);
+  const imports = [];
+  const exports = [];
+  const isExported2 = (node) => {
+    if (!tsMod.canHaveModifiers(node)) return false;
+    const mods = tsMod.getModifiers(node);
+    return !!mods?.some((m) => m.kind === tsMod.SyntaxKind.ExportKeyword);
+  };
+  for (const stmt of sf.statements) {
+    if (tsMod.isImportDeclaration(stmt) && tsMod.isStringLiteral(stmt.moduleSpecifier)) {
+      imports.push(stmt.moduleSpecifier.text);
+    }
+    if (tsMod.isExportDeclaration(stmt)) {
+      if (stmt.exportClause && tsMod.isNamedExports(stmt.exportClause)) {
+        for (const el of stmt.exportClause.elements) exports.push(el.name.text);
+      } else {
+        exports.push("*");
+      }
+    }
+    if (tsMod.isFunctionDeclaration(stmt) && isExported2(stmt) && stmt.name) {
+      exports.push(stmt.name.text);
+    }
+    if (tsMod.isClassDeclaration(stmt) && isExported2(stmt) && stmt.name) {
+      exports.push(stmt.name.text);
+    }
+    if (tsMod.isVariableStatement(stmt) && isExported2(stmt)) {
+      for (const decl of stmt.declarationList.declarations) {
+        if (tsMod.isIdentifier(decl.name)) exports.push(decl.name.text);
+      }
+    }
+  }
+  return { imports, exports };
+}
+
+// src/synopsis.ts
+function isExported(tsMod, node) {
+  if (!tsMod.canHaveModifiers(node)) return false;
+  const mods = tsMod.getModifiers(node);
+  return !!mods?.some((m) => m.kind === tsMod.SyntaxKind.ExportKeyword);
+}
+function leadingCommentExcerpt(sourceText, maxChars = 600) {
+  const t = sourceText.trimStart();
+  const block = t.match(/^\/\*[\s\S]*?\*\//);
+  if (block) return block[0].slice(0, maxChars);
+  const lines = t.split(/\r?\n/);
+  const commentLines = [];
+  for (const line of lines) {
+    const m = line.match(/^\s*\/\/(.*)$/);
+    if (!m) break;
+    commentLines.push(line.trim());
+    if (commentLines.join("\n").length >= maxChars) break;
+  }
+  if (commentLines.length) return commentLines.join("\n").slice(0, maxChars);
+  return "";
+}
+function uniq(xs) {
+  const out = [];
+  const s = /* @__PURE__ */ new Set();
+  for (const x of xs) {
+    if (!x) continue;
+    if (s.has(x)) continue;
+    s.add(x);
+    out.push(x);
+  }
+  return out;
+}
+function renderGenericSynopsis(input) {
+  const lead = leadingCommentExcerpt(input.sourceText);
+  const parts = [];
+  parts.push(`File synopsis`);
+  parts.push(`path: ${input.posixPath}`);
+  parts.push(`language: ${input.language}`);
+  if (lead) parts.push(`comment: ${lead.replace(/\s+/g, " ").trim()}`);
+  return parts.join("\n").slice(0, 1200);
+}
+function buildTsLikeSynopsis(input) {
+  const tsMod = getTypeScript();
+  if (!tsMod) return renderGenericSynopsis(input);
+  const lead = leadingCommentExcerpt(input.sourceText);
+  const sf = tsMod.createSourceFile(input.posixPath, input.sourceText, tsMod.ScriptTarget.Latest, true);
+  const imports = [];
+  const exports = [];
+  const topLevel = [];
+  for (const stmt of sf.statements) {
+    if (tsMod.isImportDeclaration(stmt) && tsMod.isStringLiteral(stmt.moduleSpecifier)) {
+      imports.push(stmt.moduleSpecifier.text);
+    }
+    const isExportedStmt = isExported(tsMod, stmt);
+    if (tsMod.isFunctionDeclaration(stmt) && stmt.name) topLevel.push(`fn ${stmt.name.text}${isExportedStmt ? " (export)" : ""}`);
+    if (tsMod.isClassDeclaration(stmt) && stmt.name) topLevel.push(`class ${stmt.name.text}${isExportedStmt ? " (export)" : ""}`);
+    if (tsMod.isInterfaceDeclaration(stmt) && stmt.name) topLevel.push(`interface ${stmt.name.text}${isExportedStmt ? " (export)" : ""}`);
+    if (tsMod.isTypeAliasDeclaration(stmt) && stmt.name) topLevel.push(`type ${stmt.name.text}${isExportedStmt ? " (export)" : ""}`);
+    if (tsMod.isEnumDeclaration(stmt) && stmt.name) topLevel.push(`enum ${stmt.name.text}${isExportedStmt ? " (export)" : ""}`);
+    if (tsMod.isModuleDeclaration(stmt) && stmt.name && tsMod.isIdentifier(stmt.name)) topLevel.push(`namespace ${stmt.name.text}${isExportedStmt ? " (export)" : ""}`);
+    if (tsMod.isVariableStatement(stmt)) {
+      const isExp = isExported(tsMod, stmt);
+      for (const decl of stmt.declarationList.declarations) {
+        if (tsMod.isIdentifier(decl.name)) topLevel.push(`var ${decl.name.text}${isExp ? " (export)" : ""}`);
+      }
+    }
+    if (tsMod.isExportDeclaration(stmt)) {
+      if (stmt.exportClause && tsMod.isNamedExports(stmt.exportClause)) {
+        for (const el of stmt.exportClause.elements) exports.push(el.name.text);
+      } else {
+        exports.push("*");
+      }
+    }
+    if ((tsMod.isFunctionDeclaration(stmt) || tsMod.isClassDeclaration(stmt)) && isExportedStmt && stmt.name) {
+      exports.push(stmt.name.text);
+    }
+  }
+  const importsU = uniq(imports).slice(0, 30);
+  const exportsU = uniq(exports).slice(0, 40);
+  const topU = uniq(topLevel).slice(0, 60);
+  const parts = [];
+  parts.push(`File synopsis`);
+  parts.push(`path: ${input.posixPath}`);
+  parts.push(`language: ${input.language}`);
+  if (importsU.length) parts.push(`imports: ${importsU.join(", ")}`);
+  if (exportsU.length) parts.push(`exports: ${exportsU.join(", ")}`);
+  if (topU.length) parts.push(`top-level: ${topU.join(" | ")}`);
+  if (lead) parts.push(`comment: ${lead.replace(/\s+/g, " ").trim()}`);
+  return parts.join("\n").slice(0, 1800);
+}
+var builtInStrategies = [
+  {
+    name: "ts-like",
+    supports: ({ language }) => language === "typescript" || language === "javascript",
+    build: buildTsLikeSynopsis
+  },
+  {
+    name: "markdown",
+    supports: ({ language }) => language === "markdown",
+    build: (input) => {
+      const lead = leadingCommentExcerpt(input.sourceText);
+      const parts = [];
+      parts.push(`File synopsis`);
+      parts.push(`path: ${input.posixPath}`);
+      parts.push(`language: ${input.language}`);
+      if (lead) parts.push(`comment: ${lead.replace(/\s+/g, " ").trim()}`);
+      const headings = input.sourceText.split(/\r?\n/).filter((l) => /^#{1,3}\s+/.test(l)).slice(0, 12);
+      if (headings.length) parts.push(`headings: ${headings.map((h) => h.replace(/\s+/g, " ").trim()).join(" | ")}`);
+      return parts.join("\n").slice(0, 1200);
+    }
+  },
+  {
+    name: "generic",
+    supports: () => true,
+    build: renderGenericSynopsis
+  }
+];
+var customStrategies = [];
+function buildSynopsis(posixPath, language, sourceText) {
+  const input = { posixPath, language, sourceText };
+  const all = [...customStrategies, ...builtInStrategies];
+  const strategy = all.find((s) => s.supports(input)) ?? builtInStrategies[builtInStrategies.length - 1];
+  try {
+    return strategy.build(input);
+  } catch {
+    return renderGenericSynopsis(input);
+  }
+}
+
+// src/store/embeddingCache.ts
+import fs4 from "fs";
+import path6 from "path";
+import Database from "better-sqlite3";
+var EmbeddingCache = class {
+  db;
+  constructor(cacheFilePath) {
+    fs4.mkdirSync(path6.dirname(cacheFilePath), { recursive: true });
+    this.db = new Database(cacheFilePath);
+    this.db.pragma("journal_mode = WAL");
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS embedding_cache (
+        provider_id TEXT NOT NULL,
+        content_hash TEXT NOT NULL,
+        embedding BLOB NOT NULL,
+        dim INTEGER NOT NULL,
+        created_at INTEGER NOT NULL,
+        PRIMARY KEY(provider_id, content_hash)
+      );
+    `);
+  }
+  get(providerId, contentHash) {
+    const row = this.db.prepare(
+      `SELECT embedding, dim FROM embedding_cache WHERE provider_id = ? AND content_hash = ?`
+    ).get(providerId, contentHash);
+    if (!row) return null;
+    const buf = row.embedding;
+    const view = new Float32Array(buf.buffer, buf.byteOffset, buf.byteLength / 4);
+    return new Float32Array(view);
+  }
+  put(providerId, contentHash, embedding) {
+    const buf = Buffer.from(embedding.buffer, embedding.byteOffset, embedding.byteLength);
+    this.db.prepare(
+      `INSERT OR REPLACE INTO embedding_cache(provider_id, content_hash, embedding, dim, created_at)
+       VALUES (?, ?, ?, ?, ?)`
+    ).run(providerId, contentHash, buf, embedding.length, Date.now());
+  }
+  close() {
+    this.db.close();
+  }
+};
+
+// src/store/repoStore.ts
+import fs5 from "fs";
+import path7 from "path";
+import Database2 from "better-sqlite3";
+var RepoStore = class {
+  db;
+  constructor(dbPath) {
+    fs5.mkdirSync(path7.dirname(dbPath), { recursive: true });
+    this.db = new Database2(dbPath);
+    this.db.pragma("journal_mode = WAL");
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS meta (
+        k TEXT PRIMARY KEY,
+        v TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS files (
+        path TEXT PRIMARY KEY,
+        hash TEXT NOT NULL,
+        mtime INTEGER NOT NULL,
+        language TEXT NOT NULL,
+        size INTEGER NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS chunks (
+        id TEXT PRIMARY KEY,
+        path TEXT NOT NULL,
+        language TEXT NOT NULL,
+        kind TEXT NOT NULL DEFAULT 'chunk',
+        start_line INTEGER NOT NULL,
+        end_line INTEGER NOT NULL,
+        content_hash TEXT NOT NULL,
+        tokens INTEGER NOT NULL,
+        file_mtime INTEGER NOT NULL,
+        text TEXT NOT NULL,
+        embedding BLOB NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_chunks_path ON chunks(path);
+      CREATE INDEX IF NOT EXISTS idx_chunks_kind_path ON chunks(kind, path);
+
+      CREATE VIRTUAL TABLE IF NOT EXISTS chunks_fts USING fts5(
+        id UNINDEXED,
+        path,
+        language,
+        kind,
+        text,
+        tokenize='unicode61'
+      );
+
+      CREATE TABLE IF NOT EXISTS edges (
+        from_path TEXT NOT NULL,
+        kind TEXT NOT NULL,
+        value TEXT NOT NULL,
+        PRIMARY KEY(from_path, kind, value)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_edges_from ON edges(from_path);
+    `);
+    if (this.getMeta("storeVersion") === null) this.setMeta("storeVersion", "0");
+  }
+  /** Monotonically increases whenever the chunk-store is mutated. */
+  getStoreVersion() {
+    const v = this.getMeta("storeVersion");
+    return v ? Number(v) : 0;
+  }
+  /** Internal: bump store version (call inside the same transaction that mutates chunks). */
+  bumpStoreVersion() {
+    const next = this.getStoreVersion() + 1;
+    this.setMeta("storeVersion", String(next));
+  }
+  /** Vector index sync marker (per backend kind). */
+  getVectorIndexVersion(kind) {
+    const v = this.getMeta(`vector.${kind}.storeVersion`);
+    return v ? Number(v) : 0;
+  }
+  setVectorIndexVersion(kind, storeVersion) {
+    this.setMeta(`vector.${kind}.storeVersion`, String(storeVersion));
+  }
+  setMeta(k, v) {
+    this.db.prepare(`INSERT OR REPLACE INTO meta(k, v) VALUES (?, ?)`).run(k, v);
+  }
+  getMeta(k) {
+    const row = this.db.prepare(`SELECT v FROM meta WHERE k = ?`).get(k);
+    return row?.v ?? null;
+  }
+  getFileHash(posixPath) {
+    const row = this.db.prepare(`SELECT hash FROM files WHERE path = ?`).get(posixPath);
+    return row?.hash ?? null;
+  }
+  getFileMtime(posixPath) {
+    const row = this.db.prepare(`SELECT mtime FROM files WHERE path = ?`).get(posixPath);
+    return row?.mtime ?? null;
+  }
+  upsertFile(posixPath, hash, mtime, language, size) {
+    this.db.prepare(`
+      INSERT INTO files(path, hash, mtime, language, size)
+      VALUES (?, ?, ?, ?, ?)
+      ON CONFLICT(path) DO UPDATE SET
+        hash = excluded.hash,
+        mtime = excluded.mtime,
+        language = excluded.language,
+        size = excluded.size
+    `).run(posixPath, hash, mtime, language, size);
+  }
+  deleteFile(posixPath) {
+    const tx = this.db.transaction(() => {
+      this.db.prepare(`DELETE FROM chunks WHERE path = ?`).run(posixPath);
+      this.db.prepare(`DELETE FROM chunks_fts WHERE path = ?`).run(posixPath);
+      this.db.prepare(`DELETE FROM edges WHERE from_path = ?`).run(posixPath);
+      this.db.prepare(`DELETE FROM files WHERE path = ?`).run(posixPath);
+      this.bumpStoreVersion();
+    });
+    tx();
+  }
+  replaceChunksForFile(posixPath, rows) {
+    const tx = this.db.transaction(() => {
+      this.db.prepare(`DELETE FROM chunks WHERE path = ?`).run(posixPath);
+      this.db.prepare(`DELETE FROM chunks_fts WHERE path = ?`).run(posixPath);
+      const ins = this.db.prepare(`
+        INSERT INTO chunks(id, path, language, kind, start_line, end_line, content_hash, tokens, file_mtime, text, embedding)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `);
+      const insFts = this.db.prepare(`
+        INSERT INTO chunks_fts(id, path, language, kind, text)
+        VALUES (?, ?, ?, ?, ?)
+      `);
+      for (const r of rows) {
+        const buf = Buffer.from(r.embedding.buffer, r.embedding.byteOffset, r.embedding.byteLength);
+        ins.run(r.id, posixPath, r.language, r.kind, r.startLine, r.endLine, r.contentHash, r.tokens, r.fileMtime, r.text, buf);
+        insFts.run(r.id, posixPath, r.language, r.kind, r.ftsText);
+      }
+      this.bumpStoreVersion();
+    });
+    tx();
+  }
+  setEdges(fromPath, kind, values) {
+    const tx = this.db.transaction(() => {
+      this.db.prepare(`DELETE FROM edges WHERE from_path = ? AND kind = ?`).run(fromPath, kind);
+      const ins = this.db.prepare(`INSERT OR REPLACE INTO edges(from_path, kind, value) VALUES (?, ?, ?)`);
+      for (const v of values) ins.run(fromPath, kind, v);
+    });
+    tx();
+  }
+  listEdges(fromPath, kind) {
+    const rows = this.db.prepare(`SELECT value FROM edges WHERE from_path = ? AND kind = ?`).all(fromPath, kind);
+    return rows.map((r) => r.value);
+  }
+  listAllFiles() {
+    const rows = this.db.prepare(`SELECT path FROM files`).all();
+    return rows.map((r) => r.path);
+  }
+  countChunks() {
+    const row = this.db.prepare(`SELECT COUNT(*) AS c FROM chunks`).get();
+    return row.c;
+  }
+  /**
+   * Returns the embedding dimension if any chunks exist, otherwise null.
+   * Efficient (doesn't load all embeddings).
+   */
+  getAnyEmbeddingDimension() {
+    const row = this.db.prepare(`SELECT embedding FROM chunks LIMIT 1`).get();
+    if (!row) return null;
+    return Math.floor(row.embedding.byteLength / 4);
+  }
+  loadAllChunkEmbeddings() {
+    const rows = this.db.prepare(`SELECT id, embedding FROM chunks`).all();
+    return rows.map((r) => {
+      const view = new Float32Array(r.embedding.buffer, r.embedding.byteOffset, r.embedding.byteLength / 4);
+      return { id: r.id, embedding: new Float32Array(view) };
+    });
+  }
+  getChunkById(id) {
+    const row = this.db.prepare(`SELECT * FROM chunks WHERE id = ?`).get(id);
+    return row ?? null;
+  }
+  listChunksForFile(posixPath, kind) {
+    if (kind) {
+      return this.db.prepare(`SELECT id, start_line, end_line, kind FROM chunks WHERE path = ? AND kind = ? ORDER BY start_line ASC`).all(posixPath, kind);
+    }
+    return this.db.prepare(`SELECT id, start_line, end_line, kind FROM chunks WHERE path = ? ORDER BY kind DESC, start_line ASC`).all(posixPath);
+  }
+  /**
+   * Best-effort lexical search using SQLite FTS5.
+   * Returns ids with bm25 values (lower is better).
+   */
+  searchFts(ftq, limit, includePaths) {
+    try {
+      if (includePaths && includePaths.length > 0) {
+        const placeholders = includePaths.map(() => "?").join(", ");
+        const sql2 = `
+          SELECT id, bm25(chunks_fts) AS bm25
+          FROM chunks_fts
+          WHERE chunks_fts MATCH ? AND path IN (${placeholders})
+          ORDER BY bm25 ASC
+          LIMIT ?
+        `;
+        const args = [ftq, ...includePaths, limit];
+        return this.db.prepare(sql2).all(...args);
+      }
+      const sql = `
+        SELECT id, bm25(chunks_fts) AS bm25
+        FROM chunks_fts
+        WHERE chunks_fts MATCH ?
+        ORDER BY bm25 ASC
+        LIMIT ?
+      `;
+      return this.db.prepare(sql).all(ftq, limit);
+    } catch {
+      return [];
+    }
+  }
+  close() {
+    this.db.close();
+  }
+};
+
+// src/retrieval/tokens.ts
+function uniq2(xs) {
+  const out = [];
+  const s = /* @__PURE__ */ new Set();
+  for (const x of xs) {
+    if (!x) continue;
+    if (s.has(x)) continue;
+    s.add(x);
+    out.push(x);
+  }
+  return out;
+}
+function extractLexicalTokens(text, maxTokens = 2500) {
+  const toks = text.match(/[A-Za-z_][A-Za-z0-9_]{1,}/g) ?? [];
+  const u = uniq2(toks).slice(0, maxTokens);
+  return u.join(" ");
+}
+
+// src/retrieval/fts.ts
+function ftsQueryFromText(input) {
+  const tokens = (input.match(/[A-Za-z0-9_]{2,}/g) ?? []).slice(0, 24);
+  if (tokens.length === 0) return "";
+  const parts = tokens.map((t) => {
+    const safe = t.replace(/"/g, '""');
+    return `${safe}*`;
+  });
+  return parts.join(" OR ");
+}
+function bm25ToScore01(bm25) {
+  if (!Number.isFinite(bm25)) return 0;
+  const s = 1 / (1 + Math.max(0, bm25));
+  return clamp(s, 0, 1);
+}
+function vectorCosineToScore01(cosine) {
+  if (!Number.isFinite(cosine)) return 0;
+  return clamp((cosine + 1) / 2, 0, 1);
+}
+
+// src/indexer/repoIndexer.ts
+function repoIdFromRoot(repoRoot) {
+  return sha256Hex(path8.resolve(repoRoot)).slice(0, 16);
+}
+function looksBinary(buf) {
+  let nul = 0;
+  const n = Math.min(buf.length, 4096);
+  for (let i = 0; i < n; i++) if (buf[i] === 0) nul++;
+  return nul > 2;
+}
+var RepoIndexer = class {
+  // id -> row cache
+  constructor(repoRoot, embedder, config = {}) {
+    this.embedder = embedder;
+    this.repoRoot = path8.resolve(repoRoot);
+    this.repoId = repoIdFromRoot(this.repoRoot);
+    const cacheDir = config.cacheDir ?? defaultCacheDir();
+    this.config = {
+      cacheDir,
+      includeExtensions: config.includeExtensions ?? [
+        ".ts",
+        ".tsx",
+        ".js",
+        ".jsx",
+        ".mjs",
+        ".cjs",
+        ".py",
+        ".go",
+        ".rs",
+        ".java",
+        ".kt",
+        ".kts",
+        ".cs",
+        ".md",
+        ".json",
+        ".yml",
+        ".yaml",
+        ".toml"
+      ],
+      maxFileBytes: config.maxFileBytes ?? 2e6,
+      chunk: {
+        maxChars: config.chunk?.maxChars ?? 12e3,
+        maxLines: config.chunk?.maxLines ?? 240,
+        overlapLines: config.chunk?.overlapLines ?? 40
+      },
+      embed: {
+        batchSize: config.embed?.batchSize ?? 32,
+        concurrency: config.embed?.concurrency ?? 4
+      },
+      watch: {
+        debounceMs: config.watch?.debounceMs ?? 250
+      },
+      ignoreFiles: config.ignoreFiles ?? [".petriignore", ".augmentignore"],
+      redact: {
+        enabled: config.redact?.enabled ?? true,
+        skipPathSubstrings: config.redact?.skipPathSubstrings ?? [".env", "id_rsa", ".pem", ".p12", "secrets"],
+        patterns: config.redact?.patterns ?? [
+          { name: "private_key_block", regex: /-----BEGIN [A-Z ]+PRIVATE KEY-----[\s\S]*?-----END [A-Z ]+PRIVATE KEY-----/g, replaceWith: "[REDACTED_PRIVATE_KEY]" },
+          { name: "aws_access_key_id", regex: /\bAKIA[0-9A-Z]{16}\b/g, replaceWith: "[REDACTED_AWS_KEY]" }
+        ]
+      },
+      storage: {
+        storeText: config.storage?.storeText ?? true,
+        ftsMode: config.storage?.ftsMode ?? "full"
+      },
+      vector: {
+        provider: config.vector?.provider ?? "bruteforce",
+        metric: config.vector?.metric ?? "cosine",
+        hnswlib: config.vector?.hnswlib,
+        qdrant: config.vector?.qdrant,
+        faiss: config.vector?.faiss,
+        custom: config.vector?.custom
+      },
+      profiles: config.profiles ?? {}
+    };
+    this.embeddingCache = new EmbeddingCache(path8.join(cacheDir, "embedding-cache.sqlite"));
+  }
+  repoRoot;
+  repoId;
+  config;
+  store = null;
+  vec = null;
+  vecFlushTimer = null;
+  vecFlushInFlight = null;
+  embeddingCache;
+  currentCommit = null;
+  currentBranch = null;
+  watcher = null;
+  fileIgnore = null;
+  serial = pLimit(1);
+  chunkCache = /* @__PURE__ */ new Map();
+  getCommit() {
+    return this.currentCommit;
+  }
+  getBranch() {
+    return this.currentBranch;
+  }
+  getStore() {
+    return this.store;
+  }
+  dbPathForCommit(commit) {
+    return path8.join(this.config.cacheDir, "index", this.repoId, `${commit}.sqlite`);
+  }
+  shouldIndexPath(posixRelPath) {
+    const lower = posixRelPath.toLowerCase();
+    const ext = "." + (lower.split(".").pop() ?? "");
+    if (!this.config.includeExtensions.includes(ext)) return false;
+    if (this.config.redact.enabled) {
+      for (const s of this.config.redact.skipPathSubstrings) {
+        if (lower.includes(s.toLowerCase())) return false;
+      }
+    }
+    if (this.fileIgnore && this.fileIgnore(posixRelPath)) return false;
+    return true;
+  }
+  applyRedactions(text) {
+    if (!this.config.redact.enabled) return text;
+    let t = text;
+    for (const p of this.config.redact.patterns) t = t.replace(p.regex, p.replaceWith);
+    return t;
+  }
+  vectorMetric() {
+    return this.config.vector.metric ?? "cosine";
+  }
+  vectorFlushDebounceMs() {
+    const kind = this.vec?.kind;
+    if (!kind) return 0;
+    if (kind === "hnswlib") return this.config.vector.hnswlib?.persistDebounceMs ?? 2e3;
+    if (kind === "faiss") return this.config.vector.faiss?.persistDebounceMs ?? 2e3;
+    return 0;
+  }
+  scheduleVectorFlush() {
+    if (!this.vec || !this.store) return;
+    const ms = this.vectorFlushDebounceMs();
+    if (this.vecFlushTimer) {
+      clearTimeout(this.vecFlushTimer);
+      this.vecFlushTimer = null;
+    }
+    if (ms <= 0) {
+      void this.flushVectorNow();
+      return;
+    }
+    this.vecFlushTimer = setTimeout(() => {
+      this.vecFlushTimer = null;
+      void this.flushVectorNow();
+    }, ms);
+  }
+  async flushVectorNow() {
+    if (!this.vec || !this.store) return;
+    if (this.vecFlushTimer) {
+      clearTimeout(this.vecFlushTimer);
+      this.vecFlushTimer = null;
+    }
+    if (this.vecFlushInFlight) return this.vecFlushInFlight;
+    const work = (async () => {
+      await this.vec.flush();
+      const sv = this.store.getStoreVersion();
+      this.store.setVectorIndexVersion(this.vec.kind, sv);
+    })();
+    this.vecFlushInFlight = work.finally(() => {
+      this.vecFlushInFlight = null;
+    });
+    return this.vecFlushInFlight;
+  }
+  async ensureVectorIndex(dimension) {
+    if (!this.currentCommit || !this.currentBranch) return null;
+    if (this.vec && this.vec.dimension === dimension) return this.vec;
+    if (this.vec) {
+      try {
+        await this.vec.close();
+      } catch {
+      }
+      this.vec = null;
+    }
+    const vec = await createVectorIndex(this.config.vector);
+    await vec.init({
+      repoId: this.repoId,
+      repoRoot: this.repoRoot,
+      commit: this.currentCommit,
+      branch: this.currentBranch,
+      cacheDir: this.config.cacheDir,
+      dimension,
+      metric: this.vectorMetric()
+    });
+    this.vec = vec;
+    return vec;
+  }
+  async openForCurrentHead() {
+    const commit = await getHeadCommit(this.repoRoot);
+    const branch = await getBranchName(this.repoRoot);
+    if (this.currentCommit === commit && this.store) return;
+    this.currentCommit = commit;
+    this.currentBranch = branch;
+    this.chunkCache.clear();
+    if (this.vecFlushTimer) {
+      clearTimeout(this.vecFlushTimer);
+      this.vecFlushTimer = null;
+    }
+    this.vecFlushInFlight = null;
+    if (this.vec) {
+      try {
+        await this.vec.close();
+      } catch {
+      }
+      this.vec = null;
+    }
+    if (this.store) this.store.close();
+    this.fileIgnore = loadExtraIgnore(this.repoRoot, this.config.ignoreFiles);
+    this.store = new RepoStore(this.dbPathForCommit(commit));
+    this.store.setMeta("repoRoot", this.repoRoot);
+    this.store.setMeta("repoId", this.repoId);
+    this.store.setMeta("commit", commit);
+    this.store.setMeta("branch", branch);
+    this.store.setMeta("embedderId", this.embedder.id);
+    const dim = this.embedder.dimension ?? this.store.getAnyEmbeddingDimension();
+    if (!dim) return;
+    const vec = await this.ensureVectorIndex(dim);
+    if (!vec) return;
+    const storeCount = this.store.countChunks();
+    const storeVersion = this.store.getStoreVersion();
+    const vecVersion = this.store.getVectorIndexVersion(vec.kind);
+    const vecCount = await vec.count();
+    if (storeCount > 0 && (vecVersion !== storeVersion || vecCount !== storeCount || vec.kind === "faiss")) {
+      await vec.rebuild(
+        this.store.loadAllChunkEmbeddings().map((e) => ({ id: e.id, vector: e.embedding }))
+      );
+      await this.flushVectorNow();
+    }
+  }
+  async indexAll() {
+    await this.openForCurrentHead();
+    if (!this.store) throw new Error("RepoStore not initialised");
+    const files = (await listWorkingFiles(this.repoRoot)).filter((p) => this.shouldIndexPath(p));
+    const currentSet = new Set(files);
+    for (const known of this.store.listAllFiles()) {
+      if (!currentSet.has(known)) {
+        await this.deleteFile(known);
+      }
+    }
+    const limit = pLimit(this.config.embed.concurrency);
+    await Promise.all(files.map((f) => limit(() => this.indexFile(f))));
+    if (this.vec) await this.flushVectorNow();
+  }
+  async indexFile(posixRelPath) {
+    return this.serial(async () => {
+      await this.openForCurrentHead();
+      if (!this.store) throw new Error("RepoStore not initialised");
+      if (!this.shouldIndexPath(posixRelPath)) return;
+      const abs = path8.join(this.repoRoot, fromPosixPath(posixRelPath));
+      let stat;
+      try {
+        stat = fs6.statSync(abs);
+      } catch {
+        this.deleteFile(posixRelPath);
+        return;
+      }
+      if (!stat.isFile()) return;
+      if (stat.size > this.config.maxFileBytes) return;
+      const buf = fs6.readFileSync(abs);
+      if (looksBinary(buf)) return;
+      const raw = buf.toString("utf8");
+      const redacted = this.applyRedactions(raw);
+      const fileHash = sha256Hex(redacted);
+      const prev = this.store.getFileHash(posixRelPath);
+      if (prev === fileHash) return;
+      const { language, chunks } = chunkSource(posixRelPath, redacted, this.config.chunk);
+      if (language === "typescript" || language === "javascript") {
+        const rel = extractTsRelations(posixRelPath, redacted);
+        this.store.setEdges(posixRelPath, "import", rel.imports);
+        this.store.setEdges(posixRelPath, "export", rel.exports);
+      } else {
+        this.store.setEdges(posixRelPath, "import", []);
+        this.store.setEdges(posixRelPath, "export", []);
+      }
+      const synopsisText = buildSynopsis(posixRelPath, language, redacted);
+      const synopsis = synopsisText.trim() ? [{
+        startLine: 1,
+        endLine: 1,
+        text: synopsisText,
+        contentHash: sha256Hex(synopsisText),
+        tokens: Math.max(1, Math.ceil(synopsisText.length / 4)),
+        kind: "synopsis"
+      }] : [];
+      const headerLines = Math.min(80, this.config.chunk.maxLines);
+      const headerText = redacted.split(/\r?\n/).slice(0, headerLines).join("\n").trimEnd();
+      const headerChunk = headerText.trim() ? [{
+        startLine: 1,
+        endLine: headerLines,
+        text: headerText,
+        contentHash: sha256Hex(headerText),
+        tokens: Math.max(1, Math.ceil(headerText.length / 4)),
+        kind: "chunk"
+      }] : [];
+      const combined = [
+        ...synopsis,
+        ...headerChunk,
+        ...chunks.map((c) => ({ ...c, kind: "chunk" }))
+      ];
+      const embedTexts = [];
+      const embedPlan = [];
+      const embeddings = combined.map(() => null);
+      for (let i = 0; i < combined.length; i++) {
+        const ch = combined[i];
+        const cached2 = this.embeddingCache.get(this.embedder.id, ch.contentHash);
+        if (cached2) {
+          embeddings[i] = cached2;
+          continue;
+        }
+        embedTexts.push(
+          `repo:${path8.basename(this.repoRoot)}
+path:${posixRelPath}
+language:${language}
+kind:${ch.kind}
+lines:${ch.startLine}-${ch.endLine}
+---
+${ch.text}`
+        );
+        embedPlan.push({ chunkIdx: i, contentHash: ch.contentHash });
+      }
+      const batchSize = this.config.embed.batchSize;
+      for (let start = 0; start < embedTexts.length; start += batchSize) {
+        const end = Math.min(embedTexts.length, start + batchSize);
+        const batch = embedTexts.slice(start, end);
+        const vecs = await this.embedder.embed(batch);
+        for (let j = 0; j < vecs.length; j++) {
+          const plan = embedPlan[start + j];
+          embeddings[plan.chunkIdx] = vecs[j];
+          this.embeddingCache.put(this.embedder.id, plan.contentHash, vecs[j]);
+        }
+      }
+      const fileMtime = stat.mtimeMs;
+      const ftsMode = this.config.storage.ftsMode;
+      const storeText = this.config.storage.storeText;
+      const oldChunkIds = this.store.listChunksForFile(posixRelPath).map((r) => r.id);
+      const points = [];
+      const rows = combined.map((ch, i) => {
+        const id = sha256Hex(`${this.repoId}:${posixRelPath}:${ch.kind}:${ch.startLine}:${ch.endLine}:${ch.contentHash}`).slice(0, 32);
+        const emb = embeddings[i];
+        if (!emb) throw new Error("Embedding missing unexpectedly");
+        points.push({ id, vector: emb });
+        const textToStore = ch.kind === "synopsis" ? ch.text : storeText ? ch.text : "";
+        const ftsText = ftsMode === "off" ? "" : ftsMode === "tokens" ? extractLexicalTokens(ch.text) : ch.text;
+        return {
+          id,
+          language,
+          kind: ch.kind,
+          startLine: ch.startLine,
+          endLine: ch.endLine,
+          contentHash: ch.contentHash,
+          text: textToStore,
+          ftsText,
+          tokens: ch.tokens,
+          fileMtime,
+          embedding: emb
+        };
+      });
+      this.store.upsertFile(posixRelPath, fileHash, fileMtime, language, stat.size);
+      this.store.replaceChunksForFile(posixRelPath, rows);
+      const dim = points[0]?.vector.length;
+      if (dim) {
+        await this.ensureVectorIndex(dim);
+        if (this.vec) {
+          await this.vec.remove(oldChunkIds);
+          await this.vec.upsert(points);
+          this.scheduleVectorFlush();
+        }
+      }
+    });
+  }
+  async deleteFileInner(posixRelPath) {
+    if (!this.store) return;
+    const chunkIds = this.store.listChunksForFile(posixRelPath).map((r) => r.id);
+    this.store.deleteFile(posixRelPath);
+    if (this.vec && chunkIds.length > 0) {
+      await this.vec.remove(chunkIds);
+      this.scheduleVectorFlush();
+    }
+  }
+  async deleteFile(posixRelPath) {
+    return this.serial(async () => {
+      await this.openForCurrentHead();
+      await this.deleteFileInner(posixRelPath);
+    });
+  }
+  async vectorCandidates(queryEmbedding, k, includePaths) {
+    await this.openForCurrentHead();
+    if (!this.store) throw new Error("RepoStore not initialised");
+    if (!this.vec) {
+      const dim = this.embedder.dimension ?? this.store.getAnyEmbeddingDimension();
+      if (dim) await this.ensureVectorIndex(dim);
+    }
+    if (!this.vec) return [];
+    if (!includePaths || includePaths.length === 0) {
+      return await this.vec.search(queryEmbedding, k);
+    }
+    const tries = [k * 5, k * 15, k * 40].map((x) => Math.max(k, x));
+    for (const kk of tries) {
+      const cand2 = await this.vec.search(queryEmbedding, kk);
+      const filtered2 = [];
+      for (const c of cand2) {
+        const row = this.getChunkRowCached(c.id);
+        if (row && includePaths.includes(row.path)) filtered2.push(c);
+        if (filtered2.length >= k) break;
+      }
+      if (filtered2.length >= k) return filtered2.slice(0, k);
+    }
+    const cand = await this.vec.search(queryEmbedding, tries[tries.length - 1]);
+    const filtered = cand.filter((c) => {
+      const row = this.getChunkRowCached(c.id);
+      return row ? includePaths.includes(row.path) : false;
+    });
+    return filtered.slice(0, k);
+  }
+  async lexicalCandidates(queryText, k, includePaths) {
+    await this.openForCurrentHead();
+    if (!this.store) throw new Error("RepoStore not initialised");
+    if (this.config.storage.ftsMode === "off") return [];
+    const ftq = ftsQueryFromText(queryText);
+    if (!ftq) return [];
+    const rows = this.store.searchFts(ftq, k, includePaths);
+    return rows.map((r) => ({ id: r.id, score: bm25ToScore01(r.bm25) }));
+  }
+  getChunkRowCached(id) {
+    const cached2 = this.chunkCache.get(id);
+    if (cached2) return cached2;
+    if (!this.store) return null;
+    const row = this.store.getChunkById(id);
+    if (row) this.chunkCache.set(id, row);
+    return row ?? null;
+  }
+  readChunkTextFallback(row) {
+    const abs = path8.join(this.repoRoot, fromPosixPath(row.path));
+    try {
+      const raw = fs6.readFileSync(abs, "utf8");
+      const lines = raw.split(/\r?\n/);
+      const start = Math.max(1, row.start_line);
+      const end = Math.max(start, row.end_line);
+      return lines.slice(start - 1, end).join("\n");
+    } catch {
+      return "";
+    }
+  }
+  getChunkRecord(id) {
+    const row = this.getChunkRowCached(id);
+    if (!row) return null;
+    const text = row.text && row.text.trim().length > 0 ? row.text : this.readChunkTextFallback(row);
+    return {
+      id: row.id,
+      repoId: this.repoId,
+      repoRoot: this.repoRoot,
+      path: row.path,
+      language: row.language,
+      startLine: row.start_line,
+      endLine: row.end_line,
+      contentHash: row.content_hash,
+      text,
+      tokens: row.tokens,
+      fileMtimeMs: row.file_mtime,
+      kind: row.kind === "synopsis" ? "synopsis" : "chunk"
+    };
+  }
+  getChunkMeta(id) {
+    const row = this.getChunkRowCached(id);
+    if (!row) return null;
+    return {
+      id: row.id,
+      repoId: this.repoId,
+      repoRoot: this.repoRoot,
+      path: row.path,
+      language: row.language,
+      startLine: row.start_line,
+      endLine: row.end_line,
+      contentHash: row.content_hash,
+      tokens: row.tokens,
+      fileMtimeMs: row.file_mtime,
+      kind: row.kind === "synopsis" ? "synopsis" : "chunk"
+    };
+  }
+  getChunkText(id) {
+    const row = this.getChunkRowCached(id);
+    if (!row) return "";
+    return row.text && row.text.trim().length > 0 ? row.text : this.readChunkTextFallback(row);
+  }
+  getChunkPreview(id) {
+    const r = this.getChunkRecord(id);
+    return r ? makePreview(r.text) : "";
+  }
+  /**
+   * Expand context around a hit:
+   * - adjacency (previous/next chunks in file)
+   * - follow relative imports to include imported file synopses/headers
+   */
+  async expandContext(chunkId, opts) {
+    await this.openForCurrentHead();
+    if (!this.store) throw new Error("RepoStore not initialised");
+    const row = this.getChunkRowCached(chunkId);
+    if (!row) return [];
+    const out = [];
+    if (opts.includeFileSynopsis) {
+      const synopsis = this.store.listChunksForFile(row.path, "synopsis")[0];
+      if (synopsis) out.push({ id: synopsis.id, reason: "file synopsis" });
+    }
+    const adj = Math.max(0, opts.adjacentChunks);
+    if (adj > 0) {
+      const fileChunks = this.store.listChunksForFile(row.path).filter((c) => c.kind !== "synopsis");
+      const idx = fileChunks.findIndex((c) => c.id === chunkId);
+      if (idx >= 0) {
+        for (let d = 1; d <= adj; d++) {
+          for (const j of [idx - d, idx + d]) {
+            if (j < 0 || j >= fileChunks.length) continue;
+            out.push({ id: fileChunks[j].id, reason: `adjacent chunk (\xB1${d})` });
+          }
+        }
+      }
+    }
+    const follow = Math.max(0, opts.followImports);
+    if (follow > 0) {
+      const imports = this.store.listEdges(row.path, "import").filter((s) => s.startsWith("."));
+      for (const spec of imports.slice(0, follow)) {
+        const candidates = [
+          spec,
+          `${spec}.ts`,
+          `${spec}.tsx`,
+          `${spec}.js`,
+          `${spec}.jsx`,
+          `${spec}/index.ts`,
+          `${spec}/index.tsx`,
+          `${spec}/index.js`,
+          `${spec}/index.jsx`
+        ].map((s) => path8.posix.normalize(path8.posix.join(path8.posix.dirname(row.path), s)));
+        for (const c of candidates) {
+          const syn = this.store.listChunksForFile(c, "synopsis")[0];
+          if (syn) {
+            out.push({ id: syn.id, reason: `imported file synopsis (${spec})` });
+            break;
+          }
+          const header = this.store.listChunksForFile(c).find((x) => x.kind !== "synopsis");
+          if (header) {
+            out.push({ id: header.id, reason: `imported file header (${spec})` });
+            break;
+          }
+        }
+      }
+    }
+    const seen = /* @__PURE__ */ new Set();
+    const deduped = [];
+    for (const x of out) {
+      if (seen.has(x.id)) continue;
+      seen.add(x.id);
+      deduped.push(x);
+    }
+    return deduped;
+  }
+  async watch() {
+    await this.openForCurrentHead();
+    const debounceMs = this.config.watch.debounceMs;
+    let timer = null;
+    const schedule = (fn) => {
+      if (timer) clearTimeout(timer);
+      timer = setTimeout(fn, debounceMs);
+    };
+    const headPath = path8.join(this.repoRoot, ".git", "HEAD");
+    this.watcher = chokidar.watch([this.repoRoot, headPath], {
+      ignoreInitial: true,
+      ignored: (p) => {
+        const rel = path8.relative(this.repoRoot, p);
+        if (!rel) return false;
+        const posix = rel.split(path8.sep).join("/");
+        if (posix.startsWith(".git/")) return true;
+        if (posix.includes("node_modules/")) return true;
+        if (posix.includes("/.cache/")) return true;
+        return false;
+      }
+    });
+    this.watcher.on("change", (p) => {
+      const rel = path8.relative(this.repoRoot, p);
+      const posix = rel.split(path8.sep).join("/");
+      if (posix === ".git/HEAD") {
+        schedule(() => this.indexAll().catch(() => void 0));
+        return;
+      }
+      schedule(() => this.indexFile(posix).catch(() => void 0));
+    });
+    this.watcher.on("add", (p) => {
+      const rel = path8.relative(this.repoRoot, p);
+      const posix = rel.split(path8.sep).join("/");
+      schedule(() => this.indexFile(posix).catch(() => void 0));
+    });
+    this.watcher.on("unlink", (p) => {
+      const rel = path8.relative(this.repoRoot, p);
+      const posix = rel.split(path8.sep).join("/");
+      schedule(() => this.deleteFile(posix).catch(() => void 0));
+    });
+  }
+  async closeAsync() {
+    if (this.vecFlushTimer) {
+      clearTimeout(this.vecFlushTimer);
+      this.vecFlushTimer = null;
+    }
+    if (this.vec && this.store) {
+      try {
+        await this.flushVectorNow();
+      } catch {
+      }
+    }
+    if (this.vec) {
+      try {
+        await this.vec.close();
+      } catch {
+      }
+      this.vec = null;
+    }
+    await this.watcher?.close().catch(() => void 0);
+    this.watcher = null;
+    this.store?.close();
+    this.store = null;
+    this.embeddingCache.close();
+    this.chunkCache.clear();
+  }
+  close() {
+    void this.closeAsync();
+  }
+};
+
+// src/profiles.ts
+var DEFAULT_PROFILES = {
+  search: {
+    name: "search",
+    k: 10,
+    weights: { vector: 0.65, lexical: 0.35, recency: 0 },
+    expand: { adjacentChunks: 0, followImports: 0, includeFileSynopsis: false },
+    candidates: { vectorK: 25, lexicalK: 25, maxMergedCandidates: 60 }
+  },
+  refactor: {
+    name: "refactor",
+    k: 15,
+    weights: { vector: 0.55, lexical: 0.35, recency: 0.1 },
+    expand: { adjacentChunks: 1, followImports: 2, includeFileSynopsis: true },
+    candidates: { vectorK: 60, lexicalK: 40, maxMergedCandidates: 140 }
+  },
+  review: {
+    name: "review",
+    k: 20,
+    weights: { vector: 0.45, lexical: 0.35, recency: 0.2 },
+    expand: { adjacentChunks: 1, followImports: 1, includeFileSynopsis: true },
+    candidates: { vectorK: 80, lexicalK: 60, maxMergedCandidates: 180 }
+  },
+  architecture: {
+    name: "architecture",
+    k: 20,
+    weights: { vector: 0.7, lexical: 0.2, recency: 0.1 },
+    expand: { adjacentChunks: 0, followImports: 3, includeFileSynopsis: true },
+    candidates: { vectorK: 120, lexicalK: 40, maxMergedCandidates: 220 }
+  },
+  rca: {
+    name: "rca",
+    k: 25,
+    weights: { vector: 0.5, lexical: 0.25, recency: 0.25 },
+    expand: { adjacentChunks: 2, followImports: 1, includeFileSynopsis: true },
+    candidates: { vectorK: 140, lexicalK: 80, maxMergedCandidates: 260 }
+  },
+  custom: {
+    name: "custom",
+    k: 10,
+    weights: { vector: 0.65, lexical: 0.35, recency: 0 },
+    expand: { adjacentChunks: 0, followImports: 0, includeFileSynopsis: false },
+    candidates: { vectorK: 25, lexicalK: 25, maxMergedCandidates: 60 }
+  }
+};
+function deepMergeProfile(base, patch) {
+  if (!patch) return base;
+  const merged = {
+    ...base,
+    ...patch,
+    weights: { ...base.weights, ...patch.weights ?? {} },
+    expand: { ...base.expand, ...patch.expand ?? {} },
+    candidates: { ...base.candidates, ...patch.candidates ?? {} }
+  };
+  return merged;
+}
+
+// src/indexer/workspaceIndexer.ts
+import fs7 from "fs";
+import path9 from "path";
+function findGitRepos(workspaceRoot) {
+  const out = [];
+  const stack = [path9.resolve(workspaceRoot)];
+  while (stack.length) {
+    const dir = stack.pop();
+    if (dir.includes("node_modules")) continue;
+    const gitDir = path9.join(dir, ".git");
+    if (fs7.existsSync(gitDir) && fs7.statSync(gitDir).isDirectory()) {
+      out.push(dir);
+      continue;
+    }
+    let entries;
+    try {
+      entries = fs7.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const e of entries) {
+      if (!e.isDirectory()) continue;
+      if (e.name.startsWith(".")) continue;
+      stack.push(path9.join(dir, e.name));
+    }
+  }
+  return out;
+}
+function halfLifeDaysForProfile(profileName) {
+  if (profileName === "rca") return 7;
+  if (profileName === "review") return 14;
+  if (profileName === "refactor") return 21;
+  return 30;
+}
+var WorkspaceIndexer = class {
+  constructor(workspaceRoot, embedder, config = {}) {
+    this.workspaceRoot = workspaceRoot;
+    this.embedder = embedder;
+    this.config = { ...config };
+    if (!this.config.cacheDir) this.config.cacheDir = defaultCacheDir();
+  }
+  repos = [];
+  config;
+  async open() {
+    const repoRoots = findGitRepos(this.workspaceRoot);
+    this.repos = repoRoots.map((r) => new RepoIndexer(r, this.embedder, this.config));
+  }
+  async indexAll() {
+    if (this.repos.length === 0) await this.open();
+    await Promise.all(this.repos.map((r) => r.indexAll()));
+  }
+  async watch() {
+    if (this.repos.length === 0) await this.open();
+    await Promise.all(this.repos.map((r) => r.watch()));
+  }
+  getRepoIndexers() {
+    return this.repos.slice();
+  }
+  resolveProfile(opts) {
+    const name = opts?.profile ?? "search";
+    const base = DEFAULT_PROFILES[name] ?? DEFAULT_PROFILES.search;
+    const configPatch = this.config.profiles?.[name] ?? {};
+    const merged1 = deepMergeProfile(base, configPatch);
+    const merged2 = deepMergeProfile(merged1, opts?.profileOverrides);
+    const w = merged2.weights;
+    const sum = Math.max(1e-6, w.vector + w.lexical + w.recency);
+    merged2.weights = { vector: w.vector / sum, lexical: w.lexical / sum, recency: w.recency / sum };
+    return merged2;
+  }
+  async retrieve(query, opts = {}) {
+    if (this.repos.length === 0) await this.open();
+    const profile = this.resolveProfile(opts);
+    const qVec = (await this.embedder.embed([query]))[0];
+    const vectorK = profile.candidates?.vectorK ?? Math.max(profile.k * 3, 30);
+    const lexicalK = profile.candidates?.lexicalK ?? Math.max(profile.k * 3, 30);
+    const maxMerged = profile.candidates?.maxMergedCandidates ?? Math.max(profile.k * 8, 120);
+    const repoFilters = opts.filters?.repoRoots;
+    const langFilter = opts.filters?.language;
+    const pathPrefix = opts.filters?.pathPrefix;
+    const candidates = [];
+    let vecCount = 0;
+    let lexCount = 0;
+    for (const repo of this.repos) {
+      if (repoFilters && !repoFilters.includes(repo.repoRoot)) continue;
+      let includePaths = opts.scope?.includePaths?.slice();
+      if (opts.scope?.changedOnly) {
+        try {
+          const changed = await listChangedFiles(repo.repoRoot, opts.scope.baseRef ?? "HEAD~1");
+          includePaths = includePaths ? includePaths.filter((p) => changed.includes(p)) : changed;
+        } catch {
+        }
+      }
+      const [vHits, lHits] = await Promise.all([
+        repo.vectorCandidates(qVec, vectorK, includePaths),
+        repo.lexicalCandidates(query, lexicalK, includePaths)
+      ]);
+      vecCount += vHits.length;
+      lexCount += lHits.length;
+      const m = /* @__PURE__ */ new Map();
+      for (const vh of vHits) {
+        const id = vh.id;
+        const vector01 = vectorCosineToScore01(vh.score);
+        m.set(id, { repo, id, vector01, combined: 0 });
+      }
+      for (const lh of lHits) {
+        const id = lh.id;
+        const prev = m.get(id);
+        if (prev) prev.lexical01 = lh.score;
+        else m.set(id, { repo, id, lexical01: lh.score, combined: 0 });
+      }
+      const halfLife = halfLifeDaysForProfile(profile.name);
+      for (const c of m.values()) {
+        const meta = repo.getChunkMeta(c.id);
+        if (!meta) continue;
+        if (langFilter && meta.language !== langFilter) continue;
+        if (pathPrefix && !meta.path.startsWith(pathPrefix)) continue;
+        c.recency01 = profile.weights.recency > 0 ? recencyScore(meta.fileMtimeMs, halfLife) : 0;
+        let kindFactor = 1;
+        if (meta.kind === "synopsis" && profile.name === "search") kindFactor = 0.85;
+        if (meta.kind === "synopsis" && profile.name === "architecture") kindFactor = 1.05;
+        const v = c.vector01 ?? 0;
+        const l = c.lexical01 ?? 0;
+        const r = c.recency01 ?? 0;
+        c.combined = clamp(
+          kindFactor * (profile.weights.vector * v + profile.weights.lexical * l + profile.weights.recency * r),
+          0,
+          1
+        );
+        candidates.push(c);
+      }
+    }
+    candidates.sort((a, b) => b.combined - a.combined);
+    const merged = candidates.slice(0, maxMerged);
+    const top = merged.slice(0, profile.k);
+    const hits = top.map((c) => {
+      const meta = c.repo.getChunkMeta(c.id);
+      const preview = makePreview(c.repo.getChunkText(c.id));
+      return {
+        score: c.combined,
+        scoreBreakdown: { vector: c.vector01, lexical: c.lexical01, recency: c.recency01 },
+        chunk: { ...meta, preview }
+      };
+    });
+    const contextBlocks = [];
+    const seenKey = /* @__PURE__ */ new Set();
+    const addBlock = (repoRoot, path11, startLine, endLine, text, reason) => {
+      const key = `${repoRoot}:${path11}:${startLine}:${endLine}:${text.length}:${reason}`;
+      if (seenKey.has(key)) return;
+      seenKey.add(key);
+      if (!text.trim()) return;
+      contextBlocks.push({ repoRoot, path: path11, startLine, endLine, text, reason });
+    };
+    for (const h of hits) {
+      const repo = this.repos.find((r) => r.repoRoot === h.chunk.repoRoot);
+      if (!repo) continue;
+      const text = repo.getChunkText(h.chunk.id);
+      addBlock(h.chunk.repoRoot, h.chunk.path, h.chunk.startLine, h.chunk.endLine, text, "primary hit");
+      const expanded = await repo.expandContext(h.chunk.id, {
+        adjacentChunks: profile.expand.adjacentChunks ?? 0,
+        followImports: profile.expand.followImports ?? 0,
+        includeFileSynopsis: profile.expand.includeFileSynopsis ?? false
+      });
+      for (const ex of expanded) {
+        const meta = repo.getChunkMeta(ex.id);
+        if (!meta) continue;
+        const t = repo.getChunkText(ex.id);
+        addBlock(meta.repoRoot, meta.path, meta.startLine, meta.endLine, t, ex.reason);
+      }
+    }
+    return {
+      hits,
+      context: contextBlocks,
+      stats: {
+        profile: profile.name,
+        reposSearched: this.repos.length,
+        candidates: {
+          vector: vecCount,
+          lexical: lexCount,
+          merged: merged.length,
+          returned: hits.length
+        }
+      }
+    };
+  }
+  async search(query, k = 10) {
+    const bundle = await this.retrieve(query, { profile: "search", profileOverrides: { k } });
+    return bundle.hits;
+  }
+  async closeAsync() {
+    for (const r of this.repos) {
+      await r.closeAsync().catch(() => void 0);
+    }
+    this.repos = [];
+  }
+  close() {
+    void this.closeAsync();
+  }
+};
+
+// src/embeddings/ollama.ts
+import pLimit2 from "p-limit";
+var OllamaEmbeddingsProvider = class {
+  id;
+  dimension = null;
+  baseUrl;
+  model;
+  concurrency;
+  constructor(opts) {
+    this.model = opts.model;
+    this.baseUrl = opts.baseUrl ?? "http://localhost:11434";
+    this.concurrency = opts.concurrency ?? 4;
+    this.id = `ollama:${this.model}`;
+  }
+  async tryBatchEndpoint(texts) {
+    const res = await fetch(`${this.baseUrl}/api/embed`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ model: this.model, input: texts })
+    }).catch(() => null);
+    if (!res || !res.ok) return null;
+    const json = await res.json();
+    const embeddings = json.embeddings;
+    if (!embeddings) return null;
+    const out = embeddings.map((v) => Float32Array.from(v));
+    if (out.length > 0) this.dimension = out[0].length;
+    return out;
+  }
+  async embedOne(text) {
+    const res = await fetch(`${this.baseUrl}/api/embeddings`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ model: this.model, prompt: text })
+    });
+    if (!res.ok) {
+      const errText = await res.text().catch(() => "");
+      throw new Error(`Ollama embeddings failed: ${res.status} ${res.statusText} ${errText}`);
+    }
+    const json = await res.json();
+    const emb = Float32Array.from(json.embedding);
+    this.dimension = emb.length;
+    return emb;
+  }
+  async embed(texts) {
+    const batch = await this.tryBatchEndpoint(texts);
+    if (batch) return batch;
+    const limit = pLimit2(this.concurrency);
+    const out = await Promise.all(texts.map((t) => limit(() => this.embedOne(t))));
+    return out;
+  }
+};
+
+// src/embeddings/openai.ts
+var OpenAIEmbeddingsProvider = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.id = `openai:${opts.model}`;
+  }
+  id;
+  dimension = null;
+  async embed(texts) {
+    const baseUrl = this.opts.baseUrl ?? "https://api.openai.com";
+    const res = await fetch(`${baseUrl}/v1/embeddings`, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${this.opts.apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        model: this.opts.model,
+        input: texts
+      })
+    });
+    if (!res.ok) {
+      const errText = await res.text().catch(() => "");
+      throw new Error(`OpenAI embeddings failed: ${res.status} ${res.statusText} ${errText}`);
+    }
+    const json = await res.json();
+    const arr = json.data.map((d) => Float32Array.from(d.embedding));
+    if (arr.length > 0) this.dimension = arr[0].length;
+    return arr;
+  }
+};
+
+// src/embeddings/hash.ts
+import crypto3 from "crypto";
+var HashEmbeddingsProvider = class {
+  id;
+  dimension;
+  constructor(dimension = 384) {
+    this.dimension = dimension;
+    this.id = `hash:${dimension}`;
+  }
+  async embed(texts) {
+    return texts.map((t) => this.embedOne(t));
+  }
+  embedOne(text) {
+    const v = new Float32Array(this.dimension);
+    const tokens = text.split(/[^A-Za-z0-9_]+/).filter(Boolean).slice(0, 6e3);
+    for (const tok of tokens) {
+      const h = crypto3.createHash("sha256").update(tok).digest();
+      const idx = h.readUInt32LE(0) % this.dimension;
+      const sign = h[4] & 1 ? 1 : -1;
+      v[idx] += sign;
+    }
+    let sumSq = 0;
+    for (let i = 0; i < v.length; i++) sumSq += v[i] * v[i];
+    const norm = Math.sqrt(sumSq) || 1;
+    for (let i = 0; i < v.length; i++) v[i] /= norm;
+    return v;
+  }
+};
+
+// src/config.ts
+import fs8 from "fs";
+import path10 from "path";
+function loadConfigFile(filePath) {
+  const abs = path10.resolve(filePath);
+  const raw = fs8.readFileSync(abs, "utf8");
+  const json = JSON.parse(raw);
+  const cfg = { ...json };
+  if (json.redact?.patterns && Array.isArray(json.redact.patterns)) {
+    const pats = json.redact.patterns;
+    cfg.redact = cfg.redact ?? {};
+    cfg.redact.patterns = pats.map((p) => {
+      if (p.regex instanceof RegExp) {
+        return { name: p.name, regex: p.regex, replaceWith: p.replaceWith };
+      }
+      return {
+        name: p.name,
+        regex: new RegExp(p.regex, p.flags ?? "g"),
+        replaceWith: p.replaceWith
+      };
+    });
+  }
+  return cfg;
+}
+
+export {
+  createVectorIndex,
+  RepoIndexer,
+  DEFAULT_PROFILES,
+  deepMergeProfile,
+  WorkspaceIndexer,
+  OllamaEmbeddingsProvider,
+  OpenAIEmbeddingsProvider,
+  HashEmbeddingsProvider,
+  loadConfigFile
+};