@ninjaxtools/slopdex 0.3.0 → 0.6.0

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/code-index.ts
-import { lstat, readFile } from "node:fs/promises";
+import { lstat as lstat2, readFile, readdir } from "node:fs/promises";
 import path6 from "node:path";
 
 // src/errors.ts
@@ -15,6 +15,12 @@ var GitDivergenceError = class extends CodeIndexError {
     this.name = "GitDivergenceError";
   }
 };
+var GitUnavailableError = class extends CodeIndexError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "GitUnavailableError";
+  }
+};
 var IncompatibleIndexError = class extends CodeIndexError {
   constructor(message) {
     super(message);
@@ -24,6 +30,7 @@ var IncompatibleIndexError = class extends CodeIndexError {
 
 // src/git/repository.ts
 import { spawn } from "node:child_process";
+import { lstat } from "node:fs/promises";
 import path from "node:path";
 var GitRepository = class {
   constructor(rootDir) {
@@ -37,7 +44,13 @@ var GitRepository = class {
       const stderr = [];
       child.stdout.on("data", (value) => stdout.push(value));
       child.stderr.on("data", (value) => stderr.push(value));
-      child.on("error", reject);
+      child.on("error", (error) => {
+        if (error.code === "ENOENT") {
+          reject(new GitUnavailableError("Git executable is not available.", { cause: error }));
+          return;
+        }
+        reject(error);
+      });
       child.on("close", (code) => {
         const exitCode = code ?? -1;
         if (exitCode === 0 || allowExitOne && exitCode === 1) {
@@ -49,29 +62,51 @@ var GitRepository = class {
     });
   }
   async assertRepository() {
-    const result = await this.#run(["rev-parse", "--is-inside-work-tree"]);
+    let result;
+    try {
+      result = await this.#run(["rev-parse", "--is-inside-work-tree"]);
+    } catch (error) {
+      if (error instanceof GitUnavailableError) throw error;
+      try {
+        await lstat(path.join(this.rootDir, ".git"));
+      } catch (markerError) {
+        if (markerError.code === "ENOENT") {
+          throw new GitUnavailableError(`${this.rootDir} is not a Git worktree.`, { cause: error });
+        }
+        throw markerError;
+      }
+      throw error;
+    }
     if (result.stdout.toString("utf8").trim() !== "true") {
-      throw new CodeIndexError(`${this.rootDir} is not a Git worktree.`);
+      throw new GitUnavailableError(`${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 = []) {
+  async workTreeChanges(base, excludePaths = []) {
     const pathspecs = [".", ...excludePaths.map((filePath) => `:(top,literal,exclude)${filePath}`)];
     const result = await this.#run([
-      "status",
-      "--porcelain=v1",
+      "diff",
+      "--name-status",
       "-z",
-      "--untracked-files=all",
-      "--ignore-submodules=none",
+      "--find-renames",
+      base,
       "--",
       ...pathspecs
     ]);
-    if (result.stdout.length > 0) {
-      throw new CodeIndexError("Cannot update from Git: the working tree has uncommitted changes. Commit or stash them first.");
-    }
+    const changes = parseChanges(splitNull(result.stdout));
+    const untracked = await this.#run([
+      "ls-files",
+      "--others",
+      "--exclude-standard",
+      "-z",
+      "--",
+      ...pathspecs
+    ]);
+    for (const filePath of splitNull(untracked.stdout)) changes.push({ status: "A", path: filePath });
+    return changes;
   }
   async resolveCommit(ref) {
     const result = await this.#run(["rev-parse", "--verify", "--end-of-options", `${ref}^{commit}`]);
@@ -103,26 +138,28 @@ var GitRepository = class {
   }
   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;
+    return parseChanges(splitNull(result.stdout));
   }
 };
+function parseChanges(values) {
+  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");
@@ -446,6 +483,7 @@ function parseCallables(relativePath, content, onWarning = console.warn) {
       startColumn: node.startPosition.column + 1,
       endLine: node.endPosition.row + 1,
       endColumn: node.endPosition.column + 1,
+      lineCount: node.endPosition.row - node.startPosition.row + 1,
       source,
       sourceHash: sha256(source),
       embeddingInput
@@ -475,18 +513,24 @@ var SourcePolicy = class {
   includes(relativePath) {
     const normalized = relativePath.replaceAll("\\", "/");
     if (!languageForPath(normalized)) return false;
-    if (normalized.split("/").some((segment) => DEFAULT_EXCLUDED_SEGMENTS.has(segment))) return false;
+    if (hasExcludedSegment(normalized)) 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));
   }
+  traversesDirectory(relativePath) {
+    return !hasExcludedSegment(relativePath.replaceAll("\\", "/"));
+  }
 };
+function hasExcludedSegment(relativePath) {
+  return relativePath.split("/").some((segment) => DEFAULT_EXCLUDED_SEGMENTS.has(segment));
+}
 
 // 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 SCHEMA_VERSION = "2";
 var IndexDatabase = class {
   #db;
   #rootDir;
@@ -498,15 +542,30 @@ var IndexDatabase = class {
     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();
+    try {
+      sqliteVec.load(this.#db);
+      this.#db.enableLoadExtension(false);
+      const regexes = /* @__PURE__ */ new Map();
+      this.#db.function("slopdex_regexp", { deterministic: true }, (pattern, value) => {
+        if (typeof pattern !== "string" || typeof value !== "string") return 0;
+        let regex = regexes.get(pattern);
+        if (!regex) {
+          regex = new RegExp(pattern);
+          regexes.set(pattern, regex);
+        }
+        return regex.test(value) ? 1 : 0;
+      });
+      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);
+    } catch (error) {
+      this.#db.close();
+      throw error;
     }
-    this.#validateMetadata(readOnly);
   }
   close() {
     this.#db.close();
@@ -545,6 +604,7 @@ var IndexDatabase = class {
         start_column INTEGER NOT NULL,
         end_line INTEGER NOT NULL,
         end_column INTEGER NOT NULL,
+        line_count INTEGER NOT NULL,
         source TEXT NOT NULL,
         source_hash TEXT NOT NULL,
         embedding_input TEXT NOT NULL,
@@ -553,13 +613,31 @@ var IndexDatabase = class {
         source_mode TEXT NOT NULL CHECK(source_mode IN ('git', 'working-tree')),
         embedding_id INTEGER NOT NULL REFERENCES embeddings(id)
       );
+      CREATE TABLE IF NOT EXISTS callable_provenance (
+        identity_key TEXT NOT NULL,
+        source_hash TEXT NOT NULL,
+        first_seen_commit TEXT NOT NULL,
+        PRIMARY KEY(identity_key, source_hash)
+      );
       CREATE INDEX IF NOT EXISTS functions_path ON functions(path);
       CREATE INDEX IF NOT EXISTS functions_embedding ON functions(embedding_id);
+      INSERT OR IGNORE INTO callable_provenance(identity_key, source_hash, first_seen_commit)
+        SELECT identity_key, source_hash, first_seen_commit FROM functions WHERE first_seen_commit IS NOT NULL;
     `);
     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");
     }
+    const functionColumns = this.#db.prepare("PRAGMA table_info(functions)").all();
+    const needsLineCount = !functionColumns.some((column) => column.name === "line_count");
+    const schemaVersion = this.#metadata("schema_version");
+    if (needsLineCount || schemaVersion === "1") {
+      this.#transaction(() => {
+        if (needsLineCount) this.#db.exec("ALTER TABLE functions ADD COLUMN line_count INTEGER NOT NULL DEFAULT 1");
+        this.#db.exec("UPDATE functions SET line_count = end_line - start_line + 1");
+        if (schemaVersion === "1") this.#setMetadata("schema_version", SCHEMA_VERSION);
+      });
+    }
   }
   #metadata(key) {
     const row = this.#db.prepare("SELECT value FROM metadata WHERE key = ?").get(key);
@@ -571,6 +649,9 @@ var IndexDatabase = class {
       ON CONFLICT(key) DO UPDATE SET value = excluded.value
     `).run(key, value);
   }
+  #deleteMetadata(key) {
+    this.#db.prepare("DELETE FROM metadata WHERE key = ?").run(key);
+  }
   #validateMetadata(readOnly) {
     const schemaVersion = this.#metadata("schema_version");
     if (readOnly && !schemaVersion) throw new IncompatibleIndexError("Target file is not a slopdex index.");
@@ -619,6 +700,13 @@ var IndexDatabase = class {
       FROM files WHERE source_mode = 'working-tree' ORDER BY path
     `).all();
   }
+  getFileStates() {
+    return this.#db.prepare(`
+      SELECT path, content_hash AS contentHash, blob_oid AS blobOid,
+        source_mode AS sourceMode, previous_path AS previousPath
+      FROM files ORDER BY path
+    `).all();
+  }
   getEmbeddingKeys(keys) {
     const found = /* @__PURE__ */ new Set();
     const statement = this.#db.prepare("SELECT 1 FROM embeddings WHERE embedding_key = ?");
@@ -632,36 +720,44 @@ var IndexDatabase = class {
       if (options.expectedCheckpoint !== void 0 && this.getCheckpoint() !== options.expectedCheckpoint) {
         throw new CodeIndexError("Git checkpoint changed while the update was being prepared.");
       }
+      if (options.expectedGeneration !== void 0 && this.getGeneration() !== options.expectedGeneration) {
+        throw new CodeIndexError("Index changed while the update was being prepared; retry the update.");
+      }
       const stats = {
-        filesUpdated: options.files.length,
+        filesUpdated: 0,
         filesDeleted: 0,
         functionsAdded: 0,
         functionsUpdated: 0,
         functionsDeleted: 0,
         embeddingsCreated: 0,
-        checkpoint: options.checkpoint ?? this.getCheckpoint()
+        checkpoint: options.checkpoint !== void 0 ? 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;
+      const applyStage = (files, deletePaths) => {
+        stats.filesUpdated += files.length;
+        const uniqueDeletes = new Set(deletePaths);
+        for (const file of files) {
+          uniqueDeletes.delete(file.path);
+          if (file.previousPath) uniqueDeletes.delete(file.previousPath);
+          if (file.replacePath) uniqueDeletes.delete(file.replacePath);
         }
-      }
-      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)");
+        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 files) this.#replaceFile(file, stats);
+      };
+      applyStage(options.files, options.deletePaths);
+      if (options.workingTree) applyStage(options.workingTree.files, options.workingTree.deletePaths);
       const generation = this.getGeneration() + 1;
       this.#setMetadata("generation", String(generation));
-      if (options.checkpoint) this.#setMetadata("git_checkpoint", options.checkpoint);
+      if (options.checkpoint === null) this.#deleteMetadata("git_checkpoint");
+      else if (options.checkpoint !== void 0) this.#setMetadata("git_checkpoint", options.checkpoint);
       return stats;
     });
   }
@@ -671,6 +767,12 @@ var IndexDatabase = class {
     const existingFile = this.#db.prepare("SELECT previous_path FROM files WHERE path = ?").get(sourcePath);
     const oldMatches = reconcileFunctions(file.callables, oldRows);
     if (sourcePath !== file.path) {
+      const displacedRows = this.#rowsForPath(file.path);
+      const displaced = this.#db.prepare("DELETE FROM files WHERE path = ?").run(file.path);
+      if (displaced.changes > 0) {
+        stats.filesDeleted += 1;
+        stats.functionsDeleted += displacedRows.length;
+      }
       this.#db.prepare("DELETE FROM files WHERE path = ?").run(sourcePath);
     } else {
       this.#db.prepare("DELETE FROM files WHERE path = ?").run(file.path);
@@ -702,13 +804,16 @@ var IndexDatabase = class {
       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;
+      const remembered = this.#db.prepare(`
+        SELECT first_seen_commit FROM callable_provenance WHERE identity_key = ? AND source_hash = ?
+      `).get(callable.identityKey, callable.sourceHash);
+      const firstSeenCommit = old?.first_seen_commit ?? remembered?.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,
+          start_line, start_column, end_line, end_column, line_count, source, source_hash,
           embedding_input, first_seen_commit, last_seen_commit, source_mode, embedding_id
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
       `).run(
         old?.id ?? null,
         file.path,
@@ -722,6 +827,7 @@ var IndexDatabase = class {
         callable.startColumn,
         callable.endLine,
         callable.endColumn,
+        callable.lineCount,
         callable.source,
         callable.sourceHash,
         callable.embeddingInput,
@@ -732,6 +838,11 @@ var IndexDatabase = class {
       );
       if (old) stats.functionsUpdated += 1;
       else stats.functionsAdded += 1;
+      if (firstSeenCommit) {
+        this.#db.prepare(`
+          INSERT OR IGNORE INTO callable_provenance(identity_key, source_hash, first_seen_commit) VALUES (?, ?, ?)
+        `).run(callable.identityKey, callable.sourceHash, firstSeenCommit);
+      }
     }
     stats.functionsDeleted += oldRows.length - usedIds.size;
   }
@@ -754,19 +865,28 @@ var IndexDatabase = class {
     return results;
   }
   searchVector(vector, options) {
+    const excludePaths = options.excludePaths ?? [];
+    const pathFilter = excludePaths.length > 0 ? `AND f.path NOT IN (${excludePaths.map(() => "?").join(", ")})` : "";
     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 != ?)
+        ${pathFilter}
+        AND f.line_count >= ?
+        AND (? IS NULL OR slopdex_regexp(?, f.qualified_name))
         AND (1.0 - vec_distance_cosine(e.vector, ?)) >= ?
-        AND (? IS NULL OR (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,
+      ...excludePaths,
+      options.minLines ?? 1,
+      options.nameRegex ?? null,
+      options.nameRegex ?? null,
       vectorBuffer(vector),
       options.minSimilarity,
       options.maxSimilarity ?? null,
@@ -815,6 +935,7 @@ function toIndexedFunction(row) {
     startColumn: row.start_column,
     endLine: row.end_line,
     endColumn: row.end_column,
+    lineCount: row.line_count,
     source: row.source,
     sourceHash: row.source_hash,
     embeddingInput: row.embedding_input,
@@ -909,7 +1030,7 @@ var CodeIndex = class {
       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);
+      const info = await lstat2(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}`);
@@ -930,50 +1051,210 @@ var CodeIndex = class {
       deletePaths: [...deletePaths, ...renameMap.values()]
     });
   }
+  async updateFromWorkingTree(options = {}) {
+    throwIfAborted(options.signal);
+    const generation = this.#database.getGeneration();
+    const indexedFiles = this.#database.getFileStates();
+    const sourcePaths = await this.#workingTreeSourcePaths(options.signal);
+    const prepared = [];
+    const skippedPaths = /* @__PURE__ */ new Set();
+    for (const relativePath of sourcePaths) {
+      throwIfAborted(options.signal);
+      const absolutePath = path6.join(this.rootDir, relativePath);
+      const info = await lstat2(absolutePath);
+      if (!info.isFile() || info.isSymbolicLink() || info.size > this.#maxFileSize) {
+        skippedPaths.add(relativePath);
+        continue;
+      }
+      const content = await readFile(absolutePath);
+      prepared.push(this.#prepareFile(relativePath, content, {
+        blobOid: null,
+        sourceMode: "working-tree",
+        indexedCommit: null
+      }));
+    }
+    await this.#attachEmbeddings(prepared, options.signal);
+    const pathsAgain = await this.#workingTreeSourcePaths(options.signal);
+    if (JSON.stringify(pathsAgain) !== JSON.stringify(sourcePaths)) {
+      throw new CodeIndexError("Working-tree files changed while indexing; retry the update.");
+    }
+    for (const file of prepared) {
+      try {
+        const info = await lstat2(path6.join(this.rootDir, file.path));
+        const content = await readFile(path6.join(this.rootDir, file.path));
+        if (!info.isFile() || info.isSymbolicLink() || info.size > this.#maxFileSize || sha256(content.toString("utf8")) !== file.contentHash) {
+          throw new CodeIndexError(`Working-tree file changed while indexing: ${file.path}`);
+        }
+      } catch (error) {
+        if (error instanceof CodeIndexError) throw error;
+        throw new CodeIndexError(`Working-tree file changed while indexing: ${file.path}`, { cause: error });
+      }
+    }
+    for (const relativePath of skippedPaths) {
+      const info = await lstat2(path6.join(this.rootDir, relativePath));
+      if (info.isFile() && !info.isSymbolicLink() && info.size <= this.#maxFileSize) {
+        throw new CodeIndexError(`Working-tree file changed while indexing: ${relativePath}`);
+      }
+    }
+    return this.#database.applyUpdate({
+      files: prepared,
+      deletePaths: indexedFiles.map((file) => file.path),
+      checkpoint: null,
+      expectedGeneration: generation
+    });
+  }
   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 head = await this.#git.resolveCommit("HEAD");
