@ninjaxtools/slopdex 0.3.0

package/dist/cli.js

@@ -0,0 +1,1691 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { existsSync, readFileSync, rmSync } from "node:fs";
+import path7 from "node:path";
+import { parseArgs } from "node:util";
+
+// src/code-index.ts
+import { lstat, readFile } from "node:fs/promises";
+import path6 from "node:path";
+
+// src/errors.ts
+var CodeIndexError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "CodeIndexError";
+  }
+};
+var GitDivergenceError = class extends CodeIndexError {
+  constructor(checkpoint, target) {
+    super(`Stored Git checkpoint ${checkpoint} is not an ancestor of ${target}; rebuild the index.`);
+    this.name = "GitDivergenceError";
+  }
+};
+var IncompatibleIndexError = class extends CodeIndexError {
+  constructor(message) {
+    super(message);
+    this.name = "IncompatibleIndexError";
+  }
+};
+
+// src/git/repository.ts
+import { spawn } from "node:child_process";
+import path from "node:path";
+var GitRepository = class {
+  constructor(rootDir) {
+    this.rootDir = rootDir;
+  }
+  rootDir;
+  async #run(args, allowExitOne = false) {
+    return await new Promise((resolve, reject) => {
+      const child = spawn("git", ["-C", this.rootDir, ...args], { stdio: ["ignore", "pipe", "pipe"] });
+      const stdout = [];
+      const stderr = [];
+      child.stdout.on("data", (value) => stdout.push(value));
+      child.stderr.on("data", (value) => stderr.push(value));
+      child.on("error", reject);
+      child.on("close", (code) => {
+        const exitCode = code ?? -1;
+        if (exitCode === 0 || allowExitOne && exitCode === 1) {
+          resolve({ stdout: Buffer.concat(stdout), code: exitCode });
+          return;
+        }
+        reject(new CodeIndexError(`Git command failed: ${Buffer.concat(stderr).toString("utf8").trim()}`));
+      });
+    });
+  }
+  async assertRepository() {
+    const result = await this.#run(["rev-parse", "--is-inside-work-tree"]);
+    if (result.stdout.toString("utf8").trim() !== "true") {
+      throw new CodeIndexError(`${this.rootDir} is not a Git worktree.`);
+    }
+    const topLevel = (await this.#run(["rev-parse", "--show-toplevel"])).stdout.toString("utf8").trim();
+    if (path.resolve(topLevel) !== path.resolve(this.rootDir)) {
+      throw new CodeIndexError(`rootDir must be the Git worktree root: ${topLevel}`);
+    }
+  }
+  async assertCleanWorkingTree(excludePaths = []) {
+    const pathspecs = [".", ...excludePaths.map((filePath) => `:(top,literal,exclude)${filePath}`)];
+    const result = await this.#run([
+      "status",
+      "--porcelain=v1",
+      "-z",
+      "--untracked-files=all",
+      "--ignore-submodules=none",
+      "--",
+      ...pathspecs
+    ]);
+    if (result.stdout.length > 0) {
+      throw new CodeIndexError("Cannot update from Git: the working tree has uncommitted changes. Commit or stash them first.");
+    }
+  }
+  async resolveCommit(ref) {
+    const result = await this.#run(["rev-parse", "--verify", "--end-of-options", `${ref}^{commit}`]);
+    const oid = result.stdout.toString("ascii").trim();
+    if (!/^[0-9a-f]{40,64}$/.test(oid)) throw new CodeIndexError(`Could not resolve Git commit: ${ref}`);
+    return oid;
+  }
+  async isAncestor(ancestor, descendant) {
+    const result = await this.#run(["merge-base", "--is-ancestor", ancestor, descendant], true);
+    return result.code === 0;
+  }
+  async listTree(commit) {
+    const result = await this.#run(["ls-tree", "-r", "-z", "-l", "--full-tree", commit, "--"]);
+    const entries = /* @__PURE__ */ new Map();
+    for (const record of splitNull(result.stdout)) {
+      const tab = record.indexOf("	");
+      if (tab < 0) continue;
+      const [mode, type, oid, sizeText] = record.slice(0, tab).trim().split(/\s+/);
+      const filePath = record.slice(tab + 1);
+      const size = Number(sizeText);
+      if ((mode === "100644" || mode === "100755") && type === "blob" && oid && Number.isSafeInteger(size)) {
+        entries.set(filePath, { path: filePath, oid, mode, size });
+      }
+    }
+    return entries;
+  }
+  async readBlob(oid) {
+    return (await this.#run(["cat-file", "blob", oid])).stdout;
+  }
+  async diff(base, target) {
+    const result = await this.#run(["diff", "--name-status", "-z", "--find-renames", `${base}..${target}`, "--"]);
+    const values = splitNull(result.stdout);
+    const changes = [];
+    for (let index = 0; index < values.length; ) {
+      const rawStatus = values[index++];
+      if (!rawStatus) continue;
+      const status = rawStatus[0];
+      if (status === "R" || status === "C") {
+        const oldPath = values[index++];
+        const filePath = values[index++];
+        if (oldPath && filePath) changes.push({ status, oldPath, path: filePath });
+      } else if (status === "A" || status === "M" || status === "D" || status === "T") {
+        const filePath = values[index++];
+        if (filePath) changes.push({ status, path: filePath });
+      } else {
+        throw new CodeIndexError(`Unsupported Git diff status: ${rawStatus}`);
+      }
+    }
+    return changes;
+  }
+};
+function splitNull(buffer) {
+  const value = buffer.toString("utf8");
+  const parts = value.split("\0");
+  if (parts.at(-1) === "") parts.pop();
+  return parts;
+}
+
+// src/parser/callable-parser.ts
+import path3 from "node:path";
+import Parser from "tree-sitter";
+import JavaScript from "tree-sitter-javascript";
+import TypeScript from "tree-sitter-typescript";
+
+// src/utils.ts
+import { createHash } from "node:crypto";
+import path2 from "node:path";
+function sha256(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+function normalizeRelativePath(rootDir, inputPath) {
+  const absolute = path2.resolve(rootDir, inputPath);
+  const relative = path2.relative(rootDir, absolute);
+  if (relative === "" || relative === ".") {
+    throw new CodeIndexError(`Expected a file path, received repository root: ${inputPath}`);
+  }
+  if (relative.startsWith(`..${path2.sep}`) || path2.isAbsolute(relative)) {
+    throw new CodeIndexError(`Path escapes repository root: ${inputPath}`);
+  }
+  return relative.split(path2.sep).join("/");
+}
+function throwIfAborted(signal) {
+  signal?.throwIfAborted();
+}
+function chunk(values, size) {
+  const batches = [];
+  for (let index = 0; index < values.length; index += size) {
+    batches.push(values.slice(index, index + size));
+  }
+  return batches;
+}
+function assertPositiveInteger(value, name) {
+  if (!Number.isInteger(value) || value < 1) {
+    throw new CodeIndexError(`${name} must be a positive integer.`);
+  }
+}
+function normalizeEmbeddingVector(value, dimensions) {
+  if (!Array.isArray(value) || value.length !== dimensions) {
+    throw new CodeIndexError(`Expected a finite ${dimensions}-dimensional embedding vector.`);
+  }
+  const converted = [];
+  for (const component of value) {
+    if (typeof component !== "number" || !Number.isFinite(component)) {
+      throw new CodeIndexError(`Expected a finite ${dimensions}-dimensional embedding vector.`);
+    }
+    const normalized = Math.fround(component);
+    if (!Number.isFinite(normalized)) {
+      throw new CodeIndexError(`Expected a finite ${dimensions}-dimensional embedding vector.`);
+    }
+    converted.push(normalized);
+  }
+  if (!converted.some((component) => component !== 0)) {
+    throw new CodeIndexError("Embedding vector must not be all zeroes.");
+  }
+  return converted;
+}
+
+// src/parser/callable-parser.ts
+var parsers = /* @__PURE__ */ new Map();
+function languageForPath(filePath) {
+  switch (path3.extname(filePath).toLowerCase()) {
+    case ".ts":
+    case ".mts":
+    case ".cts":
+      return "typescript";
+    case ".tsx":
+      return "tsx";
+    case ".js":
+    case ".mjs":
+    case ".cjs":
+      return "javascript";
+    case ".jsx":
+      return "jsx";
+    default:
+      return null;
+  }
+}
+function getParser(language) {
+  const existing = parsers.get(language);
+  if (existing) return existing;
+  const parser = new Parser();
+  if (language === "typescript") parser.setLanguage(TypeScript.typescript);
+  else if (language === "tsx") parser.setLanguage(TypeScript.tsx);
+  else parser.setLanguage(JavaScript);
+  parsers.set(language, parser);
+  return parser;
+}
+function parseTree(parser, content, relativePath) {
+  try {
+    return parser.parse(content, void 0, { bufferSize: Buffer.byteLength(content) + 1 });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new CodeIndexError(`Cannot index ${relativePath}: tree-sitter failed: ${message}`, { cause: error });
+  }
+}
+function maskSyntax(value, replacement) {
+  return replacement + value.slice(replacement.length).replace(/[^\r\n]/g, " ");
+}
+function recoverUnsupportedTypeScriptSyntax(parser, tree, content, relativePath) {
+  const errors = [];
+  const collectErrors = (node) => {
+    if (node.isError || node.isMissing) errors.push(node);
+    for (const child of node.children) collectErrors(child);
+  };
+  collectErrors(tree.rootNode);
+  if (errors.length === 0) return null;
+  let recoveredContent = content;
+  let changed = false;
+  const taggedTemplateTypeArguments = /* @__PURE__ */ new Map();
+  for (const error of errors) {
+    const parent = error.parent;
+    if (error.isMissing && error.type === "!" && parent?.type === "type_arguments" && /^\s*`/.test(content.slice(parent.endIndex))) {
+      taggedTemplateTypeArguments.set(parent.startIndex, parent);
+    }
+  }
+  for (const node of [...taggedTemplateTypeArguments.values()].toSorted((left, right) => right.startIndex - left.startIndex)) {
+    const value = recoveredContent.slice(node.startIndex, node.endIndex);
+    recoveredContent = `${recoveredContent.slice(0, node.startIndex)}${value.replace(/[^\r\n]/g, " ")}${recoveredContent.slice(node.endIndex)}`;
+    changed = true;
+  }
+  for (const node of errors.filter((candidate) => {
+    const parent = candidate.parent;
+    return !candidate.isMissing && candidate.type === "ERROR" && candidate.text === "type" && parent?.type === "export_statement" && content.slice(parent.startIndex, candidate.startIndex).trim() === "export" && /^\s*\*/.test(content.slice(candidate.endIndex, parent.endIndex));
+  }).toSorted((left, right) => right.startIndex - left.startIndex)) {
+    recoveredContent = `${recoveredContent.slice(0, node.startIndex)}    ${recoveredContent.slice(node.endIndex)}`;
+    changed = true;
+  }
+  recoveredContent = recoveredContent.replace(
+    /\bimport\s*\(\s*(["'])(?:\\.|(?!\1)[^\\])*\1\s*\)/g,
+    (value) => {
+      changed = true;
+      return maskSyntax(value, "X");
+    }
+  );
+  if (!changed) return null;
+  const recoveredTree = parseTree(parser, recoveredContent, relativePath);
+  return recoveredTree.rootNode.hasError ? null : recoveredTree;
+}
+function textFor(content, node) {
+  return content.slice(node.startIndex, node.endIndex);
+}
+function fieldText(content, node, field) {
+  const child = node.childForFieldName(field);
+  return child ? textFor(content, child) : null;
+}
+function callableKind(node, name) {
+  if (name === "constructor") return "constructor";
+  if (node.type.includes("generator") || /^\s*(?:async\s+)?\*/.test(node.text)) return "generator";
+  return node.type === "method_definition" ? "method" : "function";
+}
+function bindingName(content, node) {
+  const nameNode = node.childForFieldName("name");
+  if (!nameNode || !["identifier", "property_identifier", "private_property_identifier"].includes(nameNode.type)) {
+    return null;
+  }
+  return textFor(content, nameNode).replace(/^#/, "");
+}
+function assignmentName(content, node) {
+  const left = node.childForFieldName("left");
+  if (!left) return null;
+  const value = textFor(content, left).trim();
+  const match = value.match(/(?:^|[.#])([A-Za-z_$][\w$]*)$/);
+  return match?.[1] ?? null;
+}
+function objectScopeName(content, node) {
+  const parent = node.parent;
+  if (!parent) return null;
+  if (parent.type === "variable_declarator" && parent.childForFieldName("value")?.id === node.id) {
+    return bindingName(content, parent);
+  }
+  if (parent.type === "pair" && parent.childForFieldName("value")?.id === node.id) {
+    return fieldText(content, parent, "key")?.replace(/["']/g, "") ?? null;
+  }
+  if (parent.type === "assignment_expression" && parent.childForFieldName("right")?.id === node.id) {
+    return assignmentName(content, parent);
+  }
+  return null;
+}
+function walk(node, content, scope, candidates) {
+  if (node.type === "class_declaration" || node.type === "class") {
+    const name = fieldText(content, node, "name") ?? objectScopeName(content, node);
+    const nextScope = name ? [...scope, name] : scope;
+    for (const child of node.namedChildren) walk(child, content, nextScope, candidates);
+    return;
+  }
+  if (node.type === "internal_module" || node.type === "module") {
+    const name = fieldText(content, node, "name")?.replace(/["']/g, "");
+    const nextScope = name ? [...scope, name] : scope;
+    for (const child of node.namedChildren) walk(child, content, nextScope, candidates);
+    return;
+  }
+  if (node.type === "object") {
+    const name = objectScopeName(content, node);
+    const nextScope = name ? [...scope, name] : scope;
+    for (const child of node.namedChildren) walk(child, content, nextScope, candidates);
+    return;
+  }
+  if (["function_declaration", "generator_function_declaration"].includes(node.type)) {
+    const name = fieldText(content, node, "name");
+    const body = node.childForFieldName("body");
+    if (name && body) {
+      candidates.push({ node, name, kind: callableKind(node, name), scope });
+      walk(body, content, [...scope, name], candidates);
+    }
+    return;
+  }
+  if (node.type === "method_definition") {
+    const name = fieldText(content, node, "name")?.replace(/^#/, "");
+    const body = node.childForFieldName("body");
+    if (name && body) {
+      candidates.push({ node, name, kind: callableKind(node, name), scope });
+      walk(body, content, [...scope, name], candidates);
+    }
+    return;
+  }
+  if (node.type === "public_field_definition" || node.type === "field_definition") {
+    const name = (fieldText(content, node, "name") ?? fieldText(content, node, "property"))?.replace(/^#/, "");
+    const value = node.childForFieldName("value");
+    if (name && value && ["arrow_function", "function_expression", "generator_function"].includes(value.type)) {
+      const kind = callableKind(value, name) === "generator" ? "generator" : "method";
+      candidates.push({ node: value, name, kind, scope });
+      const body = value.childForFieldName("body");
+      if (body) walk(body, content, [...scope, name], candidates);
+      return;
+    }
+  }
+  if (node.type === "variable_declarator") {
+    const name = bindingName(content, node);
+    const value = node.childForFieldName("value");
+    if (name && value && ["arrow_function", "function_expression", "generator_function"].includes(value.type)) {
+      candidates.push({ node: value, name, kind: callableKind(value, name), scope });
+      const body = value.childForFieldName("body");
+      if (body) walk(body, content, [...scope, name], candidates);
+      return;
+    }
+  }
+  if (node.type === "pair") {
+    const name = fieldText(content, node, "key")?.replace(/["']/g, "");
+    const value = node.childForFieldName("value");
+    if (name && value && ["arrow_function", "function_expression", "generator_function"].includes(value.type)) {
+      candidates.push({ node: value, name, kind: callableKind(value, name), scope });
+      const body = value.childForFieldName("body");
+      if (body) walk(body, content, [...scope, name], candidates);
+      return;
+    }
+  }
+  if (node.type === "assignment_expression") {
+    const name = assignmentName(content, node);
+    const value = node.childForFieldName("right");
+    if (name && value && ["arrow_function", "function_expression", "generator_function"].includes(value.type)) {
+      candidates.push({ node: value, name, kind: callableKind(value, name), scope });
+      const body = value.childForFieldName("body");
+      if (body) walk(body, content, [...scope, name], candidates);
+      return;
+    }
+  }
+  if (["function_expression", "generator_function"].includes(node.type)) {
+    const name = fieldText(content, node, "name");
+    const body = node.childForFieldName("body");
+    if (name && body) {
+      candidates.push({ node, name, kind: callableKind(node, name), scope });
+      walk(body, content, [...scope, name], candidates);
+      return;
+    }
+  }
+  for (const child of node.namedChildren) walk(child, content, scope, candidates);
+}
+function signatureFor(content, node, name) {
+  const parameters = node.childForFieldName("parameters");
+  if (!parameters) return name;
+  const returnType = node.childForFieldName("return_type");
+  return `${name}${textFor(content, parameters)}${returnType ? textFor(content, returnType) : ""}`;
+}
+function parseCallables(relativePath, content, onWarning = console.warn) {
+  const language = languageForPath(relativePath);
+  if (!language) return [];
+  const parser = getParser(language);
+  const parsedTree = parseTree(parser, content, relativePath);
+  const tree = parsedTree.rootNode.hasError ? recoverUnsupportedTypeScriptSyntax(parser, parsedTree, content, relativePath) ?? parsedTree : parsedTree;
+  if (tree.rootNode.hasError) {
+    onWarning(`Cannot fully parse ${relativePath}: tree-sitter reported syntax errors; indexing recoverable callables only.`);
+  }
+  const candidates = [];
+  walk(tree.rootNode, content, [], candidates);
+  candidates.sort((left, right) => left.node.startIndex - right.node.startIndex);
+  const occurrences = /* @__PURE__ */ new Map();
+  return candidates.map(({ node, name, kind, scope }) => {
+    const qualifiedName = [...scope, name].join(".");
+    const baseIdentity = `${relativePath}\0${qualifiedName}\0${kind}`;
+    const occurrence = occurrences.get(baseIdentity) ?? 0;
+    occurrences.set(baseIdentity, occurrence + 1);
+    const identityKey = sha256(`${baseIdentity}\0${occurrence}`);
+    const source = textFor(content, node);
+    const signature = signatureFor(content, node, name);
+    const embeddingInput = [
+      `language: ${language}`,
+      `kind: ${kind}`,
+      `symbol: ${qualifiedName}`,
+      signature ? `signature: ${signature}` : null,
+      "source:",
+      source
+    ].filter((value) => value !== null).join("\n");
+    return {
+      path: relativePath,
+      language,
+      kind,
+      name,
+      qualifiedName,
+      signature,
+      identityKey,
+      startLine: node.startPosition.row + 1,
+      startColumn: node.startPosition.column + 1,
+      endLine: node.endPosition.row + 1,
+      endColumn: node.endPosition.column + 1,
+      source,
+      sourceHash: sha256(source),
+      embeddingInput
+    };
+  });
+}
+
+// src/source-policy.ts
+import path4 from "node:path";
+var DEFAULT_EXCLUDED_SEGMENTS = /* @__PURE__ */ new Set([
+  ".git",
+  ".slopdex",
+  "node_modules",
+  "dist",
+  "build",
+  "coverage",
+  "vendor",
+  "generated"
+]);
+var SourcePolicy = class {
+  #include;
+  #exclude;
+  constructor(include = [], exclude = []) {
+    this.#include = include;
+    this.#exclude = exclude;
+  }
+  includes(relativePath) {
+    const normalized = relativePath.replaceAll("\\", "/");
+    if (!languageForPath(normalized)) return false;
+    if (normalized.split("/").some((segment) => DEFAULT_EXCLUDED_SEGMENTS.has(segment))) return false;
+    if (this.#exclude.some((pattern) => path4.matchesGlob(normalized, pattern))) return false;
+    return this.#include.length === 0 || this.#include.some((pattern) => path4.matchesGlob(normalized, pattern));
+  }
+};
+
+// src/storage/database.ts
+import { mkdirSync } from "node:fs";
+import path5 from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import * as sqliteVec from "sqlite-vec";
+var SCHEMA_VERSION = "1";
+var IndexDatabase = class {
+  #db;
+  #rootDir;
+  #indexPath;
+  #profile;
+  constructor(indexPath, rootDir, profile, readOnly = false) {
+    if (!readOnly) mkdirSync(path5.dirname(indexPath), { recursive: true });
+    this.#indexPath = indexPath;
+    this.#rootDir = rootDir;
+    this.#profile = profile;
+    this.#db = new DatabaseSync(indexPath, { allowExtension: true, readOnly });
+    sqliteVec.load(this.#db);
+    this.#db.enableLoadExtension(false);
+    if (readOnly) {
+      this.#db.exec("PRAGMA foreign_keys=ON");
+    } else {
+      this.#db.exec("PRAGMA journal_mode=WAL; PRAGMA synchronous=NORMAL; PRAGMA foreign_keys=ON;");
+      this.#migrate();
+    }
+    this.#validateMetadata(readOnly);
+  }
+  close() {
+    this.#db.close();
+  }
+  #migrate() {
+    this.#db.exec(`
+      CREATE TABLE IF NOT EXISTS metadata (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS files (
+        path TEXT PRIMARY KEY,
+        content_hash TEXT NOT NULL,
+        blob_oid TEXT,
+        source_mode TEXT NOT NULL CHECK(source_mode IN ('git', 'working-tree')),
+        indexed_commit TEXT,
+        previous_path TEXT,
+        language TEXT NOT NULL,
+        byte_size INTEGER NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS embeddings (
+        id INTEGER PRIMARY KEY,
+        embedding_key TEXT NOT NULL UNIQUE,
+        vector BLOB NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS functions (
+        id INTEGER PRIMARY KEY,
+        path TEXT NOT NULL REFERENCES files(path) ON DELETE CASCADE ON UPDATE CASCADE,
+        language TEXT NOT NULL,
+        kind TEXT NOT NULL,
+        name TEXT NOT NULL,
+        qualified_name TEXT NOT NULL,
+        signature TEXT,
+        identity_key TEXT NOT NULL UNIQUE,
+        start_line INTEGER NOT NULL,
+        start_column INTEGER NOT NULL,
+        end_line INTEGER NOT NULL,
+        end_column INTEGER NOT NULL,
+        source TEXT NOT NULL,
+        source_hash TEXT NOT NULL,
+        embedding_input TEXT NOT NULL,
+        first_seen_commit TEXT,
+        last_seen_commit TEXT,
+        source_mode TEXT NOT NULL CHECK(source_mode IN ('git', 'working-tree')),
+        embedding_id INTEGER NOT NULL REFERENCES embeddings(id)
+      );
+      CREATE INDEX IF NOT EXISTS functions_path ON functions(path);
+      CREATE INDEX IF NOT EXISTS functions_embedding ON functions(embedding_id);
+    `);
+    const fileColumns = this.#db.prepare("PRAGMA table_info(files)").all();
+    if (!fileColumns.some((column) => column.name === "previous_path")) {
+      this.#db.exec("ALTER TABLE files ADD COLUMN previous_path TEXT");
+    }
+  }
+  #metadata(key) {
+    const row = this.#db.prepare("SELECT value FROM metadata WHERE key = ?").get(key);
+    return row?.value ?? null;
+  }
+  #setMetadata(key, value) {
+    this.#db.prepare(`
+      INSERT INTO metadata(key, value) VALUES (?, ?)
+      ON CONFLICT(key) DO UPDATE SET value = excluded.value
+    `).run(key, value);
+  }
+  #validateMetadata(readOnly) {
+    const schemaVersion = this.#metadata("schema_version");
+    if (readOnly && !schemaVersion) throw new IncompatibleIndexError("Target file is not a slopdex index.");
+    if (schemaVersion && schemaVersion !== SCHEMA_VERSION) {
+      throw new IncompatibleIndexError(`Unsupported index schema version ${schemaVersion}.`);
+    }
+    const storedRoot = this.#metadata("root_dir");
+    if (readOnly && !storedRoot) throw new IncompatibleIndexError("Target index has no repository identity.");
+    if (storedRoot && path5.resolve(storedRoot) !== this.#rootDir) {
+      throw new IncompatibleIndexError(`Index belongs to ${storedRoot}, not ${this.#rootDir}.`);
+    }
+    const profileJson = JSON.stringify(this.#profile);
+    const storedProfile = this.#metadata("embedding_profile");
+    if (readOnly && !storedProfile) throw new IncompatibleIndexError("Target index has no embedding profile.");
+    if (storedProfile && storedProfile !== profileJson) {
+      throw new IncompatibleIndexError("Embedding provider, model, dimensions, or strategy differs from this index.");
+    }
+    if (readOnly) return;
+    this.#transaction(() => {
+      this.#setMetadata("schema_version", SCHEMA_VERSION);
+      this.#setMetadata("root_dir", this.#rootDir);
+      this.#setMetadata("embedding_profile", profileJson);
+      if (!this.#metadata("generation")) this.#setMetadata("generation", "0");
+    });
+  }
+  #transaction(operation) {
+    this.#db.exec("BEGIN IMMEDIATE");
+    try {
+      const result = operation();
+      this.#db.exec("COMMIT");
+      return result;
+    } catch (error) {
+      this.#db.exec("ROLLBACK");
+      throw error;
+    }
+  }
+  getCheckpoint() {
+    return this.#metadata("git_checkpoint");
+  }
+  getGeneration() {
+    return Number(this.#metadata("generation") ?? 0);
+  }
+  getWorkingTreeFiles() {
+    return this.#db.prepare(`
+      SELECT path, previous_path AS previousPath
+      FROM files WHERE source_mode = 'working-tree' ORDER BY path
+    `).all();
+  }
+  getEmbeddingKeys(keys) {
+    const found = /* @__PURE__ */ new Set();
+    const statement = this.#db.prepare("SELECT 1 FROM embeddings WHERE embedding_key = ?");
+    for (const key of keys) {
+      if (statement.get(key)) found.add(key);
+    }
+    return found;
+  }
+  applyUpdate(options) {
+    return this.#transaction(() => {
+      if (options.expectedCheckpoint !== void 0 && this.getCheckpoint() !== options.expectedCheckpoint) {
+        throw new CodeIndexError("Git checkpoint changed while the update was being prepared.");
+      }
+      const stats = {
+        filesUpdated: options.files.length,
+        filesDeleted: 0,
+        functionsAdded: 0,
+        functionsUpdated: 0,
+        functionsDeleted: 0,
+        embeddingsCreated: 0,
+        checkpoint: options.checkpoint ?? this.getCheckpoint()
+      };
+      const deleteFile = this.#db.prepare("DELETE FROM files WHERE path = ?");
+      const countFunctions = this.#db.prepare("SELECT COUNT(*) AS count FROM functions WHERE path = ?");
+      const uniqueDeletes = new Set(options.deletePaths);
+      for (const file of options.files) {
+        uniqueDeletes.delete(file.path);
+        if (file.previousPath) uniqueDeletes.delete(file.previousPath);
+        if (file.replacePath) uniqueDeletes.delete(file.replacePath);
+      }
+      for (const filePath of uniqueDeletes) {
+        const count = Number(countFunctions.get(filePath).count);
+        const result = deleteFile.run(filePath);
+        if (result.changes > 0) {
+          stats.filesDeleted += 1;
+          stats.functionsDeleted += count;
+        }
+      }
+      for (const file of options.files) this.#replaceFile(file, stats);
+      this.#db.exec("DELETE FROM embeddings WHERE id NOT IN (SELECT DISTINCT embedding_id FROM functions)");
+      const generation = this.getGeneration() + 1;
+      this.#setMetadata("generation", String(generation));
+      if (options.checkpoint) this.#setMetadata("git_checkpoint", options.checkpoint);
+      return stats;
+    });
+  }
+  #replaceFile(file, stats) {
+    const sourcePath = file.replacePath ?? file.previousPath ?? file.path;
+    const oldRows = this.#rowsForPath(sourcePath);
+    const existingFile = this.#db.prepare("SELECT previous_path FROM files WHERE path = ?").get(sourcePath);
+    const oldMatches = reconcileFunctions(file.callables, oldRows);
+    if (sourcePath !== file.path) {
+      this.#db.prepare("DELETE FROM files WHERE path = ?").run(sourcePath);
+    } else {
+      this.#db.prepare("DELETE FROM files WHERE path = ?").run(file.path);
+    }
+    this.#db.prepare(`
+      INSERT INTO files(path, content_hash, blob_oid, source_mode, indexed_commit, previous_path, language, byte_size)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(
+      file.path,
+      file.contentHash,
+      file.blobOid,
+      file.sourceMode,
+      file.indexedCommit,
+      file.sourceMode === "working-tree" ? file.previousPath ?? existingFile?.previous_path ?? null : null,
+      file.language,
+      file.byteSize
+    );
+    const usedIds = /* @__PURE__ */ new Set();
+    const orderedCallables = [
+      ...file.callables.filter((callable) => oldMatches.has(callable)),
+      ...file.callables.filter((callable) => !oldMatches.has(callable))
+    ];
+    for (const callable of orderedCallables) {
+      if (callable.vector) {
+        const result = this.#db.prepare("INSERT OR IGNORE INTO embeddings(embedding_key, vector) VALUES (?, ?)").run(callable.embeddingKey, vectorBuffer(callable.vector));
+        stats.embeddingsCreated += Number(result.changes);
+      }
+      const embedding = this.#db.prepare("SELECT id FROM embeddings WHERE embedding_key = ?").get(callable.embeddingKey);
+      if (!embedding) throw new CodeIndexError(`Missing embedding for ${callable.qualifiedName}.`);
+      const old = oldMatches.get(callable);
+      if (old) usedIds.add(old.id);
+      const firstSeenCommit = old?.first_seen_commit ?? file.indexedCommit;
+      this.#db.prepare(`
+        INSERT INTO functions(
+          id, path, language, kind, name, qualified_name, signature, identity_key,
+          start_line, start_column, end_line, end_column, source, source_hash,
+          embedding_input, first_seen_commit, last_seen_commit, source_mode, embedding_id
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(
+        old?.id ?? null,
+        file.path,
+        callable.language,
+        callable.kind,
+        callable.name,
+        callable.qualifiedName,
+        callable.signature,
+        callable.identityKey,
+        callable.startLine,
+        callable.startColumn,
+        callable.endLine,
+        callable.endColumn,
+        callable.source,
+        callable.sourceHash,
+        callable.embeddingInput,
+        firstSeenCommit,
+        file.indexedCommit,
+        file.sourceMode,
+        embedding.id
+      );
+      if (old) stats.functionsUpdated += 1;
+      else stats.functionsAdded += 1;
+    }
+    stats.functionsDeleted += oldRows.length - usedIds.size;
+  }
+  #rowsForPath(filePath) {
+    return this.#db.prepare("SELECT * FROM functions WHERE path = ? ORDER BY start_line, start_column, id").all(filePath);
+  }
+  allFunctions() {
+    return this.#db.prepare("SELECT * FROM functions ORDER BY path, start_line, start_column, id").all().map(toIndexedFunction);
+  }
+  allFilePaths() {
+    return this.#db.prepare("SELECT path FROM files ORDER BY path").all().map((row) => row.path);
+  }
+  previousPath(filePath) {
+    const row = this.#db.prepare("SELECT previous_path FROM files WHERE path = ?").get(filePath);
+    return row?.previous_path ?? null;
+  }
+  functionsForPaths(paths) {
+    const results = [];
+    for (const filePath of paths) results.push(...this.#rowsForPath(filePath).map(toIndexedFunction));
+    return results;
+  }
+  searchVector(vector, options) {
+    const rows = this.#db.prepare(`
+      SELECT f.*, 1.0 - vec_distance_cosine(e.vector, ?) AS similarity
+      FROM functions f
+      JOIN embeddings e ON e.id = f.embedding_id
+      WHERE (? IS NULL OR f.id != ?)
+        AND (1.0 - vec_distance_cosine(e.vector, ?)) >= ?
+        AND (? IS NULL OR (1.0 - vec_distance_cosine(e.vector, ?)) <= ?)
+      ORDER BY similarity DESC, f.id ASC
+      LIMIT ?
+    `).all(
+      vectorBuffer(vector),
+      options.excludeId ?? null,
+      options.excludeId ?? null,
+      vectorBuffer(vector),
+      options.minSimilarity,
+      options.maxSimilarity ?? null,
+      vectorBuffer(vector),
+      options.maxSimilarity ?? null,
+      options.limit
+    );
+    return rows.map((row) => ({ function: toIndexedFunction(row), similarity: row.similarity }));
+  }
+  vectorForFunction(id) {
+    const row = this.#db.prepare(`
+      SELECT e.vector FROM functions f JOIN embeddings e ON e.id = f.embedding_id WHERE f.id = ?
+    `).get(id);
+    if (!row) throw new CodeIndexError(`Function ${id} does not exist.`);
+    return Array.from(new Float32Array(row.vector.buffer, row.vector.byteOffset, row.vector.byteLength / 4));
+  }
+  status() {
+    const functionCount = Number(this.#db.prepare("SELECT COUNT(*) AS count FROM functions").get().count);
+    const fileCount = Number(this.#db.prepare("SELECT COUNT(*) AS count FROM files").get().count);
+    return {
+      rootDir: this.#rootDir,
+      indexPath: this.#indexPath,
+      functionCount,
+      fileCount,
+      generation: this.getGeneration(),
+      gitCheckpoint: this.getCheckpoint(),
+      embeddingProfile: this.#profile
+    };
+  }
+};
+function vectorBuffer(vector) {
+  const values = Float32Array.from(vector);
+  return new Uint8Array(values.buffer);
+}
+function toIndexedFunction(row) {
+  return {
+    id: row.id,
+    path: row.path,
+    language: row.language,
+    kind: row.kind,
+    name: row.name,
+    qualifiedName: row.qualified_name,
+    signature: row.signature,
+    identityKey: row.identity_key,
+    startLine: row.start_line,
+    startColumn: row.start_column,
+    endLine: row.end_line,
+    endColumn: row.end_column,
+    source: row.source,
+    sourceHash: row.source_hash,
+    embeddingInput: row.embedding_input,
+    firstSeenCommit: row.first_seen_commit,
+    lastSeenCommit: row.last_seen_commit,
+    sourceMode: row.source_mode,
+    embeddingId: row.embedding_id
+  };
+}
+function reconcileFunctions(current, previous) {
+  const matches = /* @__PURE__ */ new Map();
+  const keys = /* @__PURE__ */ new Set([
+    ...current.map((callable) => `${callable.qualifiedName}\0${callable.kind}`),
+    ...previous.map((callable) => `${callable.qualified_name}\0${callable.kind}`)
+  ]);
+  for (const key of keys) {
+    const currentGroup = current.filter((callable) => `${callable.qualifiedName}\0${callable.kind}` === key);
+    const previousGroup = previous.filter((callable) => `${callable.qualified_name}\0${callable.kind}` === key);
+    const unmatchedPrevious = new Set(previousGroup);
+    const unmatchedCurrent = new Set(currentGroup);
+    for (const callable of currentGroup) {
+      const exact = [...unmatchedPrevious].find((old) => old.source_hash === callable.sourceHash);
+      if (exact) {
+        matches.set(callable, exact);
+        unmatchedPrevious.delete(exact);
+        unmatchedCurrent.delete(callable);
+      }
+    }
+    for (const callable of unmatchedCurrent) {
+      const old = unmatchedPrevious.values().next().value;
+      if (!old) break;
+      matches.set(callable, old);
+      unmatchedPrevious.delete(old);
+    }
+  }
+  return matches;
+}
+
+// src/code-index.ts
+var DEFAULT_MAX_FILE_SIZE = 1024 * 1024;
+var DEFAULT_BATCH_SIZE = 32;
+var CodeIndex = class {
+  rootDir;
+  indexPath;
+  provider;
+  #database;
+  #policy;
+  #maxFileSize;
+  #embeddingBatchSize;
+  #git;
+  #onWarning;
+  constructor(options) {
+    this.rootDir = path6.resolve(options.rootDir);
+    this.indexPath = path6.resolve(options.indexPath ?? path6.join(this.rootDir, ".slopdex", "index.sqlite"));
+    this.provider = options.provider;
+    const profile = normalizeProfile(options.provider.profile);
+    assertPositiveInteger(profile.dimensions, "embedding dimensions");
+    this.#database = new IndexDatabase(this.indexPath, this.rootDir, profile, options.readOnly ?? false);
+    this.#policy = new SourcePolicy(options.include, options.exclude);
+    this.#maxFileSize = options.maxFileSize ?? DEFAULT_MAX_FILE_SIZE;
+    this.#embeddingBatchSize = options.embeddingBatchSize ?? DEFAULT_BATCH_SIZE;
+    this.#onWarning = options.onWarning ?? console.warn;
+    assertPositiveInteger(this.#maxFileSize, "maxFileSize");
+    assertPositiveInteger(this.#embeddingBatchSize, "embeddingBatchSize");
+    this.#git = new GitRepository(this.rootDir);
+  }
+  close() {
+    this.#database.close();
+  }
+  status() {
+    return this.#database.status();
+  }
+  allFunctions() {
+    return this.#database.allFunctions();
+  }
+  async updateFiles(options) {
+    const normalizedRenames = (options.renames ?? []).map(({ from, to }) => ({
+      from: normalizeRelativePath(this.rootDir, from),
+      to: normalizeRelativePath(this.rootDir, to)
+    }));
+    validateRenames(normalizedRenames);
+    const upsertPaths = [...new Set((options.upsert ?? []).map((value) => normalizeRelativePath(this.rootDir, value)))];
+    const deletePaths = [...new Set((options.delete ?? []).map((value) => normalizeRelativePath(this.rootDir, value)))];
+    const renameMap = new Map(
+      normalizedRenames.map(({ from, to }) => [to, from])
+    );
+    for (const target of renameMap.keys()) {
+      if (!upsertPaths.includes(target)) upsertPaths.push(target);
+    }
+    const prepared = [];
+    for (const relativePath of upsertPaths) {
+      throwIfAborted(options.signal);
+      if (!this.#policy.includes(relativePath)) throw new CodeIndexError(`Unsupported or excluded source file: ${relativePath}`);
+      const absolutePath = path6.join(this.rootDir, relativePath);
+      const info = await lstat(absolutePath);
+      if (info.isSymbolicLink()) throw new CodeIndexError(`Symbolic links are not supported: ${relativePath}`);
+      if (!info.isFile()) throw new CodeIndexError(`Not a regular file: ${relativePath}`);
+      if (info.size > this.#maxFileSize) throw new CodeIndexError(`File exceeds maxFileSize: ${relativePath}`);
+      const content = await readFile(absolutePath);
+      const renameSource = renameMap.get(relativePath);
+      const originalPath = renameSource ? this.#database.previousPath(renameSource) ?? renameSource : void 0;
+      prepared.push(this.#prepareFile(relativePath, content, {
+        blobOid: null,
+        sourceMode: "working-tree",
+        indexedCommit: null,
+        ...originalPath ? { previousPath: originalPath } : {},
+        ...renameSource ? { replacePath: renameSource } : {}
+      }));
+    }
+    await this.#attachEmbeddings(prepared, options.signal);
+    return this.#database.applyUpdate({
+      files: prepared,
+      deletePaths: [...deletePaths, ...renameMap.values()]
+    });
+  }
+  async updateFromGit(options = {}) {
+    throwIfAborted(options.signal);
+    await this.#git.assertRepository();
+    const relativeIndexPath = path6.relative(this.rootDir, this.indexPath).replaceAll(path6.sep, "/");
+    const indexArtifacts = relativeIndexPath && !relativeIndexPath.startsWith("../") ? [relativeIndexPath, `${relativeIndexPath}-shm`, `${relativeIndexPath}-wal`, `${relativeIndexPath}-journal`] : [];
+    await this.#git.assertCleanWorkingTree(indexArtifacts);
+    const target = await this.#git.resolveCommit(options.target ?? "HEAD");
+    const checkpoint = this.#database.getCheckpoint();
+    let rebuild = checkpoint === null;
+    if (checkpoint && !await this.#git.isAncestor(checkpoint, target)) {
+      if (!options.rebuildOnDivergence) throw new GitDivergenceError(checkpoint, target);
+      rebuild = true;
+    }
+    const tree = await this.#git.listTree(target);
+    const workingFiles = this.#database.getWorkingTreeFiles();
+    const changes = rebuild || !checkpoint ? [] : await this.#git.diff(checkpoint, target);
+    const upserts = /* @__PURE__ */ new Map();
+    const deletes = /* @__PURE__ */ new Set();
+    if (rebuild) {
+      for (const existing of this.#database.allFilePaths()) deletes.add(existing);
+      for (const entry of tree.values()) {
+        if (this.#policy.includes(entry.path) && entry.size <= this.#maxFileSize) upserts.set(entry.path, { entry });
+      }
+    } else {
+      this.#classifyGitChanges(changes, tree, upserts, deletes);
+      for (const { path: dirtyPath } of workingFiles) {
+        const entry = tree.get(dirtyPath);
+        if (entry && this.#policy.includes(dirtyPath) && entry.size <= this.#maxFileSize) upserts.set(dirtyPath, { entry });
+        else deletes.add(dirtyPath);
+      }
+      const eligibleTargetPaths = new Set(
+        [...tree.values()].filter((entry) => this.#policy.includes(entry.path) && entry.size <= this.#maxFileSize).map((entry) => entry.path)
+      );
+      const indexedPaths = new Set(this.#database.allFilePaths());
+      for (const targetPath of eligibleTargetPaths) {
+        if (!indexedPaths.has(targetPath) && !upserts.has(targetPath)) {
+          upserts.set(targetPath, { entry: tree.get(targetPath) });
+        }
+      }
+      for (const indexedPath of indexedPaths) {
+        if (!eligibleTargetPaths.has(indexedPath)) deletes.add(indexedPath);
+      }
+    }
+    if (!rebuild && checkpoint === target && upserts.size === 0 && deletes.size === 0) return emptyStats(checkpoint);
+    const prepared = [];
+    for (const { entry, previousPath } of upserts.values()) {
+      throwIfAborted(options.signal);
+      const content = await this.#git.readBlob(entry.oid);
+      if (content.byteLength > this.#maxFileSize) {
+        deletes.add(entry.path);
+        continue;
+      }
+      prepared.push(this.#prepareFile(entry.path, content, {
+        blobOid: entry.oid,
+        sourceMode: "git",
+        indexedCommit: target,
+        ...previousPath ? { replacePath: previousPath } : {}
+      }));
+    }
+    await this.#attachEmbeddings(prepared, options.signal);
+    const resolvedAgain = await this.#git.resolveCommit(options.target ?? "HEAD");
+    if (resolvedAgain !== target) throw new CodeIndexError("Target Git ref changed while indexing; retry the update.");
+    return this.#database.applyUpdate({
+      files: prepared,
+      deletePaths: [...deletes],
+      checkpoint: target,
+      expectedCheckpoint: checkpoint
+    });
+  }
+  #classifyGitChanges(changes, tree, upserts, deletes) {
+    for (const change of changes) {
+      if (change.status === "D") {
+        deletes.add(change.path);
+        continue;
+      }
+      if (change.status === "R") {
+        deletes.add(change.oldPath);
+        const entry2 = tree.get(change.path);
+        if (entry2 && this.#policy.includes(change.path) && entry2.size <= this.#maxFileSize) {
+          upserts.set(change.path, { entry: entry2, previousPath: change.oldPath });
+        }
+        continue;
+      }
+      const entry = tree.get(change.path);
+      if (entry && this.#policy.includes(change.path) && entry.size <= this.#maxFileSize) upserts.set(change.path, { entry });
+      else deletes.add(change.path);
+    }
+  }
+  #prepareFile(relativePath, buffer, provenance) {
+    const content = buffer.toString("utf8");
+    const callables = parseCallables(relativePath, content, this.#onWarning);
+    const language = callables[0]?.language ?? path6.extname(relativePath).slice(1);
+    return {
+      path: relativePath,
+      contentHash: sha256(content),
+      blobOid: provenance.blobOid,
+      sourceMode: provenance.sourceMode,
+      indexedCommit: provenance.indexedCommit,
+      language,
+      byteSize: buffer.byteLength,
+      ...provenance.previousPath ? { previousPath: provenance.previousPath } : {},
+      ...provenance.replacePath ? { replacePath: provenance.replacePath } : {},
+      callables
+    };
+  }
+  async #attachEmbeddings(files, signal) {
+    const profile = JSON.stringify(normalizeProfile(this.provider.profile));
+    const unique = /* @__PURE__ */ new Map();
+    for (const file of files) {
+      for (const callable of file.callables) {
+        callable.embeddingKey = sha256(`${profile}\0${callable.embeddingInput}`);
+        const values = unique.get(callable.embeddingKey) ?? [];
+        values.push(callable);
+        unique.set(callable.embeddingKey, values);
+      }
+    }
+    const existing = this.#database.getEmbeddingKeys([...unique.keys()]);
+    const missing = [...unique.entries()].filter(([key]) => !existing.has(key));
+    for (const batch of chunk(missing, this.#embeddingBatchSize)) {
+      throwIfAborted(signal);
+      const vectors = await this.provider.embedDocuments(batch.map(([, callables]) => callables[0].embeddingInput), signal ? { signal } : void 0);
+      if (vectors.length !== batch.length) throw new CodeIndexError("Embedding provider returned an unexpected number of vectors.");
+      vectors.forEach((vector, index) => {
+        const converted = normalizeEmbeddingVector(vector, this.provider.profile.dimensions);
+        for (const callable of batch[index][1]) callable.vector = converted;
+      });
+    }
+  }
+  async similaritySearch(options) {
+    if (!options.query.trim()) throw new CodeIndexError("query must not be empty.");
+    const limit = options.limit ?? 10;
+    assertPositiveInteger(limit, "limit");
+    throwIfAborted(options.signal);
+    const vector = await this.provider.embedQuery(options.query, options.signal ? { signal: options.signal } : void 0);
+    return this.searchByVector(vector, {
+      limit,
+      minSimilarity: options.minSimilarity ?? -1,
+      ...options.maxSimilarity !== void 0 ? { maxSimilarity: options.maxSimilarity } : {}
+    });
+  }
+  similarToFunction(functionId, options) {
+    const vector = this.#database.vectorForFunction(functionId);
+    return this.#database.searchVector(vector, {
+      limit: options.limit,
+      minSimilarity: options.minSimilarity,
+      ...options.maxSimilarity !== void 0 ? { maxSimilarity: options.maxSimilarity } : {},
+      excludeId: functionId
+    });
+  }
+  vectorForFunction(functionId) {
+    return this.#database.vectorForFunction(functionId);
+  }
+  searchByVector(vector, options) {
+    return this.#database.searchVector(normalizeEmbeddingVector(vector, this.provider.profile.dimensions), options);
+  }
+  async sourceFunctions(filter) {
+    const functions = filter.type === "all" ? this.allFunctions() : await this.#functionsAddedSince(filter.commit);
+    if (!filter.path) return functions;
+    const sourcePath = normalizeRelativePath(this.rootDir, filter.path);
+    return functions.filter((callable) => callable.path === sourcePath || callable.path.startsWith(`${sourcePath}/`));
+  }
+  async #functionsAddedSince(baseRef) {
+    await this.#git.assertRepository();
+    const checkpoint = this.#database.getCheckpoint();
+    if (!checkpoint) throw new CodeIndexError("added-since requires an index with a Git checkpoint.");
+    const base = await this.#git.resolveCommit(baseRef);
+    if (!await this.#git.isAncestor(base, checkpoint)) {
+      throw new GitDivergenceError(base, checkpoint);
+    }
+    const changes = await this.#git.diff(base, checkpoint);
+    const baseTree = await this.#git.listTree(base);
+    const comparisonPaths = /* @__PURE__ */ new Map();
+    for (const change of changes) {
+      if (change.status === "D") continue;
+      if (change.status === "R") comparisonPaths.set(change.path, change.oldPath);
+      else if (change.status === "A" || change.status === "C") comparisonPaths.set(change.path, null);
+      else comparisonPaths.set(change.path, change.path);
+    }
+    for (const dirtyFile of this.#database.getWorkingTreeFiles()) {
+      if (!comparisonPaths.has(dirtyFile.path)) {
+        comparisonPaths.set(dirtyFile.path, dirtyFile.previousPath ?? dirtyFile.path);
+      }
+    }
+    const current = this.#database.functionsForPaths([...comparisonPaths.keys()]);
+    const baseFunctionsByCurrentPath = /* @__PURE__ */ new Map();
+    for (const [currentPath, basePath] of comparisonPaths) {
+      if (!basePath) {
+        baseFunctionsByCurrentPath.set(currentPath, []);
+        continue;
+      }
+      const entry = baseTree.get(basePath);
+      if (!entry) {
+        baseFunctionsByCurrentPath.set(currentPath, []);
+        continue;
+      }
+      const content = (await this.#git.readBlob(entry.oid)).toString("utf8");
+      baseFunctionsByCurrentPath.set(currentPath, parseCallables(basePath, content, this.#onWarning));
+    }
+    const currentByPath = groupBy(current, (callable) => callable.path);
+    const addedIds = /* @__PURE__ */ new Set();
+    for (const [currentPath, currentFunctions] of currentByPath) {
+      for (const id of addedFunctionIds(currentFunctions, baseFunctionsByCurrentPath.get(currentPath) ?? [])) {
+        addedIds.add(id);
+      }
+    }
+    return current.filter((callable) => addedIds.has(callable.id));
+  }
+};
+function addedFunctionIds(current, base) {
+  const currentGroups = groupBy(current, (callable) => `${callable.qualifiedName}\0${callable.kind}`);
+  const baseGroups = groupBy(base, (callable) => `${callable.qualifiedName}\0${callable.kind}`);
+  const added = [];
+  for (const [key, currentGroup] of currentGroups) {
+    const baseGroup = baseGroups.get(key) ?? [];
+    const unmatchedBase = new Set(baseGroup.map((_, index) => index));
+    const unmatchedCurrent = new Set(currentGroup.map((_, index) => index));
+    for (let currentIndex = 0; currentIndex < currentGroup.length; currentIndex += 1) {
+      const exactBaseIndex = [...unmatchedBase].find(
+        (baseIndex) => baseGroup[baseIndex].sourceHash === currentGroup[currentIndex].sourceHash
+      );
+      if (exactBaseIndex !== void 0) {
+        unmatchedBase.delete(exactBaseIndex);
+        unmatchedCurrent.delete(currentIndex);
+      }
+    }
+    for (const currentIndex of unmatchedCurrent) {
+      const baseIndex = unmatchedBase.values().next().value;
+      if (baseIndex === void 0) added.push(currentGroup[currentIndex].id);
+      else unmatchedBase.delete(baseIndex);
+    }
+  }
+  return added;
+}
+function normalizeProfile(profile) {
+  return {
+    provider: profile.provider,
+    model: profile.model,
+    dimensions: profile.dimensions,
+    strategyVersion: profile.strategyVersion ?? "callable-v1"
+  };
+}
+function emptyStats(checkpoint) {
+  return {
+    filesUpdated: 0,
+    filesDeleted: 0,
+    functionsAdded: 0,
+    functionsUpdated: 0,
+    functionsDeleted: 0,
+    embeddingsCreated: 0,
+    checkpoint
+  };
+}
+function validateRenames(renames) {
+  const sources = new Set(renames.map((rename) => rename.from));
+  const targets = new Set(renames.map((rename) => rename.to));
+  if (sources.size !== renames.length || targets.size !== renames.length) {
+    throw new CodeIndexError("Rename sources and targets must be unique.");
+  }
+  if ([...sources].some((source) => targets.has(source))) {
+    throw new CodeIndexError("Chained or cyclic renames must be applied in separate updates.");
+  }
+}
+function groupBy(values, keyFor) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const value of values) {
+    const key = keyFor(value);
+    const group = groups.get(key) ?? [];
+    group.push(value);
+    groups.set(key, group);
+  }
+  return groups;
+}
+
+// src/embeddings/http.ts
+async function requestEmbeddings(options) {
+  let lastError;
+  for (let attempt = 0; attempt < 3; attempt += 1) {
+    try {
+      const response = await fetch(options.url, {
+        method: "POST",
+        headers: {
+          authorization: `Bearer ${options.apiKey}`,
+          "content-type": "application/json"
+        },
+        body: JSON.stringify(options.body),
+        ...options.signal ? { signal: options.signal } : {}
+      });
+      if (!response.ok) {
+        const detail = (await response.text()).slice(0, 500);
+        const error = new CodeIndexError(`Embedding request failed (${response.status}): ${detail}`);
+        if (response.status !== 429 && response.status < 500) throw error;
+        lastError = error;
+      } else {
+        const payload = await response.json();
+        if (!Array.isArray(payload.data) || payload.data.length !== options.expectedCount) {
+          throw new CodeIndexError("Embedding provider returned an unexpected number of vectors.");
+        }
+        const indexes = payload.data.map((item) => item.index);
+        if (indexes.some((index) => !Number.isInteger(index)) || new Set(indexes).size !== options.expectedCount || indexes.some((index) => index < 0 || index >= options.expectedCount)) {
+          throw new CodeIndexError("Embedding provider returned invalid vector indexes.");
+        }
+        const ordered = new Array(options.expectedCount);
+        for (const item of payload.data) ordered[item.index] = item;
+        try {
+          return ordered.map((item) => normalizeEmbeddingVector(item.embedding, options.dimensions));
+        } catch {
+          throw new CodeIndexError("Embedding provider returned a malformed vector.");
+        }
+      }
+    } catch (error) {
+      if (options.signal?.aborted) throw error;
+      lastError = error;
+      if (error instanceof CodeIndexError && !/\((429|5\d\d)\)/.test(error.message)) throw error;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 250 * 2 ** attempt));
+  }
+  throw new CodeIndexError("Embedding request failed after three attempts.", { cause: lastError });
+}
+
+// src/embeddings/jina.ts
+var JinaEmbeddingProvider = class {
+  profile;
+  #apiKey;
+  #url;
+  constructor(options = {}) {
+    this.#apiKey = options.apiKey ?? process.env.JINA_API_KEY ?? "";
+    if (!this.#apiKey) throw new Error("JINA_API_KEY is required.");
+    const model = options.model ?? "jina-embeddings-v4";
+    const dimensions = options.dimensions ?? 1024;
+    if (!Number.isInteger(dimensions) || dimensions < 1) throw new Error("dimensions must be a positive integer.");
+    this.profile = {
+      provider: "jina",
+      model,
+      dimensions,
+      strategyVersion: "callable-v1:code-query-passage"
+    };
+    this.#url = options.baseUrl ?? "https://api.jina.ai/v1/embeddings";
+  }
+  embedDocuments(inputs, options) {
+    if (inputs.length === 0) return Promise.resolve([]);
+    return this.#embed(inputs, "code.passage", options?.signal);
+  }
+  async embedQuery(input, options) {
+    return (await this.#embed([input], "code.query", options?.signal))[0];
+  }
+  #embed(inputs, task, signal) {
+    return requestEmbeddings({
+      url: this.#url,
+      apiKey: this.#apiKey,
+      body: {
+        model: this.profile.model,
+        dimensions: this.profile.dimensions,
+        embedding_type: "float",
+        truncate: true,
+        task,
+        input: inputs
+      },
+      expectedCount: inputs.length,
+      dimensions: this.profile.dimensions,
+      ...signal ? { signal } : {}
+    });
+  }
+};
+
+// src/embeddings/openai.ts
+import { Tiktoken } from "js-tiktoken/lite";
+import cl100kBase from "js-tiktoken/ranks/cl100k_base";
+var MAX_INPUT_TOKENS = 8192;
+var tokenizer;
+function truncateInput(input) {
+  tokenizer ??= new Tiktoken(cl100kBase);
+  const tokens = tokenizer.encode(input);
+  return tokens.length <= MAX_INPUT_TOKENS ? input : tokenizer.decode(tokens.slice(0, MAX_INPUT_TOKENS));
+}
+var OpenAIEmbeddingProvider = class {
+  profile;
+  #apiKey;
+  #url;
+  constructor(options = {}) {
+    this.#apiKey = options.apiKey ?? process.env.OPENAI_API_KEY ?? "";
+    if (!this.#apiKey) throw new Error("OPENAI_API_KEY is required.");
+    const model = options.model ?? "text-embedding-3-small";
+    const dimensions = options.dimensions ?? 1536;
+    if (!Number.isInteger(dimensions) || dimensions < 1) throw new Error("dimensions must be a positive integer.");
+    this.profile = { provider: "openai", model, dimensions, strategyVersion: "callable-v1" };
+    this.#url = `${(options.baseUrl ?? "https://api.openai.com/v1").replace(/\/$/, "")}/embeddings`;
+  }
+  embedDocuments(inputs, options) {
+    if (inputs.length === 0) return Promise.resolve([]);
+    return this.#embed(inputs, options?.signal);
+  }
+  async embedQuery(input, options) {
+    return (await this.#embed([input], options?.signal))[0];
+  }
+  #embed(inputs, signal) {
+    return requestEmbeddings({
+      url: this.#url,
+      apiKey: this.#apiKey,
+      body: {
+        model: this.profile.model,
+        dimensions: this.profile.dimensions,
+        encoding_format: "float",
+        input: inputs.map(truncateInput)
+      },
+      expectedCount: inputs.length,
+      dimensions: this.profile.dimensions,
+      ...signal ? { signal } : {}
+    });
+  }
+};
+
+// src/format.ts
+function functionName(value) {
+  return `${value.path} :: ${value.qualifiedName}`;
+}
+function formatSimilaritySummary(matches, source) {
+  const lines = matches.map((match) => `${source ? "  " : ""}${match.similarity.toFixed(4)}  ${functionName(match.function)}`);
+  if (!source) return lines.length > 0 ? lines.join("\n") : "No matches.";
+  return [functionName(source), ...lines.length > 0 ? lines : ["  No matches."]].join("\n");
+}
+
+// src/search/cross-search.ts
+async function* crossSearch(options) {
+  const target = options.target ?? options.source;
+  const sourceProfile = JSON.stringify(options.source.status().embeddingProfile);
+  const targetProfile = JSON.stringify(target.status().embeddingProfile);
+  if (sourceProfile !== targetProfile) {
+    throw new IncompatibleIndexError("Cross-search requires identical embedding profiles.");
+  }
+  const limit = options.limitPerFunction ?? 5;
+  assertPositiveInteger(limit, "limitPerFunction");
+  const sourceFunctions = await options.source.sourceFunctions(options.sourceFilter ?? { type: "all" });
+  const sameIndex = target.indexPath === options.source.indexPath;
+  const seenPairs = /* @__PURE__ */ new Set();
+  for (let index = 0; index < sourceFunctions.length; index += 1) {
+    throwIfAborted(options.signal);
+    const source = sourceFunctions[index];
+    const vector = options.source.vectorForFunction(source.id);
+    const candidates = sameIndex ? options.source.similarToFunction(source.id, {
+      limit,
+      minSimilarity: options.minSimilarity ?? -1,
+      ...options.maxSimilarity !== void 0 ? { maxSimilarity: options.maxSimilarity } : {}
+    }) : target.searchByVector(vector, {
+      limit,
+      minSimilarity: options.minSimilarity ?? -1,
+      ...options.maxSimilarity !== void 0 ? { maxSimilarity: options.maxSimilarity } : {}
+    });
+    const matches = sameIndex && !options.includeSymmetricDuplicates ? candidates.filter((match) => {
+      const pair = source.id < match.function.id ? `${source.id}:${match.function.id}` : `${match.function.id}:${source.id}`;
+      if (seenPairs.has(pair)) return false;
+      seenPairs.add(pair);
+      return true;
+    }) : candidates;
+    if (matches.length > 0) yield { source, matches };
+    options.onProgress?.({ completed: index + 1, total: sourceFunctions.length });
+  }
+}
+
+// src/cli.ts
+var parsed = parseArgs({
+  args: process.argv.slice(2),
+  allowPositionals: true,
+  strict: true,
+  options: {
+    root: { type: "string", default: process.cwd() },
+    config: { type: "string" },
+    index: { type: "string" },
+    provider: { type: "string" },
+    model: { type: "string" },
+    dimensions: { type: "string" },
+    target: { type: "string" },
+    "target-root": { type: "string" },
+    "target-index": { type: "string" },
+    "added-since": { type: "string" },
+    "source-path": { type: "string" },
+    limit: { type: "string" },
+    "min-similarity": { type: "string" },
+    threshold: { type: "string" },
+    format: { type: "string" },
+    "include-symmetric-duplicates": { type: "boolean", default: false },
+    "rebuild-on-divergence": { type: "boolean", default: false },
+    help: { type: "boolean", short: "h", default: false }
+  }
+});
+var [command, ...positionals] = parsed.positionals;
+if (parsed.values.help || !command) {
+  printHelp();
+  process.exit(parsed.values.help ? 0 : 1);
+}
+void main().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  process.stderr.write(`slopdex: ${message}
+`);
+  process.exitCode = error instanceof CodeIndexError ? 2 : 1;
+});
+async function main() {
+  const rootDir = path7.resolve(parsed.values.root);
+  const config = loadConfig(rootDir, parsed.values.config);
+  const provider = createProvider(config);
+  const indexOptions = {
+    rootDir,
+    provider,
+    onWarning: (message) => process.stderr.write(`slopdex: warning: ${message}
+`),
+    ...parsed.values.index || config.indexPath ? { indexPath: parsed.values.index ?? config.indexPath } : {},
+    ...config.include ? { include: config.include } : {},
+    ...config.exclude ? { exclude: config.exclude } : {},
+    ...config.maxFileSize ? { maxFileSize: config.maxFileSize } : {},
+    ...config.embeddingBatchSize ? { embeddingBatchSize: config.embeddingBatchSize } : {}
+  };
+  const initialized = await initializeMissingIndex(
+    indexOptions,
+    "index",
+    command === "update-git" ? parsed.values.target ?? "HEAD" : "HEAD"
+  );
+  const index = new CodeIndex(indexOptions);
+  try {
+    switch (command) {
+      case "status":
+        printJson(index.status());
+        break;
+      case "update-files":
+        if (positionals.length === 0) throw new CodeIndexError("update-files requires at least one path.");
+        printJson(await index.updateFiles({ upsert: positionals }));
+        break;
+      case "delete-files":
+        if (positionals.length === 0) throw new CodeIndexError("delete-files requires at least one path.");
+        printJson(await index.updateFiles({ delete: positionals }));
+        break;
+      case "update-git": {
+        const stats = initialized ?? await index.updateFromGit({
+          ...parsed.values.target ? { target: parsed.values.target } : {},
+          rebuildOnDivergence: parsed.values["rebuild-on-divergence"]
+        });
+        printJson(stats);
+        break;
+      }
+      case "search": {
+        const query = positionals.join(" ").trim();
+        if (!query) throw new CodeIndexError("search requires a query.");
+        const threshold = similarityThreshold();
+        const results = await index.similaritySearch({
+          query,
+          limit: numberOption(parsed.values.limit, 10, "limit"),
+          minSimilarity: threshold.min,
+          ...threshold.max !== void 0 ? { maxSimilarity: threshold.max } : {}
+        });
+        if (outputFormat() === "summary") process.stdout.write(`${formatSimilaritySummary(results)}
+`);
+        else printJson(results.map(presentMatch));
+        break;
+      }
+      case "cross-search":
+        await runCrossSearch(index, indexOptions, provider);
+        break;
+      default:
+        throw new CodeIndexError(`Unknown command: ${command}`);
+    }
+  } finally {
+    index.close();
+  }
+}
+async function runCrossSearch(source, sourceOptions, provider) {
+  const targetRoot = parsed.values["target-root"];
+  const targetPath = parsed.values["target-index"];
+  if (targetRoot && !targetPath || !targetRoot && targetPath) {
+    throw new CodeIndexError("Cross-index search requires both --target-root and --target-index.");
+  }
+  const targetOptions = targetRoot && targetPath ? {
+    ...sourceOptions,
+    rootDir: path7.resolve(targetRoot),
+    indexPath: path7.resolve(targetPath),
+    provider
+  } : void 0;
+  if (targetOptions) await initializeMissingIndex(targetOptions, "target index", "HEAD");
+  const target = targetOptions ? new CodeIndex({ ...targetOptions, readOnly: true }) : void 0;
+  const format = outputFormat();
+  const threshold = similarityThreshold();
+  try {
+    for await (const result of crossSearch({
+      source,
+      ...target ? { target } : {},
+      sourceFilter: parsed.values["added-since"] ? {
+        type: "added-since",
+        commit: parsed.values["added-since"],
+        ...parsed.values["source-path"] ? { path: parsed.values["source-path"] } : {}
+      } : {
+        type: "all",
+        ...parsed.values["source-path"] ? { path: parsed.values["source-path"] } : {}
+      },
+      limitPerFunction: numberOption(parsed.values.limit, 5, "limit"),
+      minSimilarity: threshold.min,
+      ...threshold.max !== void 0 ? { maxSimilarity: threshold.max } : {},
+      includeSymmetricDuplicates: parsed.values["include-symmetric-duplicates"]
+    })) {
+      if (format === "summary") {
+        process.stdout.write(`${formatSimilaritySummary(result.matches, result.source)}
+`);
+      } else {
+        process.stdout.write(`${JSON.stringify({
+          source: presentFunction(result.source),
+          matches: result.matches.map(presentMatch)
+        })}
+`);
+      }
+    }
+  } finally {
+    target?.close();
+  }
+}
+async function initializeMissingIndex(options, label, target) {
+  const indexPath = path7.resolve(options.indexPath ?? path7.join(path7.resolve(options.rootDir), ".slopdex", "index.sqlite"));
+  if (existsSync(indexPath)) return null;
+  process.stderr.write(`slopdex: ${label} not found at ${indexPath}; initializing automatically from committed ${target}.
+`);
+  const index = new CodeIndex({ ...options, indexPath });
+  let initialized = false;
+  try {
+    const stats = await index.updateFromGit({ target });
+    initialized = true;
+    return stats;
+  } finally {
+    index.close();
+    if (!initialized) {
+      for (const suffix of ["", "-shm", "-wal", "-journal"]) rmSync(`${indexPath}${suffix}`, { force: true });
+    }
+  }
+}
+function loadConfig(rootDir, configuredPath) {
+  const configPath = path7.resolve(configuredPath ?? path7.join(rootDir, ".slopdex", "config.json"));
+  if (!existsSync(configPath)) return commandLineConfig({});
+  const value = JSON.parse(readFileSync(configPath, "utf8"));
+  return commandLineConfig(value);
+}
+function commandLineConfig(config) {
+  const dimensions = parsed.values.dimensions ? numberOption(parsed.values.dimensions, 0, "dimensions") : config.dimensions;
+  const providerValue = parsed.values.provider ?? config.provider;
+  if (providerValue !== void 0 && providerValue !== "openai" && providerValue !== "jina") {
+    throw new CodeIndexError(`Unsupported provider: ${providerValue}`);
+  }
+  const provider = providerValue === "openai" || providerValue === "jina" ? providerValue : void 0;
+  return {
+    ...config,
+    ...provider ? { provider } : {},
+    ...parsed.values.model ? { model: parsed.values.model } : {},
+    ...dimensions ? { dimensions } : {}
+  };
+}
+function createProvider(config) {
+  if ((config.provider ?? "openai") === "jina") {
+    return new JinaEmbeddingProvider({
+      ...config.model ? { model: config.model } : {},
+      ...config.dimensions ? { dimensions: config.dimensions } : {}
+    });
+  }
+  return new OpenAIEmbeddingProvider({
+    ...config.model ? { model: config.model } : {},
+    ...config.dimensions ? { dimensions: config.dimensions } : {}
+  });
+}
+function numberOption(value, defaultValue, name) {
+  if (value === void 0) return defaultValue;
+  const parsedValue = Number(value);
+  if (!Number.isFinite(parsedValue)) throw new CodeIndexError(`${name} must be a number.`);
+  return parsedValue;
+}
+function similarityThreshold() {
+  const threshold = parsed.values.threshold;
+  const minimum = parsed.values["min-similarity"];
+  if (threshold !== void 0 && minimum !== void 0) {
+    throw new CodeIndexError("Use either --threshold or --min-similarity, not both.");
+  }
+  if (threshold === void 0) return { min: numberOption(minimum, -1, "min-similarity") };
+  const number = "[+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:e[+-]?\\d+)?";
+  const range = new RegExp(`^\\s*(${number})\\s*-\\s*(${number})\\s*$`, "i").exec(threshold);
+  if (!range) return { min: numberOption(threshold, -1, "threshold") };
+  const min = Number(range[1]);
+  const max = Number(range[2]);
+  if (!Number.isFinite(min) || !Number.isFinite(max)) throw new CodeIndexError("threshold range bounds must be numbers.");
+  if (min > max) throw new CodeIndexError("threshold range minimum must not exceed its maximum.");
+  return { min, max };
+}
+function outputFormat() {
+  const value = parsed.values.format ?? "json";
+  if (value !== "json" && value !== "summary") throw new CodeIndexError("format must be json or summary.");
+  return value;
+}
+function presentFunction(value) {
+  const { embeddingInput: _embeddingInput, embeddingId: _embeddingId, ...result } = value;
+  return result;
+}
+function presentMatch(value) {
+  return { similarity: value.similarity, function: presentFunction(value.function) };
+}
+function printJson(value) {
+  process.stdout.write(`${JSON.stringify(value, null, 2)}
+`);
+}
+function printHelp() {
+  process.stdout.write(`Usage: slopdex <command> [arguments] [options]
+
+Commands:
+  status                              Show index metadata
+  update-files <path...>              Index specific working-tree files
+  delete-files <path...>              Remove specific files from the index
+  update-git                          Index committed changes since the checkpoint
+  search <query>                      Search functions by semantic similarity
+  cross-search                        Find nearest functions for each source function
+
+Options:
+  --root <path>                       Repository root (default: current directory)
+  --config <path>                     Config file (default: .slopdex/config.json)
+  --index <path>                      SQLite index path
+  --provider <openai|jina>            Embedding provider
+  --model <name>                      Embedding model
+  --dimensions <number>               Embedding dimensions
+  --target <ref>                      Target ref for update-git (default: HEAD)
+  --rebuild-on-divergence             Rebuild after a rebase or branch change
+  --limit <number>                    Search result limit
+  --threshold <number|range>          Show similarities at/above a value or within a range
+  --min-similarity <number>           Minimum raw cosine similarity
+  --format <json|summary>             Similarity output format (default: json)
+  --include-symmetric-duplicates      Show both directions of same-index matches
+  --added-since <commit>              Restrict cross-search source functions
+  --source-path <path>                Restrict cross-search sources to a file or directory
+  --target-root <path>                Root of a second indexed codebase
+  --target-index <path>               SQLite path of a second index
+
+Examples:
+  Show metadata for the current index:
+    slopdex status
+
+  Index specific working-tree files:
+    slopdex update-files src/service.ts src/model.ts
+
+  Remove deleted files from the index:
+    slopdex delete-files src/removed.ts
+
+  Index the latest committed Git snapshot:
+    slopdex update-git --target HEAD
+
+  Find functions matching a semantic query:
+    slopdex search "validate an authenticated session" --limit 10
+
+  Review similar functions as duplicate-code candidates:
+    slopdex cross-search --format summary --threshold 0.8 --limit 5
+
+  Review functions under a path against the whole codebase:
+    slopdex cross-search --source-path src/services --format summary
+`);
+}
+//# sourceMappingURL=cli.js.map