@noir-ai/context 1.0.0-beta.1

package/dist/index.js

@@ -0,0 +1,1182 @@
+// src/hash.ts
+import { createHash } from "crypto";
+function sha256Hex(text) {
+  return createHash("sha256").update(text, "utf8").digest("hex");
+}
+
+// src/chunker.ts
+var DEFAULT_CHUNK_MAX_TOKENS = 512;
+var DEFAULT_CHUNK_OVERLAP = 64;
+var TOKEN_ESTIMATE_FACTOR = 1.3;
+function explodeIdentifiers(text) {
+  const words = text.match(/[A-Za-z0-9]+/g);
+  if (!words) return "";
+  const tokens = [];
+  for (const word of words) {
+    const spaced = word.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2");
+    for (const piece of spaced.split(/\s+/)) {
+      if (piece.length > 0) tokens.push(piece.toLowerCase());
+    }
+  }
+  return tokens.join(" ");
+}
+function withIdentifierExplosion(content) {
+  const exploded = explodeIdentifiers(content);
+  return exploded.length > 0 ? `${content}
+${exploded}` : content;
+}
+function estimateTokens(text) {
+  const trimmed = text.trim();
+  if (trimmed.length === 0) return 0;
+  const words = trimmed.split(/\s+/).filter((w) => w.length > 0);
+  return Math.ceil(words.length * TOKEN_ESTIMATE_FACTOR);
+}
+var EXT_TO_LANGUAGE = {
+  ts: "typescript",
+  tsx: "tsx",
+  mts: "typescript",
+  cts: "typescript",
+  js: "javascript",
+  jsx: "jsx",
+  mjs: "javascript",
+  cjs: "javascript",
+  md: "markdown",
+  mdx: "markdown",
+  py: "python",
+  rb: "ruby",
+  rs: "rust",
+  go: "go",
+  java: "java",
+  kt: "kotlin",
+  json: "json",
+  yml: "yaml",
+  yaml: "yaml",
+  toml: "toml",
+  sh: "shell",
+  bash: "shell",
+  zsh: "shell",
+  sql: "sql",
+  html: "html",
+  htm: "html",
+  css: "css",
+  scss: "scss",
+  xml: "xml",
+  txt: "text"
+};
+function inferLanguage(path) {
+  const ext = path.toLowerCase().match(/\.([a-z0-9]+)$/)?.[1];
+  if (!ext) return "text";
+  return EXT_TO_LANGUAGE[ext] ?? "text";
+}
+function isMarkdown(path, language) {
+  if (language === "markdown") return true;
+  return /\.(md|mdx)$/i.test(path);
+}
+function defaultSource(path, language) {
+  return isMarkdown(path, language) ? "docs" : "codebase";
+}
+function parentDocIdOf(path) {
+  return sha256Hex(path);
+}
+function chunkSha256(content) {
+  return sha256Hex(withIdentifierExplosion(content));
+}
+var ATX_HEADING = /^(#{1,6})\s/;
+var FENCE_OPEN = /^\s*(`{3,}|~{3,})/;
+function markdownSections(content) {
+  const lines = content.split("\n");
+  const sections = [];
+  let current = [];
+  let inFence = false;
+  let fenceMarker = "";
+  const flush = () => {
+    if (current.length === 0) return;
+    const body = current.join("\n").replace(/\s+$/, "");
+    if (body.length > 0) sections.push(body);
+    current = [];
+  };
+  for (const line of lines) {
+    const fence = FENCE_OPEN.exec(line);
+    if (fence && fence[1]) {
+      const marker = fence[1].charAt(0);
+      if (!inFence) {
+        inFence = true;
+        fenceMarker = marker;
+      } else if (marker === fenceMarker) {
+        inFence = false;
+        fenceMarker = "";
+      }
+      current.push(line);
+      continue;
+    }
+    if (!inFence && ATX_HEADING.test(line)) {
+      flush();
+      current = [line];
+    } else {
+      current.push(line);
+    }
+  }
+  flush();
+  return sections;
+}
+function codeWindows(content, maxTokens, overlap) {
+  const lines = content.split("\n");
+  const n = lines.length;
+  if (n === 0) return [];
+  const windows = [];
+  let start = 0;
+  let safety = 2 * n + 8;
+  while (start < n && safety > 0) {
+    safety -= 1;
+    let end = start;
+    let body = "";
+    for (let i = start; i < n; i++) {
+      const line = lines[i];
+      if (line === void 0) break;
+      const trial = body.length === 0 ? line : `${body}
+${line}`;
+      if (i > start && estimateTokens(trial) > maxTokens) break;
+      body = trial;
+      end = i + 1;
+    }
+    if (body.length > 0) windows.push(body);
+    if (end >= n) break;
+    if (end - 1 <= start) {
+      start = end;
+      continue;
+    }
+    let carryStart = end - 1;
+    let carried = 0;
+    while (carryStart > start && carried < overlap) {
+      const line = lines[carryStart];
+      if (line === void 0) {
+        carryStart -= 1;
+        continue;
+      }
+      carried += estimateTokens(line);
+      if (carried >= overlap) break;
+      carryStart -= 1;
+    }
+    if (carryStart <= start) carryStart = start + 1;
+    if (carryStart > end - 1) carryStart = end - 1;
+    start = carryStart;
+  }
+  return windows;
+}
+function chunkFile(opts) {
+  const { path, content } = opts;
+  if (content.trim().length === 0) return [];
+  const language = opts.language ?? inferLanguage(path);
+  const source = opts.source ?? defaultSource(path, language);
+  const maxTokens = opts.maxTokens ?? DEFAULT_CHUNK_MAX_TOKENS;
+  const overlap = opts.overlap ?? DEFAULT_CHUNK_OVERLAP;
+  const parentDocId = parentDocIdOf(path);
+  const bodies = isMarkdown(path, language) ? markdownSections(content) : codeWindows(content, maxTokens, overlap);
+  const chunks = [];
+  for (let i = 0; i < bodies.length; i++) {
+    const body = bodies[i];
+    if (body === void 0 || body.length === 0) continue;
+    chunks.push({
+      id: `${parentDocId}#chunk-${i}`,
+      source,
+      content: body,
+      meta: {
+        path,
+        parentDocId,
+        chunkIndex: i,
+        language,
+        sha256: chunkSha256(body)
+      }
+    });
+  }
+  return chunks;
+}
+
+// src/config.ts
+function apiKeyEnvVar(provider) {
+  switch (provider) {
+    case "openai":
+      return process.env.OPENAI_API_KEY;
+    case "voyage":
+      return process.env.VOYAGE_API_KEY;
+    case "cohere":
+      return process.env.COHERE_API_KEY;
+    default:
+      return void 0;
+  }
+}
+function resolveEmbedderConfig(ctx) {
+  const e = ctx?.embedder;
+  switch (e?.kind) {
+    case "local": {
+      const model = e?.model;
+      return { kind: "local", ...model ? { model } : {} };
+    }
+    case "remote": {
+      const provider = e?.provider ?? "openai";
+      const model = e?.model ?? "";
+      const dim = e?.dim ?? 384;
+      const apiKey = apiKeyEnvVar(provider);
+      return { kind: "remote", provider, model, dim, ...apiKey ? { apiKey } : {} };
+    }
+    case "ollama": {
+      const baseURL = e?.baseURL ?? process.env.OLLAMA_BASE_URL ?? "";
+      const model = e?.model ?? "";
+      return { kind: "ollama", baseURL, model };
+    }
+    case "none":
+      return { kind: "none" };
+    default:
+      return { kind: "local" };
+  }
+}
+
+// src/embedders/local.ts
+import { mkdirSync } from "fs";
+import { modelsDir } from "@noir-ai/core";
+
+// src/embedders/normalize.ts
+var EMBED_DIM = 384;
+function l2normalize(vec) {
+  const n = vec.length;
+  if (n === 0) return new Float32Array(0);
+  let sum = 0;
+  for (let i = 0; i < n; i++) {
+    const v = vec[i];
+    if (v !== void 0) sum += v * v;
+  }
+  const norm = Math.sqrt(sum);
+  if (norm === 0 || !Number.isFinite(norm)) {
+    return new Float32Array(n);
+  }
+  const out = new Float32Array(n);
+  const inv = 1 / norm;
+  for (let i = 0; i < n; i++) {
+    const v = vec[i];
+    if (v !== void 0) out[i] = v * inv;
+  }
+  return out;
+}
+
+// src/embedders/local.ts
+var DEFAULT_LOCAL_MODEL = "Xenova/all-MiniLM-L6-v2";
+var MODELS_DIR = modelsDir();
+var pipelineCache = /* @__PURE__ */ new Map();
+async function loadPipeline(model) {
+  try {
+    const mod = await import("@huggingface/transformers");
+    mkdirSync(MODELS_DIR, { recursive: true });
+    mod.env.cacheDir = MODELS_DIR;
+    const extractor = await mod.pipeline("feature-extraction", model);
+    return async (text) => {
+      const out = await extractor(text, { pooling: "mean" });
+      const dim = out.dims.at(-1) ?? EMBED_DIM;
+      const raw = new Float32Array(dim);
+      for (let i = 0; i < dim; i++) raw[i] = out.data[i] ?? 0;
+      return l2normalize(raw);
+    };
+  } catch (e) {
+    const reason = e instanceof Error ? e.message : String(e);
+    throw new Error(
+      `local embedder: failed to load model "${model}" (is @huggingface/transformers installed and the onnxruntime native binary present?): ${reason}`
+    );
+  }
+}
+function getEmbedder(model) {
+  const cached = pipelineCache.get(model);
+  if (cached) return cached;
+  const promise = loadPipeline(model).catch((e) => {
+    pipelineCache.delete(model);
+    throw e;
+  });
+  pipelineCache.set(model, promise);
+  return promise;
+}
+function localEmbedder(opts = {}) {
+  const model = opts.model ?? DEFAULT_LOCAL_MODEL;
+  return {
+    model,
+    embed: async (text) => {
+      const run = await getEmbedder(model);
+      return run(text);
+    }
+  };
+}
+
+// src/embedders/ollama.ts
+async function readErrorBody(res) {
+  try {
+    const text = await res.text();
+    return text.slice(0, 500);
+  } catch {
+    return "<unreadable response body>";
+  }
+}
+function ollamaEmbedder(opts) {
+  const targetDim = opts.dim ?? EMBED_DIM;
+  const base = opts.baseURL.replace(/\/+$/, "");
+  return async (text) => {
+    if (!opts.baseURL) {
+      throw new Error(
+        "ollama embedder is not configured: baseURL is required (set context.embedder.baseURL, e.g. http://localhost:11434)"
+      );
+    }
+    const res = await fetch(`${base}/api/embeddings`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ model: opts.model, prompt: text })
+    });
+    if (!res.ok) {
+      const detail = await readErrorBody(res);
+      throw new Error(
+        `ollama embedder request failed (${res.status} ${res.statusText}): ${detail}`
+      );
+    }
+    const json = await res.json();
+    const vec = json.embedding ?? [];
+    if (vec.length < targetDim) {
+      throw new Error(
+        `ollama model "${opts.model}" returned a ${vec.length}-dim vector (shorter than the required ${targetDim}); choose a >= ${targetDim}-dim model (e.g. nomic-embed-text)`
+      );
+    }
+    const truncated = vec.length > targetDim ? Float32Array.from(vec.slice(0, targetDim)) : Float32Array.from(vec);
+    return l2normalize(truncated);
+  };
+}
+
+// src/embedders/remote.ts
+var OPENAI_DEFAULT = "https://api.openai.com/v1/embeddings";
+var ENDPOINTS = {
+  openai: OPENAI_DEFAULT,
+  voyage: "https://api.voyageai.com/v1/embeddings",
+  cohere: "https://api.cohere.com/v2/embed"
+};
+function buildRequestBody(provider, model, text) {
+  switch (provider) {
+    case "voyage":
+      return JSON.stringify({ model, inputs: [text] });
+    case "cohere":
+      return JSON.stringify({
+        model,
+        texts: [text],
+        input_type: "search_document",
+        embedding_types: ["float"]
+      });
+    case "openai":
+    default:
+      return JSON.stringify({ model, input: text });
+  }
+}
+function extractVector(json, provider) {
+  if (provider === "cohere") {
+    const vec = json.embeddings?.float?.[0];
+    return vec ?? [];
+  }
+  return json.data?.[0]?.embedding ?? [];
+}
+async function readErrorBody2(res) {
+  try {
+    const text = await res.text();
+    return text.slice(0, 500);
+  } catch {
+    return "<unreadable response body>";
+  }
+}
+function remoteEmbedder(opts) {
+  const targetDim = opts.dim ?? EMBED_DIM;
+  const endpoint = ENDPOINTS[opts.provider] ?? OPENAI_DEFAULT;
+  return async (text) => {
+    if (!opts.apiKey) {
+      throw new Error(
+        `remote embedder "${opts.provider}" is not configured: apiKey is required (set context.embedder.apiKey or the matching provider env var)`
+      );
+    }
+    const res = await fetch(endpoint, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${opts.apiKey}`
+      },
+      body: buildRequestBody(opts.provider, opts.model, text)
+    });
+    if (!res.ok) {
+      const detail = await readErrorBody2(res);
+      throw new Error(
+        `remote embedder "${opts.provider}" request failed (${res.status} ${res.statusText}): ${detail}`
+      );
+    }
+    const json = await res.json();
+    const vec = extractVector(json, opts.provider);
+    if (vec.length < targetDim) {
+      throw new Error(
+        `remote embedder "${opts.provider}" returned a ${vec.length}-dim vector (shorter than the required ${targetDim}); choose a >= ${targetDim}-dim model`
+      );
+    }
+    const truncated = vec.length > targetDim ? Float32Array.from(vec.slice(0, targetDim)) : Float32Array.from(vec);
+    return l2normalize(truncated);
+  };
+}
+
+// src/embedders/fake.ts
+import { createHash as createHash2 } from "crypto";
+function fakeEmbedFn(dim = EMBED_DIM) {
+  return (text) => {
+    const hash = createHash2("sha256").update(text, "utf8").digest();
+    const raw = new Float32Array(dim);
+    for (let i = 0; i < dim; i++) {
+      const byte = hash[i % hash.length];
+      if (byte !== void 0) raw[i] = (byte - 128) / 128;
+    }
+    return Promise.resolve(l2normalize(raw));
+  };
+}
+
+// src/embedders/index.ts
+function createEmbedFn(cfg) {
+  switch (cfg.kind) {
+    case "local": {
+      const { embed, model } = localEmbedder({ model: cfg.model });
+      return { embed, info: { kind: "local", model, dim: EMBED_DIM } };
+    }
+    case "remote": {
+      const embed = remoteEmbedder({
+        provider: cfg.provider,
+        apiKey: cfg.apiKey,
+        model: cfg.model,
+        dim: cfg.dim
+      });
+      return { embed, info: { kind: "remote", model: cfg.model, dim: cfg.dim } };
+    }
+    case "ollama": {
+      const embed = ollamaEmbedder({ baseURL: cfg.baseURL, model: cfg.model });
+      return { embed, info: { kind: "ollama", model: cfg.model, dim: EMBED_DIM } };
+    }
+    case "none": {
+      const embed = async () => {
+        throw new Error('embedder disabled (kind:"none"); search degrades to BM25-only');
+      };
+      return { embed, info: { kind: "none", dim: 0 } };
+    }
+  }
+}
+
+// src/indexer.ts
+import { readdir, readFile, stat } from "fs/promises";
+import { join, relative, resolve, sep } from "path";
+var CTX_REGISTRY_KEY = "ctx:registry";
+var CTX_EMBEDDER_KEY = "ctx:embedder";
+var CTX_FILE_PREFIX = "ctx:file:";
+function ctxFileKey(pathKey) {
+  return `${CTX_FILE_PREFIX}${pathKey}`;
+}
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  ".git",
+  ".hg",
+  ".svn",
+  ".noir",
+  "node_modules",
+  "bower_components",
+  "dist",
+  "build",
+  "out",
+  ".next",
+  ".nuxt",
+  ".turbo",
+  ".cache",
+  "coverage",
+  ".nyc_output",
+  ".venv",
+  "venv",
+  "env",
+  "__pycache__",
+  ".mypy_cache",
+  ".pytest_cache",
+  ".idea",
+  ".vscode"
+]);
+var BINARY_EXTS = /* @__PURE__ */ new Set([
+  // Images
+  "png",
+  "jpg",
+  "jpeg",
+  "gif",
+  "webp",
+  "ico",
+  "bmp",
+  "tif",
+  "tiff",
+  "svgz",
+  "heic",
+  "avif",
+  // Audio / video
+  "mp3",
+  "mp4",
+  "mov",
+  "avi",
+  "mkv",
+  "flac",
+  "wav",
+  "ogg",
+  "webm",
+  "aac",
+  "m4a",
+  // Archives
+  "zip",
+  "gz",
+  "tar",
+  "tgz",
+  "br",
+  "lz",
+  "lzma",
+  "7z",
+  "rar",
+  "bz2",
+  // Documents (binary)
+  "pdf",
+  "doc",
+  "docx",
+  "xls",
+  "xlsx",
+  "ppt",
+  "pptx",
+  // Compiled / native
+  "wasm",
+  "exe",
+  "dll",
+  "so",
+  "dylib",
+  "a",
+  "o",
+  "obj",
+  "lib",
+  "class",
+  "jar",
+  "war",
+  "pyc",
+  "pyo",
+  "pyd",
+  // ML / model artifacts
+  "onnx",
+  "pickle",
+  "pt",
+  "bin",
+  // Databases / locks
+  "db",
+  "sqlite",
+  "sqlite3",
+  "db-shm",
+  "db-wal",
+  "lock",
+  // Fonts
+  "ttf",
+  "otf",
+  "woff",
+  "woff2",
+  "eot"
+]);
+function isBinaryExt(pathOrName) {
+  const m = pathOrName.toLowerCase().match(/\.([a-z0-9]+)$/);
+  if (!m || !m[1]) return false;
+  return BINARY_EXTS.has(m[1]);
+}
+var SENSITIVE_NAMES = /* @__PURE__ */ new Set([
+  ".env",
+  ".npmrc",
+  ".pypirc",
+  ".git-credentials",
+  ".netrc",
+  ".ds_store",
+  "thumbs.db"
+]);
+var SENSITIVE_PREFIXES = [".env.", "id_rsa", "id_ed25519"];
+var SENSITIVE_SUFFIXES = [".pem", ".key", ".secret", ".p12", ".pfx", ".local"];
+var SENSITIVE_PATHS = [".aws/credentials"];
+function isSensitive(name) {
+  const lower = name.toLowerCase();
+  for (const p of SENSITIVE_PATHS) {
+    if (lower === p || lower.endsWith(`/${p}`)) return true;
+  }
+  const base = lower.slice(lower.lastIndexOf("/") + 1);
+  if (SENSITIVE_NAMES.has(base)) return true;
+  for (const pf of SENSITIVE_PREFIXES) {
+    if (base.startsWith(pf)) return true;
+  }
+  for (const sf of SENSITIVE_SUFFIXES) {
+    if (base.endsWith(sf)) return true;
+  }
+  return false;
+}
+function posix(p) {
+  return sep === "/" ? p : p.split(sep).join("/");
+}
+function createIndexer(opts) {
+  const { store, embed, info } = opts;
+  const base = opts.root ?? process.cwd();
+  let chain = Promise.resolve();
+  function serialized(work) {
+    const result = chain.then(work);
+    chain = result.then(
+      () => void 0,
+      () => void 0
+    );
+    return result;
+  }
+  const resolveAbs = (p) => resolve(base, p);
+  const toKey = (abs) => opts.root ? relative(opts.root, abs) : abs;
+  const keyAbs = (key) => posix(resolve(base, key));
+  function isWithinRoot(abs) {
+    const r = resolve(base);
+    const a = resolve(abs);
+    return a === r || a.startsWith(`${r}${sep}`);
+  }
+  function deleteChunks(ids) {
+    for (const id of ids) {
+      store.deleteDoc(id);
+      store.deleteVec(id);
+    }
+  }
+  function loadRecords() {
+    const registry = store.getState(CTX_REGISTRY_KEY) ?? [];
+    const records = /* @__PURE__ */ new Map();
+    for (const p of registry) {
+      const rec = store.getState(ctxFileKey(p));
+      if (rec) records.set(p, rec);
+    }
+    return records;
+  }
+  function persist(records, tombstones) {
+    store.setState(CTX_REGISTRY_KEY, [...records.keys()].sort());
+    for (const [key, rec] of records) store.setState(ctxFileKey(key), rec);
+    for (const key of tombstones) store.setState(ctxFileKey(key), null);
+  }
+  function recordEmbedder() {
+    const prev = store.getState(CTX_EMBEDDER_KEY);
+    if (prev === null) {
+      store.setState(CTX_EMBEDDER_KEY, info);
+      return;
+    }
+    if (!sameEmbedder(prev, info)) {
+      console.warn(
+        `[noir-context] embedder changed (${describeEmbedder(prev)} \u2192 ${describeEmbedder(info)}); existing vectors may be stale \u2014 call reindex() to refresh`
+      );
+      store.setState(CTX_EMBEDDER_KEY, info);
+    }
+  }
+  async function walk(rootAbs) {
+    const out = [];
+    const stack = [rootAbs];
+    while (stack.length > 0) {
+      const dir = stack.pop();
+      if (dir === void 0) break;
+      let entries;
+      try {
+        entries = await readdir(dir, { withFileTypes: true });
+      } catch {
+        continue;
+      }
+      for (const ent of entries) {
+        if (ent.isDirectory()) {
+          if (SKIP_DIRS.has(ent.name)) continue;
+          stack.push(join(dir, ent.name));
+        } else if (ent.isFile()) {
+          out.push(join(dir, ent.name));
+        }
+      }
+    }
+    return out;
+  }
+  function inScope(absKey, absRoots) {
+    for (const r of absRoots) {
+      const rp = posix(r);
+      if (absKey === rp || absKey.startsWith(`${rp}/`)) return true;
+    }
+    return false;
+  }
+  async function indexPaths(inputPaths, o) {
+    recordEmbedder();
+    const records = loadRecords();
+    const absRoots = [];
+    const scanned = /* @__PURE__ */ new Map();
+    for (const input of inputPaths) {
+      const abs = resolveAbs(input);
+      if (!isWithinRoot(abs)) continue;
+      const st = await stat(abs).catch(() => null);
+      if (st === null) continue;
+      if (st.isDirectory()) {
+        absRoots.push(abs);
+        for (const file of await walk(abs)) {
+          if (!isWithinRoot(file)) continue;
+          scanned.set(posix(toKey(file)), file);
+        }
+      } else if (st.isFile()) {
+        absRoots.push(abs);
+        scanned.set(posix(toKey(abs)), abs);
+      }
+    }
+    let indexed = 0;
+    let skipped = 0;
+    let failed = 0;
+    let deleted = 0;
+    let embedDisabled = info.kind === "none";
+    const tombstones = [];
+    const tryEmbed = async (content) => {
+      if (embedDisabled) return null;
+      try {
+        return await embed(content);
+      } catch {
+        embedDisabled = true;
+        return null;
+      }
+    };
+    for (const key of [...records.keys()]) {
+      if (scanned.has(key)) continue;
+      if (!inScope(keyAbs(key), absRoots)) continue;
+      const rec = records.get(key);
+      if (rec) deleteChunks(rec.chunkIds);
+      records.delete(key);
+      tombstones.push(key);
+      deleted += 1;
+    }
+    for (const [key, abs] of scanned) {
+      if (isBinaryExt(key)) {
+        failed += 1;
+        continue;
+      }
+      if (isSensitive(key)) {
+        failed += 1;
+        continue;
+      }
+      let content;
+      try {
+        content = await readFile(abs, "utf8");
+      } catch {
+        failed += 1;
+        continue;
+      }
+      if (content.includes(String.fromCharCode(0))) {
+        failed += 1;
+        continue;
+      }
+      const fileHash = sha256Hex(content);
+      const prev = records.get(key);
+      if (prev !== void 0 && prev.sha256 === fileHash) {
+        skipped += prev.chunkIds.length;
+        continue;
+      }
+      if (prev !== void 0) deleteChunks(prev.chunkIds);
+      const chunks = chunkFile({
+        path: key,
+        content,
+        source: o?.source,
+        maxTokens: o?.maxTokens,
+        overlap: o?.overlap
+      });
+      const chunkIds = [];
+      let language = inferLanguage(key);
+      for (const chunk of chunks) {
+        const indexedContent = withIdentifierExplosion(chunk.content);
+        store.indexDoc({
+          id: chunk.id,
+          source: chunk.source,
+          content: indexedContent,
+          meta: chunk.meta
+        });
+        language = chunk.meta.language;
+        const vec = await tryEmbed(indexedContent);
+        if (vec !== null) {
+          store.upsertVec(chunk.id, vec, { source: chunk.source });
+        }
+        chunkIds.push(chunk.id);
+        indexed += 1;
+      }
+      records.set(key, { sha256: fileHash, chunkIds, language });
+    }
+    persist(records, tombstones);
+    let totalChunks = 0;
+    for (const rec of records.values()) totalChunks += rec.chunkIds.length;
+    return {
+      indexed,
+      skipped,
+      deleted,
+      failed,
+      totalChunks,
+      // `degraded` is truthful about "docs indexed without vectors": only set
+      // when embedding was off AND at least one doc went in without one.
+      degraded: embedDisabled && indexed > 0
+    };
+  }
+  async function forget(inputPaths) {
+    const records = loadRecords();
+    const targets = inputPaths.map((p) => posix(resolveAbs(p)));
+    const tombstones = [];
+    for (const key of [...records.keys()]) {
+      const abs = keyAbs(key);
+      const hit = targets.some((t) => abs === t || abs.startsWith(`${t}/`));
+      if (!hit) continue;
+      const rec = records.get(key);
+      if (rec) deleteChunks(rec.chunkIds);
+      records.delete(key);
+      tombstones.push(key);
+    }
+    persist(records, tombstones);
+    let totalChunks = 0;
+    for (const rec of records.values()) totalChunks += rec.chunkIds.length;
+    return { deleted: tombstones.length, totalChunks };
+  }
+  async function reindex() {
+    const registry = store.getState(CTX_REGISTRY_KEY) ?? [];
+    const tombstones = [];
+    for (const key of registry) {
+      const rec = store.getState(ctxFileKey(key));
+      if (rec) deleteChunks(rec.chunkIds);
+      tombstones.push(key);
+    }
+    persist(/* @__PURE__ */ new Map(), tombstones);
+    return indexPaths(registry);
+  }
+  return {
+    indexPaths: (inputPaths, o) => serialized(() => indexPaths(inputPaths, o)),
+    forget: (inputPaths) => serialized(() => forget(inputPaths)),
+    reindex: () => serialized(reindex)
+  };
+}
+function sameEmbedder(a, b) {
+  return a.kind === b.kind && a.model === b.model && a.dim === b.dim;
+}
+function describeEmbedder(e) {
+  return e.model ? `${e.kind}:${e.model}(${e.dim})` : `${e.kind}(${e.dim})`;
+}
+
+// src/rrf.ts
+var DEFAULT_RRF_K = 60;
+var DEFAULT_RRF_WEIGHTS = [0.5, 0.5];
+function rankMap(list) {
+  const map = /* @__PURE__ */ new Map();
+  for (const [i, hit] of list.entries()) {
+    if (map.has(hit.id)) continue;
+    map.set(hit.id, { rank: i + 1, source: hit.source });
+  }
+  return map;
+}
+function fuseRrf(bm25, knn, opts) {
+  const k = opts?.k ?? DEFAULT_RRF_K;
+  const [wBm25, wKnn] = opts?.weights ?? DEFAULT_RRF_WEIGHTS;
+  const bm25Ranks = rankMap(bm25);
+  const knnRanks = rankMap(knn);
+  const seen = /* @__PURE__ */ new Set();
+  const orderedIds = [];
+  for (const hit of bm25) {
+    if (!seen.has(hit.id)) {
+      seen.add(hit.id);
+      orderedIds.push(hit.id);
+    }
+  }
+  for (const hit of knn) {
+    if (!seen.has(hit.id)) {
+      seen.add(hit.id);
+      orderedIds.push(hit.id);
+    }
+  }
+  const entries = orderedIds.map((id, order) => {
+    const bm = bm25Ranks.get(id);
+    const kn = knnRanks.get(id);
+    const rankBm25 = bm?.rank;
+    const rankKnn = kn?.rank;
+    const score = (rankBm25 != null ? wBm25 / (k + rankBm25) : 0) + (rankKnn != null ? wKnn / (k + rankKnn) : 0);
+    const minRank = Math.min(
+      rankBm25 ?? Number.POSITIVE_INFINITY,
+      rankKnn ?? Number.POSITIVE_INFINITY
+    );
+    const source = bm?.source ?? kn?.source ?? "";
+    return { id, source, score, minRank, order };
+  });
+  entries.sort((a, b) => {
+    if (a.score !== b.score) return b.score - a.score;
+    if (a.minRank !== b.minRank) return a.minRank - b.minRank;
+    return a.order - b.order;
+  });
+  return entries.map(({ id, source, score }) => ({ id, source, score }));
+}
+
+// src/retriever.ts
+var DEFAULT_SEARCH_LIMIT = 10;
+var DEFAULT_BUDGET_TOKENS = 4096;
+var DEFAULT_SNIPPET_WINDOW_TOKENS = 16;
+function asChunkMeta(meta) {
+  if (typeof meta !== "object" || meta === null) return void 0;
+  const m = meta;
+  const path = m["path"];
+  const parentDocId = m["parentDocId"];
+  if (typeof path !== "string" || typeof parentDocId !== "string") {
+    return void 0;
+  }
+  const chunkIndex = m["chunkIndex"];
+  const language = m["language"];
+  const sha256Val = m["sha256"];
+  return {
+    path,
+    parentDocId,
+    chunkIndex: typeof chunkIndex === "number" ? chunkIndex : 0,
+    language: typeof language === "string" ? language : "text",
+    // ChunkMeta.sha256 is required (the indexer always writes it); for a
+    // foreign/legacy row that lacks it, fall back to '' rather than crash.
+    sha256: typeof sha256Val === "string" ? sha256Val : ""
+  };
+}
+function toRetrieverMeta(meta) {
+  if (!meta) return {};
+  const out = {};
+  if (meta.language) out.language = meta.language;
+  if (meta.sha256) out.sha256 = meta.sha256;
+  out.chunkIndex = meta.chunkIndex;
+  return out;
+}
+function asSourceKind(source) {
+  switch (source) {
+    case "codebase":
+    case "docs":
+    case "spec":
+    case "memory":
+      return source;
+    default:
+      return "codebase";
+  }
+}
+function queryTermSet(query) {
+  const terms = query.toLowerCase().match(/[a-z0-9]+/g);
+  return terms ? new Set(terms) : /* @__PURE__ */ new Set();
+}
+function windowSnippet(content, query, windowTokens) {
+  const trimmed = content.trim();
+  if (trimmed.length === 0) return "";
+  const terms = queryTermSet(query);
+  const words = trimmed.split(/\s+/);
+  const slice = words.slice(0, Math.max(1, windowTokens));
+  return slice.map((w) => {
+    const core = w.toLowerCase().match(/[a-z0-9]+/)?.[0];
+    if (core && terms.has(core)) return `<<${w}>>`;
+    return w;
+  }).join(" ").concat(words.length > slice.length ? " \u2026" : "");
+}
+function collapseByParent(hits) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const hit of hits) {
+    const key = hit.parentDocId || hit.id;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(hit);
+  }
+  return out;
+}
+function packBudget(hits, budgetTokens) {
+  let consumed = 0;
+  const packed = [];
+  for (const hit of hits) {
+    const tokens = estimateTokens(hit.snippet);
+    if (packed.length > 0 && consumed + tokens > budgetTokens) {
+      return { hits: packed, consumedTokens: consumed, truncated: true };
+    }
+    packed.push(hit);
+    consumed += tokens;
+  }
+  return { hits: packed, consumedTokens: consumed, truncated: false };
+}
+function createRetriever(deps) {
+  const { store, embed } = deps;
+  const k = deps.opts?.k ?? DEFAULT_RRF_K;
+  const weights = deps.opts?.weights;
+  const defaultBudget = deps.opts?.budgetTokens ?? DEFAULT_BUDGET_TOKENS;
+  const snippetWindowTokens = deps.opts?.snippetWindowTokens ?? DEFAULT_SNIPPET_WINDOW_TOKENS;
+  const readDoc = deps.opts?.readDoc;
+  return {
+    async search(query, opts) {
+      const limit = opts?.limit ?? DEFAULT_SEARCH_LIMIT;
+      const budgetTokens = opts?.budgetTokens ?? defaultBudget;
+      const source = opts?.source;
+      let ftsHits = [];
+      let ftsFailed = false;
+      try {
+        ftsHits = store.searchFt(query, { limit, source });
+      } catch {
+        ftsFailed = true;
+      }
+      let knnHits = [];
+      let knnFailed = false;
+      try {
+        const qvec = await embed(query);
+        try {
+          knnHits = store.knn(qvec, { limit, source });
+        } catch {
+          knnFailed = true;
+        }
+      } catch {
+        knnFailed = true;
+      }
+      const mode = knnFailed ? "bm25-only" : "hybrid";
+      const degraded = knnFailed || ftsFailed;
+      const fused = fuseRrf(ftsHits, knnHits, { k, weights });
+      const ftsById = /* @__PURE__ */ new Map();
+      for (const h of ftsHits) {
+        if (!ftsById.has(h.id)) ftsById.set(h.id, h);
+      }
+      const enriched = fused.map((row) => {
+        const fts = ftsById.get(row.id);
+        if (fts) {
+          const meta = asChunkMeta(fts.meta);
+          return {
+            id: row.id,
+            source: asSourceKind(row.source),
+            score: row.score,
+            snippet: fts.snippet,
+            path: meta?.path ?? "",
+            parentDocId: meta?.parentDocId ?? "",
+            meta: toRetrieverMeta(meta)
+          };
+        }
+        if (readDoc) {
+          const doc = readDoc(row.id);
+          if (doc) {
+            const meta = asChunkMeta(doc.meta);
+            return {
+              id: row.id,
+              source: asSourceKind(row.source),
+              score: row.score,
+              snippet: windowSnippet(doc.content, query, snippetWindowTokens),
+              path: meta?.path ?? "",
+              parentDocId: meta?.parentDocId ?? "",
+              meta: toRetrieverMeta(meta)
+            };
+          }
+        }
+        return {
+          id: row.id,
+          source: asSourceKind(row.source),
+          score: row.score,
+          snippet: "",
+          path: "",
+          parentDocId: "",
+          meta: {}
+        };
+      });
+      const collapsed = collapseByParent(enriched);
+      const packed = packBudget(collapsed, budgetTokens);
+      return {
+        results: packed.hits,
+        consumedTokens: packed.consumedTokens,
+        truncated: packed.truncated,
+        degraded,
+        mode
+      };
+    }
+  };
+}
+
+// src/contextEngine.ts
+var ContextEngine = class {
+  /** The daemon's single-writer store handle (possibly read-only). */
+  store;
+  /** Project root (paths resolve against this). */
+  root;
+  /** Canonical project identifier. */
+  projectId;
+  /** Description of the active embedder (surfaced by `status()`). */
+  embedder;
+  /**
+   * Persistent degradation flag (read-only store OR `kind:'none'`). Per-query
+   * degradation lives on {@link SearchResult}.
+   */
+  degraded;
+  indexer;
+  retriever;
+  constructor(opts) {
+    this.store = opts.store;
+    this.root = opts.root;
+    this.projectId = opts.projectId;
+    const { embed, info } = createEmbedFn(opts.embedderCfg);
+    this.embedder = info;
+    this.degraded = opts.storeDegraded === true || info.kind === "none";
+    this.indexer = createIndexer({ store: opts.store, embed, info, root: opts.root });
+    this.retriever = createRetriever({ store: opts.store, embed });
+  }
+  /**
+   * Incrementally index `paths` (files or directories) into the store. Delegates
+   * to the indexer (spec F1/F3/F4). The engine — through the indexer — is the
+   * ONLY context writer; the daemon stays the single writer via this handle.
+   */
+  indexPaths(paths, opts) {
+    return this.indexer.indexPaths(paths, opts);
+  }
+  /**
+   * Hybrid search: BM25 ∪ cosine-kNN fused by RRF (k=60), collapsed by
+   * parent-doc, packed to a token budget with window-extracted snippets (spec
+   * F6/F7). Delegates to the retriever. The per-call `degraded`/`mode` on the
+   * returned {@link SearchResult} reflect THIS query's outcome (independent of
+   * the engine's persistent {@link degraded}).
+   */
+  search(query, opts) {
+    return this.retriever.search(query, opts);
+  }
+  /**
+   * Snapshot the engine's state (spec F11; mirrors `buildStoreStatus`).
+   *
+   * `docCount`/`vecCount` are live reads off the single writer handle (no
+   * cache); `indexedFiles` is the size of the `ctx:registry` KV list maintained
+   * by the indexer; `embedder` describes the active provider; `degraded` is the
+   * persistent flag (read-only store OR `kind:'none'`).
+   */
+  status() {
+    const registry = this.store.getState(CTX_REGISTRY_KEY) ?? [];
+    return {
+      ok: true,
+      projectId: this.store.projectId,
+      docCount: this.store.countDocs(),
+      vecCount: this.store.countVecs(),
+      indexedFiles: registry.length,
+      embedder: this.embedder,
+      degraded: this.degraded
+    };
+  }
+};
+
+// src/types.ts
+var SOURCES = ["codebase", "docs", "spec", "memory"];
+export {
+  CTX_EMBEDDER_KEY,
+  CTX_FILE_PREFIX,
+  CTX_REGISTRY_KEY,
+  ContextEngine,
+  DEFAULT_BUDGET_TOKENS,
+  DEFAULT_CHUNK_MAX_TOKENS,
+  DEFAULT_CHUNK_OVERLAP,
+  DEFAULT_LOCAL_MODEL,
+  DEFAULT_RRF_K,
+  DEFAULT_RRF_WEIGHTS,
+  DEFAULT_SEARCH_LIMIT,
+  DEFAULT_SNIPPET_WINDOW_TOKENS,
+  EMBED_DIM,
+  MODELS_DIR,
+  SKIP_DIRS,
+  SOURCES,
+  TOKEN_ESTIMATE_FACTOR,
+  chunkFile,
+  createEmbedFn,
+  createIndexer,
+  createRetriever,
+  ctxFileKey,
+  estimateTokens,
+  explodeIdentifiers,
+  fakeEmbedFn,
+  fuseRrf,
+  inferLanguage,
+  isBinaryExt,
+  isSensitive,
+  l2normalize,
+  localEmbedder,
+  ollamaEmbedder,
+  remoteEmbedder,
+  resolveEmbedderConfig,
+  windowSnippet,
+  withIdentifierExplosion
+};
+//# sourceMappingURL=index.js.map