+    const overlayWorkingTree = target === head && options.includeWorkingTree !== false;
     const checkpoint = this.#database.getCheckpoint();
-    let rebuild = checkpoint === null;
+    const generation = this.#database.getGeneration();
+    let reconcileAll = checkpoint === null;
     if (checkpoint && !await this.#git.isAncestor(checkpoint, target)) {
       if (!options.rebuildOnDivergence) throw new GitDivergenceError(checkpoint, target);
-      rebuild = true;
+      reconcileAll = true;
     }
     const tree = await this.#git.listTree(target);
-    const workingFiles = this.#database.getWorkingTreeFiles();
-    const changes = rebuild || !checkpoint ? [] : await this.#git.diff(checkpoint, target);
+    const indexedFiles = this.#database.getFileStates();
+    const indexedByPath = new Map(indexedFiles.map((file) => [file.path, file]));
+    const workingFiles = indexedFiles.filter((file) => file.sourceMode === "working-tree");
+    const workingChanges = overlayWorkingTree ? await this.#git.workTreeChanges(target, indexArtifacts) : [];
+    const visibleWorkingPaths = new Set(
+      workingChanges.filter((change) => change.status !== "D").map((change) => change.path)
+    );
+    const changes = reconcileAll || !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 });
+    const eligibleEntries = [...tree.values()].filter((entry) => this.#policy.includes(entry.path) && entry.size <= this.#maxFileSize);
+    const eligibleTargetPaths = new Set(eligibleEntries.map((entry) => entry.path));
+    if (reconcileAll) {
+      const renameCandidates = indexedFiles.filter((file) => file.sourceMode === "git" && file.blobOid && !eligibleTargetPaths.has(file.path));
+      const claimedRenameSources = /* @__PURE__ */ new Set();
+      for (const entry of eligibleEntries) {
+        const indexed = indexedByPath.get(entry.path);
+        if (indexed?.sourceMode === "git" && indexed.blobOid === entry.oid) continue;
+        const matches = renameCandidates.filter((candidate) => candidate.blobOid === entry.oid && !claimedRenameSources.has(candidate.path));
+        const previousPath = matches.length === 1 ? matches[0].path : void 0;
+        if (previousPath) claimedRenameSources.add(previousPath);
+        upserts.set(entry.path, { entry, ...previousPath ? { previousPath } : {} });
+      }
+      for (const indexed of indexedFiles) {
+        if (!eligibleTargetPaths.has(indexed.path)) deletes.add(indexed.path);
       }
     } 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());
