scip-query 0.4.1 → 0.4.3

package/dist/cli.js

@@ -20,18 +20,10 @@ var ScipDatabase = class {
     this.db = new Database(config.dbPath, { readonly: true });
     this.db.pragma("busy_timeout = 5000");
   }
-  /** Attach a gitignore-based path filter for query results */
-  setPathFilter(filter) {
-    this.pathFilter = filter;
-  }
   /** Check if a path should be excluded based on .gitignore rules */
   isIgnored(relativePath) {
     return this.pathFilter?.isIgnored(relativePath) ?? false;
   }
-  /** Filter an array of paths using the gitignore filter */
-  filterPaths(paths) {
-    return this.pathFilter?.filter(paths) ?? paths;
-  }
   /**
    * The local-symbol predicate: only match symbols that are defined
    * in files NOT excluded by gitignore. This replaces the old hardcoded
@@ -115,7 +107,7 @@ var ScipDatabase = class {
 // src/gitignore-filter.ts
 import ignore from "ignore";
 import { readFileSync, existsSync } from "fs";
-import { join, dirname } from "path";
+import { dirname, isAbsolute, join, relative, resolve } from "path";
 function createGitignoreFilter(projectRoot) {
   const ig = ignore();
   let loaded = false;
@@ -132,8 +124,8 @@ function createGitignoreFilter(projectRoot) {
     ig.add(DEFAULT_IGNORES);
   }
   return {
-    isIgnored: (relativePath) => ig.ignores(relativePath),
-    filter: (paths) => paths.filter((p) => !ig.ignores(p))
+    isIgnored: (relativePath) => safeIgnores(ig, projectRoot, relativePath),
+    filter: (paths) => paths.filter((p) => !safeIgnores(ig, projectRoot, p))
   };
 }
 function findGitignoreFiles(projectRoot) {
@@ -213,10 +205,35 @@ Thumbs.db
 # Type definitions (often noise in queries)
 *.d.ts
 `;
+function safeIgnores(ig, projectRoot, inputPath) {
+  const relativePath = normalizeForIgnore(projectRoot, inputPath);
+  if (!relativePath) {
+    return false;
+  }
+  try {
+    return ig.ignores(relativePath);
+  } catch {
+    return false;
+  }
+}
+function normalizeForIgnore(projectRoot, inputPath) {
+  if (!inputPath || inputPath === ".") {
+    return null;
+  }
+  if (!isAbsolute(inputPath) && !inputPath.startsWith("..")) {
+    return inputPath.replaceAll("\\", "/");
+  }
+  const absolutePath = isAbsolute(inputPath) ? inputPath : resolve(projectRoot, inputPath);
+  const relativePath = relative(projectRoot, absolutePath).replaceAll("\\", "/");
+  if (!relativePath || relativePath === "." || relativePath.startsWith("..")) {
+    return null;
+  }
+  return relativePath;
+}
 
 // src/config.ts
 import { readFileSync as readFileSync2, writeFileSync, existsSync as existsSync2, mkdirSync } from "fs";
-import { join as join2, resolve } from "path";
+import { join as join2, resolve as resolve2 } from "path";
 import { createHash } from "crypto";
 import { homedir } from "os";
 var CONFIG_FILENAME = ".scipquery.json";
@@ -247,10 +264,10 @@ function resolveWatchConfig(config) {
 function resolveCacheDir(projectRoot, config) {
   const envOverride = process.env["SCIP_QUERY_CACHE_DIR"];
   if (envOverride) return ensureDir(envOverride);
-  if (config?.dbPath) return ensureDir(resolve(projectRoot, config.dbPath));
+  if (config?.dbPath) return ensureDir(resolve2(projectRoot, config.dbPath));
   const xdgCache = process.env["XDG_CACHE_HOME"];
   const cacheBase = xdgCache || join2(homedir(), ".cache");
-  const projectHash = createHash("sha256").update(resolve(projectRoot)).digest("hex").slice(0, 12);
+  const projectHash = createHash("sha256").update(resolve2(projectRoot)).digest("hex").slice(0, 12);
   const dir = join2(cacheBase, "scip-query", "projects", projectHash);
   return ensureDir(dir);
 }
@@ -286,8 +303,8 @@ function ensureDir(dir) {
 
 // src/reindex/index.ts
 import { execFileSync as execFileSync3 } from "child_process";
-import { existsSync as existsSync6, renameSync } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync6, renameSync, rmSync } from "fs";
+import { basename, dirname as dirname2, extname as extname2, join as join6 } from "path";
 
 // src/scip-cli.ts
 import { execFileSync as execFileSync2 } from "child_process";
@@ -968,6 +985,128 @@ function resolveDotnetProject(projectRoot, suffixes) {
   return null;
 }
 
+// src/reindex/merge.ts
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { create } from "@bufbuild/protobuf";
+import {
+  deserializeSCIP,
+  serializeSCIP,
+  DocumentSchema,
+  IndexSchema,
+  SymbolInformationSchema
+} from "@c4312/scip";
+function mergeScipIndexes(indexes) {
+  if (indexes.length === 0) {
+    throw new Error("Cannot merge zero SCIP indexes");
+  }
+  if (indexes.length === 1) {
+    return indexes[0];
+  }
+  const metadata = mergeMetadata(indexes);
+  const documents = mergeDocuments(indexes.flatMap((index) => index.documents ?? []));
+  const externalSymbols = mergeSymbolInfos(indexes.flatMap((index) => index.externalSymbols ?? []));
+  return create(IndexSchema, {
+    metadata,
+    documents,
+    externalSymbols
+  });
+}
+function mergeScipFiles(inputPaths, outputPath) {
+  if (inputPaths.length === 0) {
+    throw new Error("Cannot merge zero SCIP files");
+  }
+  const indexes = inputPaths.map((path2) => deserializeSCIP(readFileSync3(path2)));
+  const merged = mergeScipIndexes(indexes);
+  writeFileSync2(outputPath, Buffer.from(serializeSCIP(merged)));
+  return {
+    documentCount: merged.documents.length,
+    externalSymbolCount: merged.externalSymbols.length,
+    inputCount: inputPaths.length
+  };
+}
+function mergeMetadata(indexes) {
+  const first = indexes[0]?.metadata;
+  if (!first) {
+    return void 0;
+  }
+  const expectedProjectRoot = first.projectRoot;
+  for (const index of indexes.slice(1)) {
+    const actualProjectRoot = index.metadata?.projectRoot;
+    if (expectedProjectRoot && actualProjectRoot && actualProjectRoot !== expectedProjectRoot) {
+      throw new Error(
+        `Cannot merge SCIP indexes with different project roots: ${expectedProjectRoot} vs ${actualProjectRoot}`
+      );
+    }
+  }
+  return first;
+}
+function mergeDocuments(documents) {
+  const byPath = /* @__PURE__ */ new Map();
+  for (const document of documents) {
+    const existing = byPath.get(document.relativePath);
+    if (!existing) {
+      byPath.set(document.relativePath, document);
+      continue;
+    }
+    byPath.set(document.relativePath, create(DocumentSchema, {
+      language: existing.language || document.language,
+      relativePath: existing.relativePath || document.relativePath,
+      occurrences: [...existing.occurrences, ...document.occurrences],
+      symbols: mergeSymbolInfos([...existing.symbols, ...document.symbols]),
+      text: chooseText(existing.text, document.text),
+      positionEncoding: existing.positionEncoding || document.positionEncoding
+    }));
+  }
+  return [...byPath.values()];
+}
+function mergeSymbolInfos(symbols2) {
+  const bySymbol = /* @__PURE__ */ new Map();
+  for (const symbol of symbols2) {
+    const existing = bySymbol.get(symbol.symbol);
+    if (!existing) {
+      bySymbol.set(symbol.symbol, symbol);
+      continue;
+    }
+    bySymbol.set(symbol.symbol, create(SymbolInformationSchema, {
+      symbol: existing.symbol,
+      documentation: uniqueStrings([...existing.documentation, ...symbol.documentation]),
+      relationships: mergeRelationships([...existing.relationships, ...symbol.relationships]),
+      kind: existing.kind || symbol.kind,
+      displayName: existing.displayName || symbol.displayName,
+      enclosingSymbol: existing.enclosingSymbol || symbol.enclosingSymbol,
+      signatureDocumentation: existing.signatureDocumentation ?? symbol.signatureDocumentation
+    }));
+  }
+  return [...bySymbol.values()];
+}
+function mergeRelationships(relationships) {
+  const seen = /* @__PURE__ */ new Set();
+  const merged = [];
+  for (const relationship of relationships) {
+    const key = [
+      relationship.symbol,
+      relationship.isReference ? "1" : "0",
+      relationship.isImplementation ? "1" : "0",
+      relationship.isTypeDefinition ? "1" : "0",
+      relationship.isDefinition ? "1" : "0"
+    ].join("|");
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    merged.push(relationship);
+  }
+  return merged;
+}
+function chooseText(left, right) {
+  if (!left) return right;
+  if (!right) return left;
+  return left.length >= right.length ? left : right;
+}
+function uniqueStrings(values) {
+  return [...new Set(values)];
+}
+
 // src/reindex/index.ts
 async function reindex(opts) {
   const {
@@ -1003,7 +1142,11 @@ async function reindex(opts) {
     ...process.env,
     NODE_OPTIONS: `--max-old-space-size=${maxHeapMb}`
   };
-  for (const lang of languages) {
+  const languageOutputs = languages.map((language, index) => ({
+    language,
+    scipPath: languages.length > 1 ? tempScipPath(outputScip, language, index) : outputScip
+  }));
+  for (const { language: lang, scipPath } of languageOutputs) {
     const config = getIndexerConfig(lang);
     const binaryLabel = describeIndexerBinary(config);
     const projectLocalBinary = resolveProjectLocalIndexerBinary(config, projectRoot);
@@ -1033,7 +1176,7 @@ async function reindex(opts) {
     const indexerEnv = getIndexerExecutionEnv(config, env, resolvedBinary);
     const { binary, args } = config.indexArgs({
       projectRoot,
-      outputPath: outputScip,
+      outputPath: scipPath,
       pnpmWorkspaces: opts.pnpmWorkspaces,
       indexerBinary: resolvedBinary
     });
@@ -1052,7 +1195,11 @@ Make sure ${binaryLabel} is installed and available on PATH.`,
         { cause: err }
       );
     }
-    moveDefaultOutputIfNeeded(config, projectRoot, outputScip);
+    moveDefaultOutputIfNeeded(config, projectRoot, scipPath);
+  }
+  if (languageOutputs.length > 1) {
+    onStatus(`Merging ${languageOutputs.length} language indexes...`);
+    mergeScipFiles(languageOutputs.map((entry) => entry.scipPath), outputScip);
   }
   onStatus("Converting to SQLite...");
   if (!existsSync6(outputScip)) {
@@ -1067,6 +1214,12 @@ Make sure ${binaryLabel} is installed and available on PATH.`,
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     throw new Error(`Failed to convert SCIP index to SQLite: ${msg}`, { cause: err });
+  } finally {
+    for (const { scipPath } of languageOutputs) {
+      if (scipPath !== outputScip) {
+        rmSync(scipPath, { force: true });
+      }
+    }
   }
   const durationMs = Date.now() - start;
   onStatus(`Done in ${(durationMs / 1e3).toFixed(1)}s`);
@@ -1081,11 +1234,16 @@ function moveDefaultOutputIfNeeded(config, projectRoot, outputScip) {
     renameSync(defaultOutputPath, outputScip);
   }
 }
+function tempScipPath(outputScip, language, index) {
+  const extension = extname2(outputScip) || ".scip";
+  const stem = basename(outputScip, extension);
+  return join6(dirname2(outputScip), `${stem}.${index + 1}.${language}${extension}`);
+}
 
 // src/watch.ts
 import { watch } from "fs";
 import { existsSync as existsSync7, renameSync as renameSync2 } from "fs";
-import { join as join7, relative } from "path";
+import { join as join7, relative as relative2 } from "path";
 import { fork } from "child_process";
 import ignore2 from "ignore";
 var Watcher = class {
@@ -1157,13 +1315,9 @@ var Watcher = class {
     if (this.cooldownTimer) clearTimeout(this.cooldownTimer);
     this.setStatus({ state: "idle" });
   }
-  /** Get current watcher status */
-  getStatus() {
-    return this.status;
-  }
   // ── Internal ─────────────────────────────────────────────
   handleFileChange(filename) {
-    const rel = relative(this.projectRoot, join7(this.projectRoot, filename));
+    const rel = relative2(this.projectRoot, join7(this.projectRoot, filename));
     if (this.gitignoreFilter.isIgnored(rel)) return;
     if (this.extraIgnore.ignores(rel)) return;
     if (filename.endsWith("index.db") || filename.endsWith("index.scip") || filename.endsWith("index.db.tmp") || filename.endsWith(".scipquery.json")) {
@@ -1244,10 +1398,10 @@ var Watcher = class {
    * Writes to index.db.tmp, then atomically renames to index.db.
    */
   runReindex() {
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve5, reject) => {
       const start = Date.now();
       const tmpDb = this.indexPaths.dbPath + ".tmp";
-      const tmpScip = tempScipPath(this.indexPaths.indexPath);
+      const tmpScip = tempScipPath2(this.indexPaths.indexPath);
       const child = fork(
         new URL("./reindex-worker.js", import.meta.url).pathname,
         [],
@@ -1272,7 +1426,7 @@ var Watcher = class {
             if (existsSync7(tmpScip)) {
               renameSync2(tmpScip, this.indexPaths.indexPath);
             }
-            resolve4(Date.now() - start);
+            resolve5(Date.now() - start);
           } catch (err) {
             reject(new Error(`Atomic swap failed: ${err}`));
           }
@@ -1288,7 +1442,7 @@ var Watcher = class {
     this.onStatus(status);
   }
 };
-function tempScipPath(indexPath) {
+function tempScipPath2(indexPath) {
   return indexPath.endsWith(".scip") ? indexPath.slice(0, -".scip".length) + ".tmp.scip" : indexPath + ".tmp.scip";
 }
 
@@ -1313,31 +1467,39 @@ function stats(db) {
 }
 
 // src/queries/files.ts
+function globToLike(pattern) {
+  const hasGlobChars = /[*?]/.test(pattern);
+  if (!hasGlobChars) {
+    return `%${pattern}%`;
+  }
+  return pattern.replace(/\*\*/g, "%").replace(/\*/g, "%").replace(/\?/g, "_");
+}
 function files(db, pattern) {
+  const likePattern = globToLike(pattern);
   const rows = db.all(
     `SELECT relative_path FROM documents
      WHERE relative_path LIKE ?
      ORDER BY relative_path`,
-    `%${pattern}%`
+    likePattern
   );
   return rows.filter((r) => !db.isIgnored(r.relative_path)).map((r) => ({ relativePath: r.relative_path }));
 }
 
 // src/query-support.ts
-import { basename as basename2 } from "path";
+import { basename as basename3 } from "path";
 
 // src/source-analysis.ts
 import {
   existsSync as existsSync8,
-  readFileSync as readFileSync3
+  readFileSync as readFileSync4
 } from "fs";
 import {
-  basename,
-  dirname as dirname2,
-  extname as extname2,
+  basename as basename2,
+  dirname as dirname3,
+  extname as extname3,
   join as join8,
-  relative as relative2,
-  resolve as resolve2
+  relative as relative3,
+  resolve as resolve3
 } from "path";
 var SOURCE_IMPORT_CACHE = /* @__PURE__ */ new WeakMap();
 var SOURCE_EXPORT_CACHE = /* @__PURE__ */ new WeakMap();
@@ -1366,7 +1528,7 @@ function getSourceImports(db, relativePath) {
     cache.set(normalized, []);
     return [];
   }
-  const source = readFileSync3(fullPath, "utf-8");
+  const source = readFileSync4(fullPath, "utf-8");
   const parsed = isPythonSourcePath(normalized) ? parsePythonImports(db, normalized, source) : isJavaScriptSourcePath(normalized) ? parseJavaScriptImports(db, normalized, source) : isJvmSourcePath(normalized) ? parseJvmImports(db, normalized, source) : isRustSourcePath(normalized) ? parseRustImports(db, normalized, source) : isRubySourcePath(normalized) ? parseRubyImports(db, normalized, source) : isCLikeSourcePath(normalized) ? parseCLikeImports(db, normalized, source) : isDotNetSourcePath(normalized) ? parseDotNetImports(db, normalized, source) : isDartSourcePath(normalized) ? parseDartImports(db, normalized, source) : isPhpSourcePath(normalized) ? parsePhpImports(db, normalized, source) : [];
   cache.set(normalized, parsed);
   return parsed;
@@ -1383,7 +1545,7 @@ function getSourceExports(db, relativePath) {
     cache.set(normalized, []);
     return [];
   }
-  const source = readFileSync3(fullPath, "utf-8");
+  const source = readFileSync4(fullPath, "utf-8");
   const parsed = isDartSourcePath(normalized) ? parseDartExports(db, normalized, source) : isRustSourcePath(normalized) ? parseRustExports(db, normalized, source) : [];
   cache.set(normalized, parsed);
   return parsed;
@@ -1680,7 +1842,7 @@ function parseRubyImports(db, importerPath, source) {
   return statements;
 }
 function rubyConstantName(specifier) {
-  return basename(specifier).replace(/\.[^.]+$/, "").split("_").filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+  return basename2(specifier).replace(/\.[^.]+$/, "").split("_").filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
 }
 function parseCLikeImports(db, importerPath, source) {
   const statements = [];
@@ -1689,7 +1851,7 @@ function parseCLikeImports(db, importerPath, source) {
     const full = match[0];
     if (!specifier || !full || typeof match.index !== "number") continue;
     const body = buildUsageBody(source, match.index, match.index + full.length);
-    const localName = basename(specifier).replace(/\.[^.]+$/, "");
+    const localName = basename2(specifier).replace(/\.[^.]+$/, "");
     statements.push({
       importedName: specifier,
       localName,
@@ -2164,16 +2326,16 @@ function resolveJavaScriptImportPath(db, importerPath, specifier) {
   if (!specifier.startsWith(".") && !specifier.startsWith("/")) {
     return null;
   }
-  const importerDir = dirname2(join8(db.config.projectRoot, importerPath));
-  const absolute = resolve2(importerDir, specifier);
+  const importerDir = dirname3(join8(db.config.projectRoot, importerPath));
+  const absolute = resolve3(importerDir, specifier);
   const indexedPaths = getIndexedPaths(db);
   for (const candidate of candidateImportPaths(absolute)) {
-    const relativeCandidate = normalizePath(relative2(db.config.projectRoot, candidate));
+    const relativeCandidate = normalizePath(relative3(db.config.projectRoot, candidate));
     if (indexedPaths.has(relativeCandidate) || existsSync8(candidate)) {
       return relativeCandidate;
     }
   }
-  return normalizePath(relative2(db.config.projectRoot, absolute));
+  return normalizePath(relative3(db.config.projectRoot, absolute));
 }
 function resolvePythonImportPath(db, importerPath, specifier) {
   const indexedPaths = getIndexedPaths(db);
@@ -2183,16 +2345,16 @@ function resolvePythonImportPath(db, importerPath, specifier) {
     if (!match) return null;
     const dots = match[1].length;
     const remainder = match[2].replace(/^\./, "");
-    let baseDir = dirname2(join8(db.config.projectRoot, importerPath));
+    let baseDir = dirname3(join8(db.config.projectRoot, importerPath));
     for (let i = 1; i < dots; i++) {
-      baseDir = dirname2(baseDir);
+      baseDir = dirname3(baseDir);
     }
-    basePath = remainder ? resolve2(baseDir, remainder.replace(/\./g, "/")) : baseDir;
+    basePath = remainder ? resolve3(baseDir, remainder.replace(/\./g, "/")) : baseDir;
   } else {
-    basePath = resolve2(db.config.projectRoot, specifier.replace(/\./g, "/"));
+    basePath = resolve3(db.config.projectRoot, specifier.replace(/\./g, "/"));
   }
   for (const candidate of pythonCandidateImportPaths(basePath)) {
-    const relativeCandidate = normalizePath(relative2(db.config.projectRoot, candidate));
+    const relativeCandidate = normalizePath(relative3(db.config.projectRoot, candidate));
     if (indexedPaths.has(relativeCandidate) || existsSync8(candidate)) {
       return relativeCandidate;
     }
@@ -2205,17 +2367,17 @@ function resolveRustImportPath(db, importerPath, specifier) {
   if (!normalizedSpecifier.startsWith("crate::") && !normalizedSpecifier.startsWith("self::") && !normalizedSpecifier.startsWith("super::")) {
     return null;
   }
-  const importerDir = dirname2(join8(db.config.projectRoot, importerPath));
+  const importerDir = dirname3(join8(db.config.projectRoot, importerPath));
   let basePath;
   if (normalizedSpecifier.startsWith("crate::")) {
-    basePath = resolve2(db.config.projectRoot, "src", normalizedSpecifier.slice("crate::".length).replace(/::/g, "/"));
+    basePath = resolve3(db.config.projectRoot, "src", normalizedSpecifier.slice("crate::".length).replace(/::/g, "/"));
   } else if (normalizedSpecifier.startsWith("self::")) {
-    basePath = resolve2(importerDir, normalizedSpecifier.slice("self::".length).replace(/::/g, "/"));
+    basePath = resolve3(importerDir, normalizedSpecifier.slice("self::".length).replace(/::/g, "/"));
   } else {
-    basePath = resolve2(dirname2(importerDir), normalizedSpecifier.slice("super::".length).replace(/::/g, "/"));
+    basePath = resolve3(dirname3(importerDir), normalizedSpecifier.slice("super::".length).replace(/::/g, "/"));
   }
   for (const candidate of rustCandidateImportPaths(basePath)) {
-    const relativeCandidate = normalizePath(relative2(db.config.projectRoot, candidate));
+    const relativeCandidate = normalizePath(relative3(db.config.projectRoot, candidate));
     if (getIndexedPaths(db).has(relativeCandidate) || existsSync8(candidate)) {
       return relativeCandidate;
     }
@@ -2223,10 +2385,10 @@ function resolveRustImportPath(db, importerPath, specifier) {
   return null;
 }
 function resolveRubyImportPath(db, importerPath, specifier) {
-  const importerDir = dirname2(join8(db.config.projectRoot, importerPath));
-  const absolute = resolve2(importerDir, specifier);
+  const importerDir = dirname3(join8(db.config.projectRoot, importerPath));
+  const absolute = resolve3(importerDir, specifier);
   for (const candidate of rubyCandidateImportPaths(absolute)) {
-    const relativeCandidate = normalizePath(relative2(db.config.projectRoot, candidate));
+    const relativeCandidate = normalizePath(relative3(db.config.projectRoot, candidate));
     if (getIndexedPaths(db).has(relativeCandidate) || existsSync8(candidate)) {
       return relativeCandidate;
     }
@@ -2235,15 +2397,15 @@ function resolveRubyImportPath(db, importerPath, specifier) {
 }
 function resolveCLikeImportPath(db, importerPath, specifier) {
   const indexedPaths = getIndexedPaths(db);
-  const importerDir = dirname2(join8(db.config.projectRoot, importerPath));
+  const importerDir = dirname3(join8(db.config.projectRoot, importerPath));
   const candidates = [
-    resolve2(importerDir, specifier),
-    resolve2(db.config.projectRoot, specifier),
-    resolve2(db.config.projectRoot, "include", specifier),
-    resolve2(db.config.projectRoot, "src", specifier)
+    resolve3(importerDir, specifier),
+    resolve3(db.config.projectRoot, specifier),
+    resolve3(db.config.projectRoot, "include", specifier),
+    resolve3(db.config.projectRoot, "src", specifier)
   ];
   for (const candidate of candidates) {
-    const relativeCandidate = normalizePath(relative2(db.config.projectRoot, candidate));
+    const relativeCandidate = normalizePath(relative3(db.config.projectRoot, candidate));
     if (indexedPaths.has(relativeCandidate) || existsSync8(candidate)) {
       return relativeCandidate;
     }
@@ -2261,10 +2423,10 @@ function resolveQualifiedImportPath(db, specifier, extensions) {
     if (exact) return exact;
   }
   for (const ext of extensions) {
-    const basenameMatch = [...indexedPaths].find((relativePath) => basename(relativePath) === `${basenameOnly}${ext}`);
+    const basenameMatch = [...indexedPaths].find((relativePath) => basename2(relativePath) === `${basenameOnly}${ext}`);
     if (basenameMatch) return basenameMatch;
   }
-  const folderMatches = [...indexedPaths].filter((relativePath) => extensions.includes(extname2(relativePath).toLowerCase())).filter((relativePath) => relativePath.includes(`/${pathified}/`) || relativePath.includes(`/${basenameOnly}/`)).sort((left, right) => left.localeCompare(right));
+  const folderMatches = [...indexedPaths].filter((relativePath) => extensions.includes(extname3(relativePath).toLowerCase())).filter((relativePath) => relativePath.includes(`/${pathified}/`) || relativePath.includes(`/${basenameOnly}/`)).sort((left, right) => left.localeCompare(right));
   if (folderMatches.length === 1) {
     return folderMatches[0];
   }
@@ -2281,10 +2443,10 @@ function resolveDartImportPath(db, importerPath, specifier) {
     if (indexedPaths.has(candidate)) return candidate;
     return null;
   }
-  const importerDir = dirname2(join8(db.config.projectRoot, importerPath));
-  const absolute = resolve2(importerDir, specifier);
+  const importerDir = dirname3(join8(db.config.projectRoot, importerPath));
+  const absolute = resolve3(importerDir, specifier);
   for (const candidate of dartCandidateImportPaths(absolute)) {
-    const relativeCandidate = normalizePath(relative2(db.config.projectRoot, candidate));
+    const relativeCandidate = normalizePath(relative3(db.config.projectRoot, candidate));
     if (indexedPaths.has(relativeCandidate) || existsSync8(candidate)) {
       return relativeCandidate;
     }
@@ -2292,7 +2454,7 @@ function resolveDartImportPath(db, importerPath, specifier) {
   return null;
 }
 function pythonCandidateImportPaths(basePath) {
-  const ext = extname2(basePath);
+  const ext = extname3(basePath);
   if (PYTHON_SOURCE_EXTENSIONS.includes(ext)) {
     return [basePath];
   }
@@ -2304,7 +2466,7 @@ function pythonCandidateImportPaths(basePath) {
   ];
 }
 function rustCandidateImportPaths(basePath) {
-  const ext = extname2(basePath);
+  const ext = extname3(basePath);
   if (RUST_SOURCE_EXTENSIONS.includes(ext)) {
     return [basePath];
   }
@@ -2314,7 +2476,7 @@ function rustCandidateImportPaths(basePath) {
   ];
 }
 function rubyCandidateImportPaths(basePath) {
-  const ext = extname2(basePath);
+  const ext = extname3(basePath);
   if (RUBY_SOURCE_EXTENSIONS.includes(ext)) {
     return [basePath];
   }
@@ -2324,14 +2486,14 @@ function rubyCandidateImportPaths(basePath) {
   ];
 }
 function dartCandidateImportPaths(basePath) {
-  const ext = extname2(basePath);
+  const ext = extname3(basePath);
   if (DART_SOURCE_EXTENSIONS.includes(ext)) {
     return [basePath];
   }
   return [`${basePath}.dart`, basePath];
 }
 function candidateImportPaths(absolute) {
-  const ext = extname2(absolute);
+  const ext = extname3(absolute);
   const candidates = /* @__PURE__ */ new Set();
   if (ext) {
     candidates.add(absolute);
@@ -2373,44 +2535,55 @@ function getCachedMap(cache, db) {
 function normalizePath(path2) {
   return path2.replace(/\\/g, "/");
 }
+var LANGUAGE_EXTENSION_FAMILIES = [
+  SOURCE_EXTENSIONS,
+  PYTHON_SOURCE_EXTENSIONS,
+  JVM_SOURCE_EXTENSIONS,
+  RUST_SOURCE_EXTENSIONS,
+  RUBY_SOURCE_EXTENSIONS,
+  C_LIKE_SOURCE_EXTENSIONS,
+  DOTNET_SOURCE_EXTENSIONS,
+  DART_SOURCE_EXTENSIONS,
+  PHP_SOURCE_EXTENSIONS
+];
+function hasExtensionIn(relativePath, extensions) {
+  return extensions.includes(extname3(relativePath).toLowerCase());
+}
 function isJavaScriptSourcePath(relativePath) {
-  return SOURCE_EXTENSIONS.includes(extname2(relativePath).toLowerCase());
+  return hasExtensionIn(relativePath, SOURCE_EXTENSIONS);
 }
 function isPythonSourcePath(relativePath) {
-  return PYTHON_SOURCE_EXTENSIONS.includes(extname2(relativePath).toLowerCase());
+  return hasExtensionIn(relativePath, PYTHON_SOURCE_EXTENSIONS);
 }
 function isJvmSourcePath(relativePath) {
-  return JVM_SOURCE_EXTENSIONS.includes(extname2(relativePath).toLowerCase());
+  return hasExtensionIn(relativePath, JVM_SOURCE_EXTENSIONS);
 }
 function isRustSourcePath(relativePath) {
-  return RUST_SOURCE_EXTENSIONS.includes(extname2(relativePath).toLowerCase());
+  return hasExtensionIn(relativePath, RUST_SOURCE_EXTENSIONS);
 }
 function isRubySourcePath(relativePath) {
-  return RUBY_SOURCE_EXTENSIONS.includes(extname2(relativePath).toLowerCase());
+  return hasExtensionIn(relativePath, RUBY_SOURCE_EXTENSIONS);
 }
 function isCLikeSourcePath(relativePath) {
-  return C_LIKE_SOURCE_EXTENSIONS.includes(extname2(relativePath).toLowerCase());
+  return hasExtensionIn(relativePath, C_LIKE_SOURCE_EXTENSIONS);
 }
 function isDotNetSourcePath(relativePath) {
-  return DOTNET_SOURCE_EXTENSIONS.includes(extname2(relativePath).toLowerCase());
+  return hasExtensionIn(relativePath, DOTNET_SOURCE_EXTENSIONS);
 }
 function isVisualBasicSourcePath(relativePath) {
-  return extname2(relativePath).toLowerCase() === ".vb";
+  return extname3(relativePath).toLowerCase() === ".vb";
 }
 function isDartSourcePath(relativePath) {
-  return DART_SOURCE_EXTENSIONS.includes(extname2(relativePath).toLowerCase());
+  return hasExtensionIn(relativePath, DART_SOURCE_EXTENSIONS);
 }
 function isPhpSourcePath(relativePath) {
-  return PHP_SOURCE_EXTENSIONS.includes(extname2(relativePath).toLowerCase());
+  return hasExtensionIn(relativePath, PHP_SOURCE_EXTENSIONS);
 }
 function extensionFamilyFor(relativePath) {
-  if (isJvmSourcePath(relativePath)) return JVM_SOURCE_EXTENSIONS;
-  if (isDotNetSourcePath(relativePath)) return DOTNET_SOURCE_EXTENSIONS;
-  if (isPhpSourcePath(relativePath)) return PHP_SOURCE_EXTENSIONS;
-  if (isDartSourcePath(relativePath)) return DART_SOURCE_EXTENSIONS;
-  if (isCLikeSourcePath(relativePath)) return C_LIKE_SOURCE_EXTENSIONS;
-  if (isRustSourcePath(relativePath)) return RUST_SOURCE_EXTENSIONS;
-  if (isRubySourcePath(relativePath)) return RUBY_SOURCE_EXTENSIONS;
+  const ext = extname3(relativePath).toLowerCase();
+  for (const family of LANGUAGE_EXTENSION_FAMILIES) {
+    if (family.includes(ext)) return family;
+  }
   return SOURCE_EXTENSIONS;
 }
 function getSourceText(db, relativePath) {
@@ -2425,7 +2598,7 @@ function getSourceText(db, relativePath) {
     cache.set(normalized, "");
     return "";
   }
-  const source = readFileSync3(fullPath, "utf-8");
+  const source = readFileSync4(fullPath, "utf-8");
   cache.set(normalized, source);
   return source;
 }
@@ -2612,6 +2785,9 @@ function leafSuffix(raw) {
   const last = sym.descriptors[sym.descriptors.length - 1];
   return last?.suffix ?? null;
 }
+function isCallableSymbol(raw) {
+  return raw.endsWith("().") || leafSuffix(raw) === "method";
+}
 function isFunctionLikeSymbol(raw) {
   const suffix = leafSuffix(raw);
   return suffix === "method" || suffix === "term";
@@ -3065,56 +3241,41 @@ function findEnclosingDefinition(definitions, line) {
   }
   return best;
 }
-function getPythonSourceCalleeRows(db, symbol, limit) {
-  const match = getFullSymbolMatch(db, symbol);
-  if (!match || !isPythonDocument(db, match.relativePath)) {
-    return [];
-  }
-  const definitions = getDefinitionsForFile(db, match.relativePath);
-  const current = definitions.find((definition) => definition.symbolId === match.symbolId);
-  if (!current) {
-    return [];
-  }
-  const imports2 = getSourceImports(db, match.relativePath);
-  const bindings = new Map(
-    getSourceConstructorBindings(db, match.relativePath, {
-      startLine: match.startLine,
-      endLine: match.endLine
-    }).map((binding) => [binding.localName, binding.typeName])
-  );
-  const rows = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const call of getSourceCalls(db, match.relativePath, {
-    startLine: match.startLine,
-    endLine: match.endLine
-  })) {
-    const resolved = resolvePythonCallTarget(
-      db,
-      current,
-      definitions,
-      imports2,
-      bindings,
-      call.receiverName,
-      call.calleeName
-    );
-    if (!resolved || resolved.symbolId === match.symbolId || db.isIgnored(resolved.relativePath)) continue;
-    const chunkId = 1e9 + call.line;
-    const key = `${resolved.symbol}|${resolved.relativePath}|${chunkId}`;
-    if (seen.has(key)) continue;
-    seen.add(key);
-    rows.push({
-      symbol: resolved.symbol,
-      file: resolved.relativePath,
-      chunkId
-    });
-  }
-  return applyLimit(rows, limit);
-}
-function getJavaScriptSourceCalleeRows(db, symbol, limit) {
-  const match = getFullSymbolMatch(db, symbol);
-  if (!match || !isJavaScriptDocument(db, match.relativePath)) {
-    return [];
-  }
+var LANGUAGE_CALLEE_CONFIGS = [
+  // Python (index 0) — complex resolver
+  { kind: "complex", languageIndex: 0, resolver: resolvePythonCallTarget },
+  // JavaScript/TypeScript (index 1) — complex resolver
+  { kind: "complex", languageIndex: 1, resolver: resolveJavaScriptCallTarget },
+  // Java (index 2) — simple with field bindings
+  { kind: "simple", languageIndex: 2, parseBindings: (_db, source) => parseJavaFieldBindings(source) },
+  // Kotlin (index 3) — simple with field bindings
+  { kind: "simple", languageIndex: 3, parseBindings: (_db, source) => parseKotlinFieldBindings(source) },
+  // Scala (index 4) — simple, no bindings
+  { kind: "simple", languageIndex: 4, parseBindings: null },
+  // C# (index 5) — simple, no bindings
+  { kind: "simple", languageIndex: 5, parseBindings: null },
+  // Visual Basic (index 6) — simple, no bindings
+  { kind: "simple", languageIndex: 6, parseBindings: null },
+  // C++ (index 7) — simple with receiver bindings
+  { kind: "simple", languageIndex: 7, parseBindings: (_db, source) => parseCppReceiverBindings(source) },
+  // Rust (index 8) — simple, no bindings
+  { kind: "simple", languageIndex: 8, parseBindings: null },
+  // Ruby (index 9) — simple with dual-attempt logic
+  {
+    kind: "simple",
+    languageIndex: 9,
+    parseBindings: (db, source) => parseRubyReceiverBindings(db, source),
+    dualAttempt: {
+      baseOpts: { allowInstanceVariables: true },
+      extendedOpts: { allowInstanceVariables: true, allowBareMemberCalls: true }
+    }
+  },
+  // Dart (index 10) — simple, no bindings
+  { kind: "simple", languageIndex: 10, parseBindings: null },
+  // PHP (index 11) — simple, no bindings
+  { kind: "simple", languageIndex: 11, parseBindings: null }
+];
+function getComplexSourceCalleeRows(db, match, config, limit) {
   const definitions = getDefinitionsForFile(db, match.relativePath);
   const current = definitions.find((definition) => definition.symbolId === match.symbolId);
   if (!current) {
@@ -3133,7 +3294,7 @@ function getJavaScriptSourceCalleeRows(db, symbol, limit) {
     startLine: match.startLine,
     endLine: match.endLine
   })) {
-    const resolved = resolveJavaScriptCallTarget(
+    const resolved = config.resolver(
       db,
       current,
       definitions,
@@ -3155,134 +3316,31 @@ function getJavaScriptSourceCalleeRows(db, symbol, limit) {
   }
   return applyLimit(rows, limit);
 }
-function getJavaSourceCalleeRows(db, symbol, limit) {
-  const match = getFullSymbolMatch(db, symbol);
-  if (!match || !isJavaDocument(db, match.relativePath)) {
-    return [];
-  }
-  const calls = getSimpleSourceCalls(db, match.relativePath, match.startLine, match.endLine);
-  const bindings = parseJavaFieldBindings(getSourceText(db, match.relativePath));
-  return resolveSimpleSourceCallees(db, match, calls, bindings, limit);
-}
-function getKotlinSourceCalleeRows(db, symbol, limit) {
-  const match = getFullSymbolMatch(db, symbol);
-  if (!match || !isKotlinDocument(db, match.relativePath)) {
-    return [];
-  }
-  const calls = getSimpleSourceCalls(db, match.relativePath, match.startLine, match.endLine);
-  const bindings = parseKotlinFieldBindings(getSourceText(db, match.relativePath));
-  return resolveSimpleSourceCallees(db, match, calls, bindings, limit);
-}
-function getScalaSourceCalleeRows(db, symbol, limit) {
-  const match = getFullSymbolMatch(db, symbol);
-  if (!match || !isScalaDocument(db, match.relativePath)) {
-    return [];
-  }
-  const calls = getSimpleSourceCalls(db, match.relativePath, match.startLine, match.endLine);
-  return resolveSimpleSourceCallees(db, match, calls, /* @__PURE__ */ new Map(), limit);
-}
-function getCSharpSourceCalleeRows(db, symbol, limit) {
-  const match = getFullSymbolMatch(db, symbol);
-  if (!match || !isCSharpDocument(db, match.relativePath)) {
-    return [];
-  }
-  const calls = getSimpleSourceCalls(db, match.relativePath, match.startLine, match.endLine);
-  return resolveSimpleSourceCallees(db, match, calls, /* @__PURE__ */ new Map(), limit);
-}
-function getVisualBasicSourceCalleeRows(db, symbol, limit) {
-  const match = getFullSymbolMatch(db, symbol);
-  if (!match || !isVisualBasicDocument(db, match.relativePath)) {
-    return [];
-  }
-  const calls = getSimpleSourceCalls(db, match.relativePath, match.startLine, match.endLine);
-  return resolveSimpleSourceCallees(db, match, calls, /* @__PURE__ */ new Map(), limit);
-}
-function getCppSourceCalleeRows(db, symbol, limit) {
-  const match = getFullSymbolMatch(db, symbol);
-  if (!match || !isCppDocument(db, match.relativePath)) {
-    return [];
+function getSimpleLanguageCalleeRows(db, match, config, limit) {
+  let calls;
+  if (config.dualAttempt) {
+    const baseCalls = getSimpleSourceCalls(db, match.relativePath, match.startLine, match.endLine, config.dualAttempt.baseOpts);
+    const extendedCalls = getSimpleSourceCalls(db, match.relativePath, match.startLine, match.endLine, config.dualAttempt.extendedOpts);
+    calls = extendedCalls.length > 0 ? extendedCalls : baseCalls;
+  } else {
+    calls = getSimpleSourceCalls(db, match.relativePath, match.startLine, match.endLine, config.sourceCallOpts);
   }
-  const calls = getSimpleSourceCalls(db, match.relativePath, match.startLine, match.endLine);
-  const bindings = parseCppReceiverBindings(getSourceText(db, match.relativePath));
+  const bindings = config.parseBindings ? config.parseBindings(db, getSourceText(db, match.relativePath)) : /* @__PURE__ */ new Map();
   return resolveSimpleSourceCallees(db, match, calls, bindings, limit);
 }
-function getRustSourceCalleeRows(db, symbol, limit) {
-  const match = getFullSymbolMatch(db, symbol);
-  if (!match || !isRustDocument(db, match.relativePath)) {
-    return [];
-  }
-  const calls = getSimpleSourceCalls(db, match.relativePath, match.startLine, match.endLine);
-  return resolveSimpleSourceCallees(db, match, calls, /* @__PURE__ */ new Map(), limit);
-}
-function getRubySourceCalleeRows(db, symbol, limit) {
-  const match = getFullSymbolMatch(db, symbol);
-  if (!match || !isRubyDocument(db, match.relativePath)) {
-    return [];
-  }
-  const calls = getSimpleSourceCalls(db, match.relativePath, match.startLine, match.endLine, { allowInstanceVariables: true });
-  const rubyCalls = getSimpleSourceCalls(db, match.relativePath, match.startLine, match.endLine, {
-    allowInstanceVariables: true,
-    allowBareMemberCalls: true
-  });
-  const bindings = parseRubyReceiverBindings(db, getSourceText(db, match.relativePath));
-  return resolveSimpleSourceCallees(db, match, rubyCalls.length > 0 ? rubyCalls : calls, bindings, limit);
-}
-function getDartSourceCalleeRows(db, symbol, limit) {
-  const match = getFullSymbolMatch(db, symbol);
-  if (!match || !isDartDocument(db, match.relativePath)) {
-    return [];
-  }
-  const calls = getSimpleSourceCalls(db, match.relativePath, match.startLine, match.endLine);
-  return resolveSimpleSourceCallees(db, match, calls, /* @__PURE__ */ new Map(), limit);
-}
-function getPhpSourceCalleeRows(db, symbol, limit) {
-  const match = getFullSymbolMatch(db, symbol);
-  if (!match || !isPhpDocument(db, match.relativePath)) {
-    return [];
-  }
-  const calls = getSimpleSourceCalls(db, match.relativePath, match.startLine, match.endLine);
-  return resolveSimpleSourceCallees(db, match, calls, /* @__PURE__ */ new Map(), limit);
-}
 function getSourceBackedCalleeRows(db, symbol, limit) {
   const match = getFullSymbolMatch(db, symbol);
   if (!match) {
     return [];
   }
-  if (isPythonDocument(db, match.relativePath)) {
-    return getPythonSourceCalleeRows(db, match, limit);
-  }
-  if (isJavaScriptDocument(db, match.relativePath)) {
-    return getJavaScriptSourceCalleeRows(db, match, limit);
-  }
-  if (isJavaDocument(db, match.relativePath)) {
-    return getJavaSourceCalleeRows(db, match, limit);
-  }
-  if (isScalaDocument(db, match.relativePath)) {
-    return getScalaSourceCalleeRows(db, match, limit);
-  }
-  if (isKotlinDocument(db, match.relativePath)) {
-    return getKotlinSourceCalleeRows(db, match, limit);
-  }
-  if (isCSharpDocument(db, match.relativePath)) {
-    return getCSharpSourceCalleeRows(db, match, limit);
-  }
-  if (isVisualBasicDocument(db, match.relativePath)) {
-    return getVisualBasicSourceCalleeRows(db, match, limit);
-  }
-  if (isCppDocument(db, match.relativePath)) {
-    return getCppSourceCalleeRows(db, match, limit);
-  }
-  if (isRustDocument(db, match.relativePath)) {
-    return getRustSourceCalleeRows(db, match, limit);
-  }
-  if (isRubyDocument(db, match.relativePath)) {
-    return getRubySourceCalleeRows(db, match, limit);
-  }
-  if (isDartDocument(db, match.relativePath)) {
-    return getDartSourceCalleeRows(db, match, limit);
-  }
-  if (isPhpDocument(db, match.relativePath)) {
-    return getPhpSourceCalleeRows(db, match, limit);
+  for (const config of LANGUAGE_CALLEE_CONFIGS) {
+    if (!isDocumentLanguage(db, match.relativePath, DOCUMENT_LANGUAGE_TABLE[config.languageIndex])) {
+      continue;
+    }
+    if (config.kind === "complex") {
+      return getComplexSourceCalleeRows(db, match, config, limit);
+    }
+    return getSimpleLanguageCalleeRows(db, match, config, limit);
   }
   return [];
 }
@@ -3292,9 +3350,11 @@ function getPythonSourceCallerRows(db, target, limit) {
   }
   const rows = [];
   const seen = /* @__PURE__ */ new Set();
+  const pythonConfig = LANGUAGE_CALLEE_CONFIGS[0];
   for (const candidate of getAllFunctionLikeDefinitions(db)) {
     if (candidate.symbolId === target.symbolId) continue;
-    const callees = getPythonSourceCalleeRows(db, candidate);
+    if (!isDocumentLanguage(db, candidate.relativePath, DOCUMENT_LANGUAGE_TABLE[pythonConfig.languageIndex])) continue;
+    const callees = getComplexSourceCalleeRows(db, candidate, pythonConfig);
     if (!callees.some((callee) => callee.symbol === target.symbol)) continue;
     const key = `${candidate.symbol}|${candidate.relativePath}`;
     if (seen.has(key) || db.isIgnored(candidate.relativePath)) continue;
@@ -3636,6 +3696,17 @@ function getAllDefinitions(db, opts = {}) {
   );
   return rows.filter((row) => !db.isIgnored(row.relative_path)).flatMap((row) => getDefinitionsForFile(db, row.relative_path));
 }
+function getScopedDefinitions(db, scope) {
+  const scopeFilter = scope ? `AND relative_path LIKE '%${scope}%'` : "";
+  return db.all(
+    `SELECT relative_path
+     FROM documents
+     WHERE 1 = 1
+       ${db.pathExclusionsFor("documents")}
+       ${scopeFilter}
+     ORDER BY relative_path`
+  ).flatMap((row) => getDefinitionsForFile(db, row.relative_path)).filter((row) => !db.isIgnored(row.relativePath));
+}
 function getAllFunctionLikeDefinitions(db) {
   return getAllDefinitions(db).filter((definition) => definition.isFunctionLike);
 }
@@ -4053,89 +4124,29 @@ function parentTypeName(rawSymbol) {
   }
   return null;
 }
-function isPythonDocument(db, relativePath) {
-  const row = db.get(
-    `SELECT language FROM documents WHERE relative_path = ? LIMIT 1`,
-    relativePath
-  );
-  return row?.language === "python" || relativePath.endsWith(".py") || relativePath.endsWith(".pyi");
-}
-function isJavaScriptDocument(db, relativePath) {
-  const row = db.get(
-    `SELECT language FROM documents WHERE relative_path = ? LIMIT 1`,
-    relativePath
-  );
-  return row?.language === "typescript" || row?.language === "javascript" || /\.(?:[cm]?[jt]sx?)$/.test(relativePath);
-}
-function isJavaDocument(db, relativePath) {
-  const row = db.get(
-    `SELECT language FROM documents WHERE relative_path = ? LIMIT 1`,
-    relativePath
-  );
-  return row?.language === "java" || relativePath.endsWith(".java");
-}
-function isKotlinDocument(db, relativePath) {
-  const row = db.get(
-    `SELECT language FROM documents WHERE relative_path = ? LIMIT 1`,
-    relativePath
-  );
-  return row?.language === "kotlin" || relativePath.endsWith(".kt") || relativePath.endsWith(".kts");
-}
-function isScalaDocument(db, relativePath) {
-  const row = db.get(
-    `SELECT language FROM documents WHERE relative_path = ? LIMIT 1`,
-    relativePath
-  );
-  return row?.language === "scala" || relativePath.endsWith(".scala");
-}
-function isCSharpDocument(db, relativePath) {
-  const row = db.get(
-    `SELECT language FROM documents WHERE relative_path = ? LIMIT 1`,
-    relativePath
-  );
-  return row?.language === "C#" || relativePath.endsWith(".cs");
-}
-function isVisualBasicDocument(db, relativePath) {
-  const row = db.get(
-    `SELECT language FROM documents WHERE relative_path = ? LIMIT 1`,
-    relativePath
-  );
-  return row?.language === "Visual Basic" || relativePath.endsWith(".vb");
-}
-function isCppDocument(db, relativePath) {
-  const row = db.get(
-    `SELECT language FROM documents WHERE relative_path = ? LIMIT 1`,
-    relativePath
-  );
-  return row?.language === "CPP" || /\.(?:cc|cpp|cxx|hpp|hh|hxx)$/.test(relativePath);
-}
-function isRustDocument(db, relativePath) {
-  const row = db.get(
-    `SELECT language FROM documents WHERE relative_path = ? LIMIT 1`,
-    relativePath
-  );
-  return row?.language === "Rust" || relativePath.endsWith(".rs");
-}
-function isRubyDocument(db, relativePath) {
-  const row = db.get(
-    `SELECT language FROM documents WHERE relative_path = ? LIMIT 1`,
-    relativePath
-  );
-  return row?.language === "ruby" || relativePath.endsWith(".rb");
-}
-function isDartDocument(db, relativePath) {
+var DOCUMENT_LANGUAGE_TABLE = [
+  { languages: ["python"], extensionPattern: /\.(?:py|pyi)$/ },
+  { languages: ["typescript", "javascript"], extensionPattern: /\.(?:[cm]?[jt]sx?)$/ },
+  { languages: ["java"], extensionPattern: /\.java$/ },
+  { languages: ["kotlin"], extensionPattern: /\.(?:kt|kts)$/ },
+  { languages: ["scala"], extensionPattern: /\.scala$/ },
+  { languages: ["C#"], extensionPattern: /\.cs$/ },
+  { languages: ["Visual Basic"], extensionPattern: /\.vb$/ },
+  { languages: ["CPP"], extensionPattern: /\.(?:cc|cpp|cxx|hpp|hh|hxx)$/ },
+  { languages: ["Rust"], extensionPattern: /\.rs$/ },
+  { languages: ["ruby"], extensionPattern: /\.rb$/ },
+  { languages: ["Dart"], extensionPattern: /\.dart$/ },
+  { languages: ["PHP"], extensionPattern: /\.php$/ }
+];
+function isDocumentLanguage(db, relativePath, entry) {
   const row = db.get(
     `SELECT language FROM documents WHERE relative_path = ? LIMIT 1`,
     relativePath
   );
-  return row?.language === "Dart" || relativePath.endsWith(".dart");
+  return entry.languages.includes(row?.language ?? "") || entry.extensionPattern.test(relativePath);
 }
-function isPhpDocument(db, relativePath) {
-  const row = db.get(
-    `SELECT language FROM documents WHERE relative_path = ? LIMIT 1`,
-    relativePath
-  );
-  return row?.language === "PHP" || relativePath.endsWith(".php");
+function isPythonDocument(db, relativePath) {
+  return isDocumentLanguage(db, relativePath, DOCUMENT_LANGUAGE_TABLE[0]);
 }
 function applyLimit(values, limit) {
   return typeof limit === "number" ? values.slice(0, limit) : values;
@@ -4174,8 +4185,8 @@ function resolveDocumentCandidates(db, filePattern, opts) {
 }
 function scoreDocumentPath(relativePath, rawPattern) {
   const normalizedPath = normalizeLookupPath(relativePath);
-  const pathBase = basename2(normalizedPath);
-  const patternBase = basename2(rawPattern);
+  const pathBase = basename3(normalizedPath);
+  const patternBase = basename3(rawPattern);
   let score = 0;
   if (normalizedPath === rawPattern) score += 1200;
   if (normalizedPath.endsWith(`/${rawPattern}`)) score += 1100;
@@ -4221,7 +4232,7 @@ function symbols(db, filePattern) {
 }
 
 // src/queries/methods.ts
-import { basename as basename3 } from "path";
+import { basename as basename4 } from "path";
 function methods(db, className) {
   const classMatch = findFirstSymbolMatch(db, className);
   if (!classMatch) {
@@ -4230,16 +4241,13 @@ function methods(db, className) {
   const ownerName = leafName(classMatch.symbol);
   const definitions = getDefinitionsForFile(db, classMatch.relativePath).filter((definition) => isCallableSymbol(definition.symbol));
   const directMethods = definitions.filter((definition) => definition.parentTypeName === ownerName || definition.symbol.includes(ownerName));
-  const fileScopedMethods = directMethods.length > 0 ? directMethods : stripExtension(basename3(classMatch.relativePath)) === ownerName ? definitions.filter((definition) => definition.symbol.includes("<invalid-global-code>")) : [];
+  const fileScopedMethods = directMethods.length > 0 ? directMethods : stripExtension(basename4(classMatch.relativePath)) === ownerName ? definitions.filter((definition) => definition.symbol.includes("<invalid-global-code>")) : [];
   return fileScopedMethods.map((definition) => ({
     startLine: definition.startLine,
     endLine: definition.endLine,
     name: leafName(definition.symbol)
   }));
 }
-function isCallableSymbol(rawSymbol) {
-  return rawSymbol.endsWith("().") || leafSuffix(rawSymbol) === "method";
-}
 function stripExtension(relativePath) {
   return relativePath.replace(/\.[^.]+$/, "");
 }
@@ -4577,7 +4585,7 @@ function surface(db, modulePattern) {
     ...matchedPaths
   );
   const exposedDefinitions = matchedPaths.flatMap(
-    (relativePath) => getDefinitionsForFile(db, relativePath).filter((definition) => isCallableSymbol2(definition.symbol)).map((definition) => ({
+    (relativePath) => getDefinitionsForFile(db, relativePath).filter((definition) => isCallableSymbol(definition.symbol)).map((definition) => ({
       relative_path: relativePath,
       symbol: definition.symbol
     }))
@@ -4594,9 +4602,6 @@ function surface(db, modulePattern) {
     shortName: shortenSymbol(r.symbol)
   }));
 }
-function isCallableSymbol2(rawSymbol) {
-  return rawSymbol.endsWith("().") || leafSuffix(rawSymbol) === "method";
-}
 
 // src/entry-surfaces.ts
 var liveBarrelCache = /* @__PURE__ */ new WeakMap();
@@ -4614,11 +4619,11 @@ function isWorkerEntrySurface(path2) {
 function isStructuralEntrySurface(path2) {
   const normalized = normalizePath2(path2);
   const segments = normalized.split("/");
-  const basename5 = segments[segments.length - 1] ?? normalized;
-  if (basename5 === "cli.ts" || basename5 === "cli.js" || basename5 === "postinstall.ts" || basename5 === "postinstall.js" || basename5 === "main.ts" || basename5 === "main.js" || basename5 === "main.rs" || basename5 === "main.go" || basename5 === "main.py") {
+  const basename6 = segments[segments.length - 1] ?? normalized;
+  if (basename6 === "cli.ts" || basename6 === "cli.js" || basename6 === "postinstall.ts" || basename6 === "postinstall.js" || basename6 === "main.ts" || basename6 === "main.js" || basename6 === "main.rs" || basename6 === "main.go" || basename6 === "main.py") {
     return true;
   }
-  if (basename5 === "index.ts" || basename5 === "index.js") {
+  if (basename6 === "index.ts" || basename6 === "index.js") {
     return segments.length <= 2;
   }
   return normalized.endsWith("/mod.rs") || normalized.endsWith("/__init__.py");
@@ -4982,22 +4987,37 @@ function outline(db, filePattern) {
     ORDER BY d.relative_path, der.start_line`,
     ...resolvedPaths
   );
+  const nodes = rows.map((r) => ({
+    symbol: r.symbol,
+    shortName: shortenSymbol(r.symbol),
+    startLine: r.start_line,
+    endLine: r.end_line,
+    children: []
+  }));
   const nodeMap = /* @__PURE__ */ new Map();
+  for (const n of nodes) nodeMap.set(n.symbol, n);
   const roots = [];
-  for (const r of rows) {
-    const node = {
-      symbol: r.symbol,
-      shortName: shortenSymbol(r.symbol),
-      startLine: r.start_line,
-      endLine: r.end_line,
-      children: []
-    };
-    nodeMap.set(r.symbol, node);
-  }
-  for (const r of rows) {
-    const node = nodeMap.get(r.symbol);
+  for (let i = 0; i < rows.length; i++) {
+    const r = rows[i];
+    const node = nodes[i];
     if (r.enclosing_symbol && nodeMap.has(r.enclosing_symbol)) {
       nodeMap.get(r.enclosing_symbol).children.push(node);
+      continue;
+    }
+    let bestParent = null;
+    let bestSize = Infinity;
+    for (const candidate of nodes) {
+      if (candidate === node) continue;
+      if (candidate.startLine <= node.startLine && candidate.endLine >= node.endLine) {
+        const size = candidate.endLine - candidate.startLine;
+        if (size < bestSize) {
+          bestSize = size;
+          bestParent = candidate;
+        }
+      }
+    }
+    if (bestParent) {
+      bestParent.children.push(node);
     } else {
       roots.push(node);
     }
@@ -5719,7 +5739,7 @@ function similar(db, symbolPattern, opts = {}) {
   return similarBySourceShape(db, symbolPattern, { minSimilarity, limit });
 }
 function similarAll(db, opts = {}) {
-  const { minSimilarity = 0.5, limit = 20, scope, minCallees = 4 } = opts;
+  const { minSimilarity = 0.5, limit = 20, scope, minCallees = 4, crossFileOnly = false } = opts;
   const all = getAllCalleeFingerprints(db, { minCallees, scope });
   const idfWeights = computeIdf(all);
   const results = [];
@@ -5727,14 +5747,16 @@ function similarAll(db, opts = {}) {
     for (let j = i + 1; j < all.length; j++) {
       const a = all[i];
       const b = all[j];
-      if (a.file === b.file) continue;
+      if (crossFileOnly && a.file === b.file) continue;
       const { similarity, significantShared } = weightedSimilarity(
         a.callees,
         b.callees,
         idfWeights
       );
       if (similarity < minSimilarity) continue;
-      if (significantShared.length < 2) continue;
+      const sharedCount = intersection(a.callees, b.callees).size;
+      if (significantShared.length < 2 && sharedCount < 4) continue;
+      const displayShared = significantShared.length > 0 ? significantShared : [...intersection(a.callees, b.callees)];
       results.push({
         symbolA: a.symbol,
         shortNameA: shortenSymbol(a.symbol),
@@ -5743,7 +5765,7 @@ function similarAll(db, opts = {}) {
         shortNameB: shortenSymbol(b.symbol),
         fileB: b.file,
         similarity,
-        sharedCallees: significantShared.map(shortenSymbol),
+        sharedCallees: displayShared.map(shortenSymbol),
         uniqueToA: [...difference(a.callees, b.callees)].map(shortenSymbol),
         uniqueToB: [...difference(b.callees, a.callees)].map(shortenSymbol)
       });
@@ -6121,8 +6143,8 @@ function similarChains(db, opts = {}) {
   }
   const structuralNames = ["index.ts", "index.js", "cli.ts", "main.ts", "health.ts", "health.js"];
   for (const node of nodeFreq.keys()) {
-    const basename5 = node.split("/").pop() ?? "";
-    if (structuralNames.includes(basename5)) infraNodes.add(node);
+    const basename6 = node.split("/").pop() ?? "";
+    if (structuralNames.includes(basename6)) infraNodes.add(node);
   }
   const filteredChains = [];
   for (const chain of rawChains) {
@@ -6296,8 +6318,8 @@ function extractCandidates(db, opts = {}) {
   const results = [];
   for (const sym of symbols2) {
     if (db.isIgnored(sym.relativePath)) continue;
-    const basename5 = sym.relativePath.split("/").pop() ?? "";
-    if (basename5.includes("types")) continue;
+    const basename6 = sym.relativePath.split("/").pop() ?? "";
+    if (basename6.includes("types")) continue;
     const calleeChunks = getCalleeRowsForSymbol(db, sym);
     const calleeSet = new Set(calleeChunks.map((c) => c.symbol));
     if (calleeSet.size < minCallees) continue;
@@ -6373,17 +6395,6 @@ function extractCandidates(db, opts = {}) {
   results.sort((a, b) => b.clusters.length - a.clusters.length || b.loc - a.loc);
   return results.slice(0, limit);
 }
-function getScopedDefinitions(db, scope) {
-  const scopeFilter = scope ? `AND relative_path LIKE '%${scope}%'` : "";
-  return db.all(
-    `SELECT relative_path
-     FROM documents
-     WHERE 1 = 1
-       ${db.pathExclusionsFor("documents")}
-       ${scopeFilter}
-     ORDER BY relative_path`
-  ).flatMap((row) => getDefinitionsForFile(db, row.relative_path)).filter((row) => !db.isIgnored(row.relativePath));
-}
 function definitionLoc(definition) {
   return definition.endLine - definition.startLine + 1;
 }
@@ -6809,32 +6820,32 @@ function isLikelyTypeOnlyDep(dep) {
 function shouldSkipDriftFile(filePath) {
   return isStructuralRole(path.basename(filePath)) || isTestLikePath(filePath);
 }
-function isStructuralRole(basename5) {
-  if (basename5 === "index.ts" || basename5 === "index.js") return true;
-  if (basename5 === "cli.ts" || basename5 === "main.ts" || basename5 === "main.rs") return true;
-  if (basename5.includes("worker.") || basename5.includes("postinstall.")) return true;
-  if (basename5 === "health.ts" || basename5 === "health.js") return true;
+function isStructuralRole(basename6) {
+  if (basename6 === "index.ts" || basename6 === "index.js") return true;
+  if (basename6 === "cli.ts" || basename6 === "main.ts" || basename6 === "main.rs") return true;
+  if (basename6.includes("worker.") || basename6.includes("postinstall.")) return true;
+  if (basename6 === "health.ts" || basename6 === "health.js") return true;
   return false;
 }
 function isTestLikePath(filePath) {
   const normalized = filePath.replace(/\\/g, "/");
-  const basename5 = path.basename(normalized);
-  return normalized.includes("/__tests__/") || normalized.includes("/tests/") || normalized.includes("/test/") || /\.(test|spec)\.[A-Za-z0-9]+$/.test(basename5) || /_(test|spec)\.[A-Za-z0-9]+$/.test(basename5) || /^test[_-]/.test(basename5) || /^test\./.test(basename5);
+  const basename6 = path.basename(normalized);
+  return normalized.includes("/__tests__/") || normalized.includes("/tests/") || normalized.includes("/test/") || /\.(test|spec)\.[A-Za-z0-9]+$/.test(basename6) || /_(test|spec)\.[A-Za-z0-9]+$/.test(basename6) || /^test[_-]/.test(basename6) || /^test\./.test(basename6);
 }
 
 // src/queries/wrapper-candidates.ts
-import { basename as basename4, extname as extname3 } from "path";
+import { basename as basename5, extname as extname4 } from "path";
 function wrapperCandidates(db, opts) {
   const { scope, maxLoc = 15, limit = 30 } = opts ?? {};
   const reverseFanIn = buildReverseFileFanIn(buildFileDepGraph(db, scope));
-  const symbols2 = getScopedDefinitions2(db, scope).filter((definition) => definitionLoc2(definition) <= maxLoc && definitionLoc2(definition) >= 2);
+  const symbols2 = getScopedDefinitions(db, scope).filter((definition) => definitionLoc2(definition) <= maxLoc && definitionLoc2(definition) >= 2);
   const results = [];
   for (const symbol of symbols2) {
     if (db.isIgnored(symbol.relativePath) || !isFunctionLikeSymbol(symbol.symbol)) continue;
-    const symbolStem = basename4(symbol.relativePath, extname3(symbol.relativePath));
+    const symbolStem = basename5(symbol.relativePath, extname4(symbol.relativePath));
     const callerRows = dedupeRows(
       getCallerRowsForSymbol(db, symbol, { limit: 200 }).filter((row) => row.file !== symbol.relativePath)
-    ).filter((row) => basename4(row.file, extname3(row.file)) !== symbolStem);
+    ).filter((row) => basename5(row.file, extname4(row.file)) !== symbolStem);
     if (callerRows.length !== 1) continue;
     const caller = callerRows[0];
     const callerDefinition = getDefinitionsForFile(db, caller.file).find((definition) => definition.symbol === caller.symbol);
@@ -6856,7 +6867,7 @@ function wrapperCandidates(db, opts) {
       endLine: symbol.endLine,
       loc: definitionLoc2(symbol),
       singleCaller: caller.symbol,
-      singleCallerShort: useDefinitionFanIn ? shortenSymbol(caller.symbol) : basename4(caller.file),
+      singleCallerShort: useDefinitionFanIn ? shortenSymbol(caller.symbol) : basename5(caller.file),
       callerFanIn
     });
   }
@@ -6866,17 +6877,6 @@ function wrapperCandidates(db, opts) {
 function definitionLoc2(definition) {
   return definition.endLine - definition.startLine + 1;
 }
-function getScopedDefinitions2(db, scope) {
-  const scopeFilter = scope ? `AND relative_path LIKE '%${scope}%'` : "";
-  return db.all(
-    `SELECT relative_path
-     FROM documents
-     WHERE 1 = 1
-       ${db.pathExclusionsFor("documents")}
-       ${scopeFilter}
-     ORDER BY relative_path`
-  ).flatMap((row) => getDefinitionsForFile(db, row.relative_path)).filter((row) => !db.isIgnored(row.relativePath));
-}
 function dedupeRows(rows) {
   const seen = /* @__PURE__ */ new Set();
   const unique = [];
@@ -6911,11 +6911,11 @@ function fallbackCallerFanIn(db, reverseFanIn, callerFile) {
   if (direct > 0) {
     return direct;
   }
-  const stem = basename4(callerFile, extname3(callerFile));
+  const stem = basename5(callerFile, extname4(callerFile));
   let best = 0;
   for (const [file, fanIn2] of reverseFanIn) {
     if (file === callerFile) continue;
-    if (basename4(file, extname3(file)) !== stem) continue;
+    if (basename5(file, extname4(file)) !== stem) continue;
     if (fanIn2 > best) {
       best = fanIn2;
     }
@@ -6926,7 +6926,7 @@ function fallbackCallerFanIn(db, reverseFanIn, callerFile) {
 // src/queries/passthrough-candidates.ts
 function passthroughCandidates(db, opts) {
   const { scope, maxLoc = 15, limit = 30 } = opts ?? {};
-  const symbols2 = getScopedDefinitions3(db, scope).filter((definition) => definitionLoc3(definition) >= 3 && definitionLoc3(definition) <= maxLoc);
+  const symbols2 = getScopedDefinitions(db, scope).filter((definition) => definitionLoc3(definition) >= 3 && definitionLoc3(definition) <= maxLoc);
   const results = [];
   for (const sym of symbols2) {
     if (db.isIgnored(sym.relativePath) || !isFunctionLikeSymbol(sym.symbol)) continue;
@@ -6955,17 +6955,6 @@ function passthroughCandidates(db, opts) {
   results.sort((a, b) => a.loc - b.loc || a.file.localeCompare(b.file));
   return results.slice(0, limit);
 }
-function getScopedDefinitions3(db, scope) {
-  const scopeFilter = scope ? `AND relative_path LIKE '%${scope}%'` : "";
-  return db.all(
-    `SELECT relative_path
-     FROM documents
-     WHERE 1 = 1
-       ${db.pathExclusionsFor("documents")}
-       ${scopeFilter}
-     ORDER BY relative_path`
-  ).flatMap((row) => getDefinitionsForFile(db, row.relative_path)).filter((row) => !db.isIgnored(row.relativePath));
-}
 function definitionLoc3(definition) {
   return definition.endLine - definition.startLine + 1;
 }
@@ -6973,7 +6962,7 @@ function definitionLoc3(definition) {
 // src/queries/stale-abstractions.ts
 function staleAbstractions(db, opts) {
   const { scope, minLoc = 3, limit = 30 } = opts ?? {};
-  const rows = getScopedDefinitions4(db, scope).filter((definition) => definition.isTypeLike && definitionLoc4(definition) >= minLoc).map((definition) => ({
+  const rows = getScopedDefinitions(db, scope).filter((definition) => definition.isTypeLike && definitionLoc4(definition) >= minLoc).map((definition) => ({
     symbol: definition.symbol,
     file: definition.relativePath,
     start_line: definition.startLine,
@@ -6993,11 +6982,11 @@ function staleAbstractions(db, opts) {
   })).slice(0, limit);
 }
 function getFilesWithFunctions(db, scope) {
-  return new Set(getScopedDefinitions4(db, scope).filter((definition) => definition.isFunctionLike).map((definition) => definition.relativePath));
+  return new Set(getScopedDefinitions(db, scope).filter((definition) => definition.isFunctionLike).map((definition) => definition.relativePath));
 }
 function isTrueStaleAbstraction(row, filesWithFunctions) {
-  const basename5 = row.file.split("/").pop() ?? "";
-  const isTypeFile = basename5.includes("types") || row.file.includes("/types/");
+  const basename6 = row.file.split("/").pop() ?? "";
+  const isTypeFile = basename6.includes("types") || row.file.includes("/types/");
   if (isTypeFile && row.consumers > 0) {
     return false;
   }
@@ -7006,17 +6995,6 @@ function isTrueStaleAbstraction(row, filesWithFunctions) {
   }
   return true;
 }
-function getScopedDefinitions4(db, scope) {
-  const scopeFilter = scope ? `AND relative_path LIKE '%${scope}%'` : "";
-  return db.all(
-    `SELECT relative_path
-     FROM documents
-     WHERE 1 = 1
-       ${db.pathExclusionsFor("documents")}
-       ${scopeFilter}
-     ORDER BY relative_path`
-  ).flatMap((row) => getDefinitionsForFile(db, row.relative_path)).filter((row) => !db.isIgnored(row.relativePath));
-}
 function countCrossFileConsumers(db, definition) {
   const callers = db.all(
     `SELECT DISTINCT d.relative_path
@@ -7395,7 +7373,7 @@ function convergence(db, symbolPatternA, symbolPatternB) {
 }
 
 // src/queries/code.ts
-import { readFileSync as readFileSync4 } from "fs";
+import { readFileSync as readFileSync5 } from "fs";
 import { join as join9 } from "path";
 function code(db, symbolPattern, opts = {}) {
   const { context = 0 } = opts;
@@ -7412,7 +7390,7 @@ function code(db, symbolPattern, opts = {}) {
   const filePath = join9(db.config.projectRoot, match.relativePath);
   let fileContent;
   try {
-    fileContent = readFileSync4(filePath, "utf-8");
+    fileContent = readFileSync5(filePath, "utf-8");
   } catch {
     return null;
   }
@@ -7424,9 +7402,11 @@ function code(db, symbolPattern, opts = {}) {
     symbol: match.symbol,
     shortName: shortenSymbol(match.symbol),
     relativePath: match.relativePath,
-    startLine: startLine + 1,
-    // 1-indexed for display
-    endLine: endLine + 1,
+    // 0-indexed, like every other query result. The CLI's displayLine()
+    // converts once at render time. Returning 1-indexed here caused a
+    // double-conversion in the CLI and printed labels off by +1.
+    startLine,
+    endLine,
     language: doc?.language ?? null,
     source
   };
@@ -7442,7 +7422,7 @@ function readFileRange(db, filePath, startLine, endLine, context) {
   const fullPath = join9(db.config.projectRoot, doc.relative_path);
   let fileContent;
   try {
-    fileContent = readFileSync4(fullPath, "utf-8");
+    fileContent = readFileSync5(fullPath, "utf-8");
   } catch {
     return null;
   }
@@ -7454,15 +7434,15 @@ function readFileRange(db, filePath, startLine, endLine, context) {
     symbol: `${doc.relative_path}:${startLine}-${endLine}`,
     shortName: `${doc.relative_path}:${startLine}-${endLine}`,
     relativePath: doc.relative_path,
-    startLine: start + 1,
-    endLine: end + 1,
+    startLine: start,
+    endLine: end,
     language: doc.language,
     source
   };
 }
 
 // src/queries/complexity.ts
-import { readFileSync as readFileSync5 } from "fs";
+import { readFileSync as readFileSync6 } from "fs";
 import { join as join10 } from "path";
 function complexity(db, symbolPattern) {
   const match = findFirstSymbolMatch(db, symbolPattern);
@@ -7475,7 +7455,7 @@ function complexity(db, symbolPattern) {
   const filePath = join10(db.config.projectRoot, match.relativePath);
   let source = "";
   try {
-    const lines = readFileSync5(filePath, "utf-8").split("\n");
+    const lines = readFileSync6(filePath, "utf-8").split("\n");
     source = lines.slice(match.startLine, match.endLine + 1).join("\n");
   } catch {
   }
@@ -7635,28 +7615,40 @@ function uniqueSymbolRows(rows) {
 
 // src/queries/slice.ts
 function slice(db, symbolPattern, opts = {}) {
-  const { direction = "backward" } = opts;
+  const { direction = "backward", maxDepth = 3 } = opts;
   const match = findFirstSymbolMatch(db, symbolPattern);
   if (!match) return null;
   if (direction === "backward") {
-    return backwardSlice(db, match);
+    return backwardSlice(db, match, maxDepth);
   } else {
     return forwardSlice(db, match);
   }
 }
-function backwardSlice(db, match) {
-  const callees = getCalleeRowsForSymbol(db, match);
-  const seen = /* @__PURE__ */ new Set();
+function backwardSlice(db, match, maxDepth) {
   const connected = [];
-  for (const c of callees) {
-    if (seen.has(c.symbol)) continue;
-    seen.add(c.symbol);
-    connected.push({
-      symbol: c.symbol,
-      shortName: shortenSymbol(c.symbol),
-      file: c.file,
-      relationship: "referenced within definition (callee)"
-    });
+  const visited = /* @__PURE__ */ new Set([match.symbol]);
+  let frontier = [match];
+  for (let depth = 1; depth <= maxDepth; depth++) {
+    if (frontier.length === 0) break;
+    const nextFrontier = [];
+    for (const current of frontier) {
+      const callees = getCalleeRowsForSymbol(db, current);
+      for (const c of callees) {
+        if (visited.has(c.symbol)) continue;
+        visited.add(c.symbol);
+        connected.push({
+          symbol: c.symbol,
+          shortName: shortenSymbol(c.symbol),
+          file: c.file,
+          relationship: depth === 1 ? "referenced within definition (callee)" : `depth ${depth} callee`
+        });
+        const calleeMatch = findExactSymbolMatch(db, c.symbol);
+        if (calleeMatch && !db.isIgnored(calleeMatch.relativePath)) {
+          nextFrontier.push(calleeMatch);
+        }
+      }
+    }
+    frontier = nextFrontier;
   }
   return {
     symbol: match.symbol,
@@ -8047,7 +8039,7 @@ import {
   readlinkSync,
   unlinkSync
 } from "fs";
-import { join as join11, dirname as dirname3, resolve as resolve3 } from "path";
+import { join as join11, dirname as dirname4, resolve as resolve4 } from "path";
 import { homedir as homedir2, platform as platform3 } from "os";
 import { fileURLToPath } from "url";
 var IS_WINDOWS3 = platform3() === "win32";
@@ -8062,7 +8054,7 @@ function installSkills(opts = {}) {
   const log = opts.quiet ? () => {
   } : console.log;
   const thisFile = fileURLToPath(import.meta.url);
-  const skillsSource = resolve3(dirname3(thisFile), "..", "skills");
+  const skillsSource = resolve4(dirname4(thisFile), "..", "skills");
   const targets = [
     join11(homedir2(), ".claude", "skills"),
     join11(homedir2(), ".codex", "skills")
@@ -8073,7 +8065,7 @@ function installSkills(opts = {}) {
     alreadyLinked: []
   };
   for (const targetDir of targets) {
-    const parentDir = dirname3(targetDir);
+    const parentDir = dirname4(targetDir);
     if (!existsSync9(parentDir)) {
       continue;
     }
@@ -8089,7 +8081,7 @@ function installSkills(opts = {}) {
       if (existsSync9(target)) {
         try {
           const existing = readlinkSync(target);
-          if (resolve3(existing) === resolve3(source)) {
+          if (resolve4(existing) === resolve4(source)) {
             result.alreadyLinked.push(`${toolName}/${skill}`);
             log(`  ok:   ${skill} \u2192 ${toolName} (already linked)`);
             continue;
@@ -8216,11 +8208,15 @@ var queries = {
 program.name("scip-query").description("Language-agnostic code intelligence CLI powered by SCIP indexes").version(cliVersion);
 program.command("reindex").description("Index the codebase and convert to SQLite").option("-l, --language <lang>", "Index only this language (can be repeated)", collect, []).option("--pnpm-workspaces", "Enable pnpm workspace support (TypeScript)").action(async (opts) => {
   const projectRoot = resolveProjectRoot();
+  const config = loadProjectConfig(projectRoot);
+  const paths = resolveIndexPaths(projectRoot, config);
   try {
     const result = await reindex({
       projectRoot,
-      languages: opts.language.length > 0 ? opts.language : void 0,
-      pnpmWorkspaces: opts.pnpmWorkspaces
+      languages: opts.language.length > 0 ? opts.language : config.languages,
+      outputScip: paths.indexPath,
+      outputDb: paths.dbPath,
+      pnpmWorkspaces: opts.pnpmWorkspaces || config.indexer?.typescript?.pnpmWorkspaces
     });
     console.log(`Indexed ${result.languages.join(", ")} in ${(result.durationMs / 1e3).toFixed(1)}s`);
   } catch (err) {
@@ -8663,7 +8659,7 @@ program.command("call-graph <symbol>").description("Show incoming callers and ou
     }
   );
 });
-program.command("similar [symbol]").description("Find functions with similar callee fingerprints (consolidation candidates)").option("--min-similarity <n>", "Minimum Jaccard similarity (0-1)", parseFloat, 0.4).option("-n, --limit <n>", "Number of results", parseIntSafe, 20).option("-s, --scope <path>", "Limit to files matching path").option("--min-callees <n>", "Minimum callees to consider", parseIntSafe, 4).action((symbol, opts) => {
+program.command("similar [symbol]").description("Find functions with similar callee fingerprints (consolidation candidates)").option("--min-similarity <n>", "Minimum Jaccard similarity (0-1)", parseFloat, 0.4).option("-n, --limit <n>", "Number of results", parseIntSafe, 20).option("-s, --scope <path>", "Limit to files matching path").option("--min-callees <n>", "Minimum callees to consider", parseIntSafe, 4).option("--cross-file-only", "Only show cross-file pairs (skip same-file matches)").action((symbol, opts) => {
   withDb((db) => {
     if (symbol) {
       const results = queries.similar(db, symbol, {
@@ -8688,7 +8684,8 @@ ${Math.round(r.similarity * 100)}% similar:`);
         minSimilarity: opts.minSimilarity,
         limit: opts.limit,
         scope: opts.scope,
-        minCallees: opts.minCallees
+        minCallees: opts.minCallees,
+        crossFileOnly: opts.crossFileOnly
       });
       if (results.length === 0) {
         console.log("No similar symbol pairs found.");
@@ -9083,10 +9080,10 @@ program.command("dataflow <symbol>").description("Reference-level dataflow: defi
   }
   db.close();
 });
-program.command("slice <symbol>").description("Reference-level program slice: what affects this (backward) or what this affects (forward)").option("--forward", "Forward slice (what does this affect). Default is backward.").action((symbol, opts) => {
+program.command("slice <symbol>").description("Reference-level program slice: what affects this (backward) or what this affects (forward)").option("--forward", "Forward slice (what does this affect). Default is backward.").option("--depth <n>", "Max transitive depth for backward slice", parseIntSafe, 3).action((symbol, opts) => {
   const db = openDb();
   const direction = opts.forward ? "forward" : "backward";
-  const result = queries.slice(db, symbol, { direction });
+  const result = queries.slice(db, symbol, { direction, maxDepth: opts.depth });
   if (!result) {
     console.log("Symbol not found.");
     db.close();
@@ -9205,6 +9202,7 @@ program.command("watch").description("Watch for file changes and reindex automat
   const watcher = new Watcher({
     projectRoot,
     config,
+    languages: config.languages,
     onStatus: (status) => {
       process.stdout.write(`\r\x1B[K${formatStatus(status)}`);
     },