+      const indexedPaths = new Set(indexedByPath.keys());
       for (const targetPath of eligibleTargetPaths) {
-        if (!indexedPaths.has(targetPath) && !upserts.has(targetPath)) {
-          upserts.set(targetPath, { entry: tree.get(targetPath) });
+        const indexed = indexedByPath.get(targetPath);
+        const entry = tree.get(targetPath);
+        if ((!indexed || indexed.sourceMode === "git" && indexed.blobOid !== entry.oid) && !upserts.has(targetPath)) {
+          upserts.set(targetPath, { entry });
         }
       }
       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);
+    for (const dirtyFile of workingFiles) {
+      const entry = tree.get(dirtyFile.path);
+      const previousEntry = dirtyFile.previousPath ? tree.get(dirtyFile.previousPath) : void 0;
+      if (previousEntry && this.#policy.includes(previousEntry.path) && previousEntry.size <= this.#maxFileSize && (entry !== void 0 || !visibleWorkingPaths.has(dirtyFile.path))) {
+        const currentPlan = entry ? upserts.get(dirtyFile.path) : void 0;
+        upserts.delete(dirtyFile.path);
+        upserts.delete(previousEntry.path);
+        upserts.set(previousEntry.path, { entry: previousEntry, previousPath: dirtyFile.path });
+        if (entry && this.#policy.includes(entry.path) && entry.size <= this.#maxFileSize) {
+          upserts.set(dirtyFile.path, currentPlan ?? { entry });
+        }
+        continue;
+      }
+      if (entry && this.#policy.includes(dirtyFile.path) && entry.size <= this.#maxFileSize) {
+        const planned = upserts.get(dirtyFile.path);
+        if (planned?.previousPath && !indexedByPath.has(planned.previousPath)) {
+          upserts.set(dirtyFile.path, { entry, previousPath: dirtyFile.path });
+        } else if (!planned) {
+          upserts.set(dirtyFile.path, { entry });
+        }
+        continue;
+      }
+      if (previousEntry && this.#policy.includes(previousEntry.path) && previousEntry.size <= this.#maxFileSize) {
+        upserts.set(previousEntry.path, { entry: previousEntry, previousPath: dirtyFile.path });
+      } else {
+        deletes.add(dirtyFile.path);
+      }
+    }
+    for (const [filePath, { entry, previousPath }] of upserts) {
+      const indexed = indexedByPath.get(filePath);
+      if (!previousPath && indexed?.sourceMode === "git" && indexed.blobOid === entry.oid) upserts.delete(filePath);
+    }
+    const workingPrepared = [];
+    const workingDeletes = /* @__PURE__ */ new Set();
+    const skippedWorkingPaths = /* @__PURE__ */ new Set();
+    for (const change of workingChanges) {
+      throwIfAborted(options.signal);
+      if (change.status === "D") {
+        upserts.delete(change.path);
+        workingDeletes.add(change.path);
+        continue;
+      }
+      let previousPath;
+      let replacePath;
+      if (change.status === "R") {
+        const plannedBase = upserts.get(change.oldPath);
+        const existingAtTarget = indexedByPath.get(change.oldPath);
+        const existingAtFinal = indexedByPath.get(change.path);
+        const continuingRename = existingAtFinal?.sourceMode === "working-tree" && existingAtFinal.previousPath === change.oldPath;
+        replacePath = continuingRename ? change.path : existingAtTarget ? change.oldPath : existingAtFinal ? change.path : plannedBase?.previousPath && indexedByPath.has(plannedBase.previousPath) ? plannedBase.previousPath : void 0;
+        previousPath = existingAtFinal?.previousPath ?? change.oldPath;
+        upserts.delete(change.oldPath);
+        upserts.delete(change.path);
+        if (replacePath) deletes.delete(replacePath);
+        workingDeletes.add(change.oldPath);
+      } else {
+        const planned = upserts.get(change.path);
+        const existing = indexedByPath.get(change.path);
+        replacePath = existing ? change.path : planned?.previousPath && indexedByPath.has(planned.previousPath) ? planned.previousPath : void 0;
+        previousPath = existing?.previousPath ?? planned?.previousPath;
+        upserts.delete(change.path);
+        if (replacePath) deletes.delete(replacePath);
+      }
+      const relativePath = change.path;
+      if (!this.#policy.includes(relativePath)) {
+        if (replacePath) workingDeletes.add(replacePath);
+        workingDeletes.add(relativePath);
+        continue;
+      }
+      const absolutePath = path6.join(this.rootDir, relativePath);
+      const info = await lstat2(absolutePath);
+      if (!info.isFile() || info.isSymbolicLink() || info.size > this.#maxFileSize) {
+        if (replacePath) workingDeletes.add(replacePath);
+        workingDeletes.add(relativePath);
+        skippedWorkingPaths.add(relativePath);
+        continue;
+      }
+      const content = await readFile(absolutePath);
+      if (!replacePath && change.status === "A") {
+        const contentHash = sha256(content.toString("utf8"));
+        const renameCandidates = workingFiles.filter((file) => file.path !== relativePath && !visibleWorkingPaths.has(file.path) && deletes.has(file.path) && file.contentHash === contentHash);
+        const renamed = renameCandidates.length === 1 ? renameCandidates[0] : void 0;
+        if (renamed) {
+          replacePath = renamed.path;
+          previousPath = renamed.previousPath ?? renamed.path;
+          deletes.delete(renamed.path);
+        }
+      }
+      workingPrepared.push(this.#prepareFile(relativePath, content, {
+        blobOid: null,
+        sourceMode: "working-tree",
+        indexedCommit: null,
+        ...previousPath ? { previousPath } : {},
+        ...replacePath ? { replacePath } : {}
+      }));
+    }
     const prepared = [];
     for (const { entry, previousPath } of upserts.values()) {
       throwIfAborted(options.signal);
@@ -989,14 +1270,46 @@ var CodeIndex = class {
         ...previousPath ? { replacePath: previousPath } : {}
       }));
     }
-    await this.#attachEmbeddings(prepared, options.signal);
+    await this.#attachEmbeddings([...prepared, ...workingPrepared], options.signal);
+    const noChanges = !reconcileAll && checkpoint === target && prepared.length === 0 && deletes.size === 0 && workingPrepared.length === 0 && workingDeletes.size === 0;
     const resolvedAgain = await this.#git.resolveCommit(options.target ?? "HEAD");
     if (resolvedAgain !== target) throw new CodeIndexError("Target Git ref changed while indexing; retry the update.");
+    if (overlayWorkingTree) {
+      const headAgain = await this.#git.resolveCommit("HEAD");
+      const workingChangesAgain = await this.#git.workTreeChanges(target, indexArtifacts);
+      if (headAgain !== head || JSON.stringify(workingChangesAgain) !== JSON.stringify(workingChanges)) {
+        throw new CodeIndexError("Git HEAD or working-tree changes changed while indexing; retry the update.");
+      }
+      for (const file of workingPrepared) {
+        const info = await lstat2(path6.join(this.rootDir, file.path));
+        const content = await readFile(path6.join(this.rootDir, file.path));
+        if (!info.isFile() || info.isSymbolicLink() || info.size > this.#maxFileSize || sha256(content.toString("utf8")) !== file.contentHash) {
+          throw new CodeIndexError(`Working-tree file changed while indexing: ${file.path}`);
+        }
+      }
+      for (const relativePath of skippedWorkingPaths) {
+        const info = await lstat2(path6.join(this.rootDir, relativePath));
+        if (info.isFile() && !info.isSymbolicLink() && info.size <= this.#maxFileSize) {
+          throw new CodeIndexError(`Working-tree file changed while indexing: ${relativePath}`);
+        }
+      }
+    }
+    if (noChanges) {
+      if (this.#database.getCheckpoint() !== checkpoint || this.#database.getGeneration() !== generation) {
+        throw new CodeIndexError("Index changed while the update was being prepared; retry the update.");
+      }
+      return emptyStats(checkpoint);
+    }
     return this.#database.applyUpdate({
       files: prepared,
       deletePaths: [...deletes],
+      workingTree: {
+        files: workingPrepared,
+        deletePaths: [...workingDeletes]
+      },
       checkpoint: target,
-      expectedCheckpoint: checkpoint
+      expectedCheckpoint: checkpoint,
+      expectedGeneration: generation
     });
   }
   #classifyGitChanges(changes, tree, upserts, deletes) {
@@ -1018,6 +1331,28 @@ var CodeIndex = class {
       else deletes.add(change.path);
     }
   }
+  async #workingTreeSourcePaths(signal) {
+    const relativeIndexPath = path6.relative(this.rootDir, this.indexPath).replaceAll(path6.sep, "/");
+    const indexArtifacts = new Set(relativeIndexPath && !relativeIndexPath.startsWith("../") ? [relativeIndexPath, `${relativeIndexPath}-shm`, `${relativeIndexPath}-wal`, `${relativeIndexPath}-journal`] : []);
+    const directories = [""];
+    const sourcePaths = [];
+    while (directories.length > 0) {
+      throwIfAborted(signal);
+      const relativeDirectory = directories.shift();
+      const entries = await readdir(path6.join(this.rootDir, relativeDirectory), { withFileTypes: true });
+      entries.sort((left, right) => left.name.localeCompare(right.name));
+      for (const entry of entries) {
+        const relativePath = relativeDirectory ? `${relativeDirectory.replaceAll(path6.sep, "/")}/${entry.name}` : entry.name;
+        if (entry.isDirectory()) {
+          if (this.#policy.traversesDirectory(relativePath)) directories.push(relativePath);
+        } else if (entry.isFile() && !indexArtifacts.has(relativePath) && this.#policy.includes(relativePath)) {
+          sourcePaths.push(relativePath);
+        }
+      }
+    }
+    sourcePaths.sort();
+    return sourcePaths;
+  }
   #prepareFile(relativePath, buffer, provenance) {
     const content = buffer.toString("utf8");
     const callables = parseCallables(relativePath, content, this.#onWarning);
@@ -1076,7 +1411,10 @@ var CodeIndex = class {
       limit: options.limit,
       minSimilarity: options.minSimilarity,
       ...options.maxSimilarity !== void 0 ? { maxSimilarity: options.maxSimilarity } : {},
-      excludeId: functionId
+      excludeId: functionId,
+      ...options.excludePaths !== void 0 ? { excludePaths: options.excludePaths } : {},
+      ...options.minLines !== void 0 ? { minLines: options.minLines } : {},
+      ...options.nameRegex !== void 0 ? { nameRegex: options.nameRegex } : {}
     });
   }
   vectorForFunction(functionId) {
@@ -1086,15 +1424,15 @@ var CodeIndex = class {
     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);
+    const functions = filter.type === "all" ? this.allFunctions() : filter.type === "uncommitted" ? this.allFunctions().filter((callable) => callable.sourceMode === "working-tree") : await this.#functionsChangedSince(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) {
+  async #functionsChangedSince(baseRef) {
     await this.#git.assertRepository();
     const checkpoint = this.#database.getCheckpoint();
-    if (!checkpoint) throw new CodeIndexError("added-since requires an index with a Git checkpoint.");
+    if (!checkpoint) throw new CodeIndexError("changed-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);
@@ -1104,18 +1442,17 @@ var CodeIndex = class {
     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);
+      if (change.status === "R") comparisonPaths.set(change.path, { basePath: change.oldPath, pathChanged: true });
+      else if (change.status === "A" || change.status === "C") comparisonPaths.set(change.path, { basePath: null, pathChanged: false });
+      else comparisonPaths.set(change.path, { basePath: change.path, pathChanged: false });
     }
     for (const dirtyFile of this.#database.getWorkingTreeFiles()) {
-      if (!comparisonPaths.has(dirtyFile.path)) {
-        comparisonPaths.set(dirtyFile.path, dirtyFile.previousPath ?? dirtyFile.path);
-      }
+      const basePath = dirtyFile.previousPath ?? comparisonPaths.get(dirtyFile.path)?.basePath ?? dirtyFile.path;
+      comparisonPaths.set(dirtyFile.path, { basePath, pathChanged: basePath !== dirtyFile.path });
     }
     const current = this.#database.functionsForPaths([...comparisonPaths.keys()]);
     const baseFunctionsByCurrentPath = /* @__PURE__ */ new Map();
-    for (const [currentPath, basePath] of comparisonPaths) {
+    for (const [currentPath, { basePath }] of comparisonPaths) {
       if (!basePath) {
         baseFunctionsByCurrentPath.set(currentPath, []);
         continue;
@@ -1129,19 +1466,25 @@ var CodeIndex = class {
       baseFunctionsByCurrentPath.set(currentPath, parseCallables(basePath, content, this.#onWarning));
     }
     const currentByPath = groupBy(current, (callable) => callable.path);
-    const addedIds = /* @__PURE__ */ new Set();
+    const changedIds = /* @__PURE__ */ new Set();
     for (const [currentPath, currentFunctions] of currentByPath) {
-      for (const id of addedFunctionIds(currentFunctions, baseFunctionsByCurrentPath.get(currentPath) ?? [])) {
-        addedIds.add(id);
+      const comparison = comparisonPaths.get(currentPath);
+      for (const id of changedFunctionIds(
+        currentFunctions,
+        baseFunctionsByCurrentPath.get(currentPath) ?? [],
+        comparison.pathChanged
+      )) {
+        changedIds.add(id);
       }
     }
-    return current.filter((callable) => addedIds.has(callable.id));
+    return current.filter((callable) => changedIds.has(callable.id));
   }
 };
-function addedFunctionIds(current, base) {
+function changedFunctionIds(current, base, pathChanged) {
+  if (pathChanged) return current.map((callable) => callable.id);
   const currentGroups = groupBy(current, (callable) => `${callable.qualifiedName}\0${callable.kind}`);
   const baseGroups = groupBy(base, (callable) => `${callable.qualifiedName}\0${callable.kind}`);
-  const added = [];
+  const changed = [];
   for (const [key, currentGroup] of currentGroups) {
     const baseGroup = baseGroups.get(key) ?? [];
     const unmatchedBase = new Set(baseGroup.map((_, index) => index));
@@ -1155,13 +1498,9 @@ function addedFunctionIds(current, base) {
         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);
-    }
+    for (const currentIndex of unmatchedCurrent) changed.push(currentGroup[currentIndex].id);
   }
-  return added;
+  return changed;
 }
 function normalizeProfile(profile) {
   return {
@@ -1203,7 +1542,280 @@ function groupBy(values, keyFor) {
   return groups;
 }
 
+// src/analysis/cohesion.ts
+import path7 from "node:path";
+async function analyzeCohesion(options) {
+  const neighbors = options.neighbors ?? 20;
+  const limit = options.limit ?? 50;
+  const minSimilarity = options.minSimilarity ?? 0.8;
+  const minLines = options.minLines ?? 2;
+  const sourceFilter = options.sourceFilter ?? { type: "all" };
+  assertPositiveInteger(neighbors, "neighbors");
+  assertPositiveInteger(limit, "limit");
+  assertPositiveInteger(minLines, "minLines");
+  if (!Number.isFinite(minSimilarity) || minSimilarity < -1 || minSimilarity >= 1) {
+    throw new CodeIndexError("minSimilarity must be at least -1 and less than 1.");
+  }
+  if (options.maxSimilarity !== void 0 && (!Number.isFinite(options.maxSimilarity) || options.maxSimilarity <= minSimilarity)) {
+    throw new CodeIndexError("maxSimilarity must be greater than minSimilarity.");
+  }
+  const nameRegex = compileNameRegex(options.nameRegex);
+  const candidateFunctions = options.source.allFunctions().filter((callable) => callable.lineCount >= minLines && (!nameRegex || nameRegex.test(callable.qualifiedName)));
+  const candidateIds = new Set(candidateFunctions.map((callable) => callable.id));
+  const sourceFunctions = (await options.source.sourceFunctions(sourceFilter)).filter((callable) => candidateIds.has(callable.id));
+  const neighborCache = /* @__PURE__ */ new Map();
+  const neighborsFor = (callable) => {
+    throwIfAborted(options.signal);
+    const matches = options.source.similarToFunction(callable.id, {
+      limit: neighbors,
+      minSimilarity,
+      ...options.maxSimilarity !== void 0 ? { maxSimilarity: options.maxSimilarity } : {},
+      minLines,
+      ...options.nameRegex !== void 0 ? { nameRegex: options.nameRegex } : {}
+    }).filter((match) => candidateIds.has(match.function.id));
+    neighborCache.set(callable.id, new Set(matches.map((match) => match.function.id)));
+    return matches;
+  };
+  const edges = /* @__PURE__ */ new Map();
+  for (let index = 0; index < sourceFunctions.length; index += 1) {
+    const source = sourceFunctions[index];
+    for (const match of neighborsFor(source)) {
+      const [left, right] = orderedFunctions(source, match.function);
+      const key = pairKey(left.id, right.id);
+      const existing = edges.get(key);
+      if (!existing || match.similarity > existing.similarity) {
+        edges.set(key, { left, right, similarity: match.similarity });
+      }
+    }
+    options.onProgress?.({ completed: index + 1, total: sourceFunctions.length });
+  }
+  const scoredPairs = [...edges.values()].map((edge) => {
+    const leftNeighbors = neighborCache.get(edge.left.id);
+    const rightNeighbors = neighborCache.get(edge.right.id);
+    const reciprocal = leftNeighbors && rightNeighbors ? leftNeighbors.has(edge.right.id) && rightNeighbors.has(edge.left.id) : null;
+    return scorePair(edge, reciprocal, minSimilarity);
+  }).sort(comparePairs);
+  scoredPairs.forEach((pair, index) => {
+    pair.rank = index + 1;
+  });
+  const repositoryScope = sourceFilter.type === "all" && sourceFilter.path === void 0;
+  const summary = summarize(
+    repositoryScope ? "repository" : "selected-sources",
+    sourceFunctions.length,
+    candidateFunctions.length,
+    scoredPairs
+  );
+  const reportedPairs = scoredPairs.slice(0, limit);
+  const files = summarizeFiles(sourceFunctions, scoredPairs).filter((file) => file.internalAffinity + file.sameFolderAffinity + file.externalAffinity > 0).slice(0, limit);
+  const groups = buildGroups(reportedPairs);
+  const status = options.source.status();
+  return {
+    schemaVersion: 1,
+    repository: {
+      generation: status.generation,
+      gitCheckpoint: status.gitCheckpoint,
+      embeddingProfile: status.embeddingProfile
+    },
+    parameters: {
+      neighbors,
+      limit,
+      minSimilarity,
+      ...options.maxSimilarity !== void 0 ? { maxSimilarity: options.maxSimilarity } : {},
+      minLines,
+      ...options.nameRegex !== void 0 ? { nameRegex: options.nameRegex } : {},
+      sourceFilter
+    },
+    summary,
+    pairs: reportedPairs,
+    files,
+    groups
+  };
+}
+function cohesionLocation(leftPath, rightPath) {
+  const normalizedLeft = leftPath.replaceAll("\\", "/");
+  const normalizedRight = rightPath.replaceAll("\\", "/");
+  const leftDirectory = directoryParts(normalizedLeft);
+  const rightDirectory = directoryParts(normalizedRight);
+  let commonLength = 0;
+  while (commonLength < leftDirectory.length && commonLength < rightDirectory.length && leftDirectory[commonLength] === rightDirectory[commonLength]) {
+    commonLength += 1;
+  }
+  const commonParts = leftDirectory.slice(0, commonLength);
+  const commonAncestor = commonParts.length > 0 ? commonParts.join("/") : null;
+  const sameFile = normalizedLeft === normalizedRight;
+  const folderHops = sameFile ? 0 : leftDirectory.length - commonLength + rightDirectory.length - commonLength;
+  return {
+    category: sameFile ? "same-file" : folderHops === 0 ? "same-folder" : "different-folder",
+    physicalDistance: sameFile ? 0 : 1 + folderHops,
+    folderHops,
+    commonAncestor,
+    sourceTestPair: isTestPath(normalizedLeft) !== isTestPath(normalizedRight)
+  };
+}
+function scorePair(edge, reciprocal, minSimilarity) {
+  const location = cohesionLocation(edge.left.path, edge.right.path);
+  const semanticWeight = clamp((edge.similarity - minSimilarity) / (1 - minSimilarity));
+  const separationWeight = 1 - Math.exp(-location.physicalDistance / 2);
+  return {
+    rank: 0,
+    left: edge.left,
+    right: edge.right,
+    similarity: edge.similarity,
+    reciprocal,
+    semanticWeight,
+    separationWeight,
+    cohesionGap: semanticWeight * separationWeight,
+    location
+  };
+}
+function summarize(scope, functionsAnalyzed, candidateFunctions, pairs) {
+  const totalWeight = pairs.reduce((sum, pair) => sum + pair.semanticWeight, 0);
+  const sameFileWeight = pairs.filter((pair) => pair.location.category === "same-file").reduce((sum, pair) => sum + pair.semanticWeight, 0);
+  const sameFolderWeight = pairs.filter((pair) => pair.location.category === "same-folder").reduce((sum, pair) => sum + pair.semanticWeight, 0);
+  const remoteWeight = pairs.filter((pair) => pair.location.category === "different-folder").reduce((sum, pair) => sum + pair.semanticWeight, 0);
+  const weightedDistance = pairs.reduce(
+    (sum, pair) => sum + pair.semanticWeight * pair.location.physicalDistance,
+    0
+  );
+  return {
+    scope,
+    functionsAnalyzed,
+    candidateFunctions,
+    semanticEdges: pairs.length,
+    sameFileRatio: ratio(sameFileWeight, totalWeight),
+    sameFolderRatio: ratio(sameFolderWeight, totalWeight),
+    remoteRatio: ratio(remoteWeight, totalWeight),
+    weightedMeanDistance: ratio(weightedDistance, totalWeight)
+  };
+}
+function summarizeFiles(sourceFunctions, pairs) {
+  const sourceIds = new Set(sourceFunctions.map((callable) => callable.id));
+  const counts = /* @__PURE__ */ new Map();
+  for (const callable of sourceFunctions) counts.set(callable.path, (counts.get(callable.path) ?? 0) + 1);
+  const reports = /* @__PURE__ */ new Map();
+  for (const [filePath, functionCount] of counts) {
+    reports.set(filePath, {
+      path: filePath,
+      functionCount,
+      internalAffinity: 0,
+      sameFolderAffinity: 0,
+      externalAffinity: 0,
+      externalAffinityRatio: 0
+    });
+  }
+  for (const pair of pairs) {
+    if (sourceIds.has(pair.left.id)) addFileAffinity(reports.get(pair.left.path), pair.right, pair);
+    if (sourceIds.has(pair.right.id)) addFileAffinity(reports.get(pair.right.path), pair.left, pair);
+  }
+  for (const report of reports.values()) {
+    const total = report.internalAffinity + report.sameFolderAffinity + report.externalAffinity;
+    report.externalAffinityRatio = ratio(report.externalAffinity, total);
+  }
+  return [...reports.values()].sort((left, right) => right.externalAffinityRatio - left.externalAffinityRatio || right.externalAffinity - left.externalAffinity || left.path.localeCompare(right.path));
+}
+function addFileAffinity(report, match, pair) {
+  if (pair.location.category === "same-file") report.internalAffinity += pair.semanticWeight;
+  else if (pair.location.category === "same-folder") report.sameFolderAffinity += pair.semanticWeight;
+  else {
+    report.externalAffinity += pair.semanticWeight;
+    updateStrongestExternal(report, match, pair);
+  }
+}
+function updateStrongestExternal(report, callable, pair) {
+  if (!report.strongestExternalMatch || pair.cohesionGap > report.strongestExternalMatch.cohesionGap) {
+    report.strongestExternalMatch = {
+      function: callable,
+      similarity: pair.similarity,
+      cohesionGap: pair.cohesionGap
+    };
+  }
+}
+function buildGroups(pairs) {
+  const functions = /* @__PURE__ */ new Map();
+  const neighbors = /* @__PURE__ */ new Map();
+  for (const pair of pairs) {
+    functions.set(pair.left.id, pair.left);
+    functions.set(pair.right.id, pair.right);
+    addNeighbor(neighbors, pair.left.id, pair.right.id);
+    addNeighbor(neighbors, pair.right.id, pair.left.id);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const groups = [];
+  for (const start of neighbors.keys()) {
+    if (seen.has(start)) continue;
+    const pending = [start];
+    const memberIds = /* @__PURE__ */ new Set();
+    while (pending.length > 0) {
+      const id = pending.pop();
+      if (seen.has(id)) continue;
+      seen.add(id);
+      memberIds.add(id);
+      for (const neighbor of neighbors.get(id) ?? []) pending.push(neighbor);
+    }
+    const groupPairs = pairs.filter((pair) => memberIds.has(pair.left.id) && memberIds.has(pair.right.id));
+    const members = [...memberIds].map((id) => functions.get(id)).sort(compareFunctions);
+    groups.push({
+      rank: 0,
+      memberCount: members.length,
+      fileCount: new Set(members.map((member) => member.path)).size,
+      minimumEdgeSimilarity: Math.min(...groupPairs.map((pair) => pair.similarity)),
+      maximumEdgeSimilarity: Math.max(...groupPairs.map((pair) => pair.similarity)),
+      maximumPhysicalDistance: Math.max(...groupPairs.map((pair) => pair.location.physicalDistance)),
+      maximumCohesionGap: Math.max(...groupPairs.map((pair) => pair.cohesionGap)),
+      members
+    });
+  }
+  groups.sort((left, right) => right.maximumCohesionGap - left.maximumCohesionGap || right.memberCount - left.memberCount || compareFunctions(left.members[0], right.members[0]));
+  groups.forEach((group, index) => {
+    group.rank = index + 1;
+  });
+  return groups;
+}
+function compileNameRegex(pattern) {
+  if (pattern === void 0) return void 0;
+  try {
+    return new RegExp(pattern);
+  } catch (error) {
+    throw new CodeIndexError(`Invalid name regex: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+  }
+}
+function directoryParts(filePath) {
+  const directory = path7.posix.dirname(filePath.replaceAll("\\", "/"));
+  return directory === "." ? [] : directory.split("/").filter(Boolean);
+}
+function isTestPath(filePath) {
+  const normalized = filePath.replaceAll("\\", "/").toLowerCase();
+  const segments = normalized.split("/");
+  const fileName = segments.at(-1) ?? "";
+  return segments.some((segment) => segment === "test" || segment === "tests" || segment === "__tests__") || /\.(?:test|spec)\.[cm]?[jt]sx?$/.test(fileName);
+}
+function orderedFunctions(left, right) {
+  return compareFunctions(left, right) <= 0 ? [left, right] : [right, left];
+}
+function compareFunctions(left, right) {
+  return left.path.localeCompare(right.path) || left.startLine - right.startLine || left.startColumn - right.startColumn || left.qualifiedName.localeCompare(right.qualifiedName) || left.id - right.id;
+}
+function comparePairs(left, right) {
+  return right.cohesionGap - left.cohesionGap || right.similarity - left.similarity || Number(right.reciprocal === true) - Number(left.reciprocal === true) || compareFunctions(left.left, right.left) || compareFunctions(left.right, right.right);
+}
+function pairKey(leftId, rightId) {
+  return leftId < rightId ? `${leftId}:${rightId}` : `${rightId}:${leftId}`;
+}
+function addNeighbor(neighbors, source, target) {
+  const values = neighbors.get(source) ?? /* @__PURE__ */ new Set();
+  values.add(target);
+  neighbors.set(source, values);
+}
+function ratio(numerator, denominator) {
+  return denominator === 0 ? 0 : numerator / denominator;
+}
+function clamp(value) {
+  return Math.max(0, Math.min(1, value));
+}
+
 // src/search/cross-search.ts
+import { realpath, stat } from "node:fs/promises";
+import path8 from "node:path";
 async function* crossSearch(options) {
   const target = options.target ?? options.source;
   const sourceProfile = JSON.stringify(options.source.status().embeddingProfile);
@@ -1213,21 +1825,55 @@ async function* crossSearch(options) {
   }
   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 minLines = options.minLines ?? 2;
+  assertPositiveInteger(minLines, "minLines");
+  const nameRegex = compileNameRegex2(options.nameRegex);
+  const sourceFunctions = (await options.source.sourceFunctions(options.sourceFilter ?? { type: "all" })).filter((callable) => callable.lineCount >= minLines && (!nameRegex || nameRegex.test(callable.qualifiedName)));
+  const sameIndex = target.indexPath === options.source.indexPath || await fileIdentity(target.indexPath) === await fileIdentity(options.source.indexPath);
+  const sourceRoot = options.crossFileOnly ? await canonicalRoot(options.source.rootDir) : void 0;
+  const targetRoot = options.crossFileOnly ? sameIndex ? sourceRoot : await canonicalRoot(target.rootDir) : void 0;
+  const canonicalFiles = /* @__PURE__ */ new Map();
+  const canonicalFile = (root, filePath) => {
+    const absolutePath = path8.resolve(root, filePath);
+    let result = canonicalFiles.get(absolutePath);
+    if (!result) {
+      result = fileIdentity(absolutePath);
+      canonicalFiles.set(absolutePath, result);
+    }
+    return result;
+  };
+  const targetPathsByCanonicalFile = /* @__PURE__ */ new Map();
+  if (targetRoot) {
+    const targetPaths = [...new Set(target.allFunctions().map((callable) => callable.path))];
+    await Promise.all(targetPaths.map(async (targetPath) => {
+      const canonicalPath = await canonicalFile(targetRoot, targetPath);
+      const paths = targetPathsByCanonicalFile.get(canonicalPath) ?? [];
+      paths.push(targetPath);
+      targetPathsByCanonicalFile.set(canonicalPath, paths);
+    }));
+  }
   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 canonicalSourceFile = sourceRoot ? await canonicalFile(sourceRoot, source.path) : void 0;
+    const excludedTargetPaths = canonicalSourceFile ? targetPathsByCanonicalFile.get(canonicalSourceFile) : void 0;
+    const excludePaths = excludedTargetPaths ? { excludePaths: excludedTargetPaths } : {};
     const candidates = sameIndex ? options.source.similarToFunction(source.id, {
       limit,
       minSimilarity: options.minSimilarity ?? -1,
-      ...options.maxSimilarity !== void 0 ? { maxSimilarity: options.maxSimilarity } : {}
+      ...options.maxSimilarity !== void 0 ? { maxSimilarity: options.maxSimilarity } : {},
+      minLines,
+      ...options.nameRegex !== void 0 ? { nameRegex: options.nameRegex } : {},
+      ...excludePaths
     }) : target.searchByVector(vector, {
       limit,
       minSimilarity: options.minSimilarity ?? -1,
-      ...options.maxSimilarity !== void 0 ? { maxSimilarity: options.maxSimilarity } : {}
+      ...options.maxSimilarity !== void 0 ? { maxSimilarity: options.maxSimilarity } : {},
+      minLines,
+      ...options.nameRegex !== void 0 ? { nameRegex: options.nameRegex } : {},
+      ...excludePaths
     });
     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}`;
@@ -1239,6 +1885,29 @@ async function* crossSearch(options) {
     options.onProgress?.({ completed: index + 1, total: sourceFunctions.length });
   }
 }
+function compileNameRegex2(pattern) {
+  if (pattern === void 0) return void 0;
+  try {
+    return new RegExp(pattern);
+  } catch (error) {
+    throw new CodeIndexError(`Invalid name regex: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+  }
+}
+async function canonicalRoot(root) {
+  try {
+    return await realpath(root);
+  } catch {
+    return path8.resolve(root);
+  }
+}
+async function fileIdentity(filePath) {
+  try {
+    const metadata = await stat(filePath);
+    return `inode:${metadata.dev}:${metadata.ino}`;
+  } catch {
+    return `path:${path8.resolve(filePath)}`;
+  }
+}
 
 // src/embeddings/openai.ts
 import { Tiktoken } from "js-tiktoken/lite";
@@ -1305,8 +1974,8 @@ var OpenAIEmbeddingProvider = class {
   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;
+    const model = options.model ?? "text-embedding-3-large";
+    const dimensions = options.dimensions ?? 3072;
     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`;
@@ -1390,24 +2059,35 @@ function updateFiles(index, options) {
 function updateFromGit(index, options) {
   return index.updateFromGit(options);
 }
+function updateFromWorkingTree(index, options) {
+  return index.updateFromWorkingTree(options);
+}
 function similaritySearch(index, options) {
   return index.similaritySearch(options);
 }
 function crossSearchFunctions(options) {
   return crossSearch(options);
 }
+function analyzeCodeCohesion(options) {
+  return analyzeCohesion(options);
+}
 export {
   CodeIndex,
   CodeIndexError,
   GitDivergenceError,
+  GitUnavailableError,
   IncompatibleIndexError,
   JinaEmbeddingProvider,
   OpenAIEmbeddingProvider,
+  analyzeCodeCohesion,
+  analyzeCohesion,
+  cohesionLocation,
   crossSearch,
   crossSearchFunctions,
   openCodeIndex,
   similaritySearch,
   updateFiles,
-  updateFromGit
+  updateFromGit,
+  updateFromWorkingTree
 };
 //# sourceMappingURL=index.js.map