scip-query 0.4.0 → 0.4.2

package/dist/cli.js

@@ -115,7 +115,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 +132,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 +213,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 +272,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 +311,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 +993,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 +1150,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 +1184,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
     });
@@ -1048,10 +1199,15 @@ async function reindex(opts) {
       const msg = err instanceof Error ? err.message : String(err);
       throw new Error(
         `Failed to index ${lang} with ${resolvedBinary}: ${msg}
-Make sure ${binaryLabel} is installed and available on PATH.`
+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)) {
@@ -1065,7 +1221,13 @@ 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}`);
+    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`);
@@ -1080,11 +1242,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 {
@@ -1162,7 +1329,7 @@ var Watcher = class {
   }
   // ── 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")) {
@@ -1243,10 +1410,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,
         [],
@@ -1271,7 +1438,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}`));
           }
@@ -1287,7 +1454,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";
 }
 
@@ -1323,7 +1490,7 @@ function files(db, pattern) {
 }
 
 // src/query-support.ts
-import { basename as basename2 } from "path";
+import { basename as basename3 } from "path";
 
 // src/source-analysis.ts
 import {
@@ -1331,12 +1498,12 @@ import {
   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();
@@ -1679,7 +1846,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 = [];
@@ -1688,7 +1855,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,
@@ -2163,16 +2330,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);
@@ -2182,16 +2349,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;
     }
@@ -2204,17 +2371,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;
     }
@@ -2222,10 +2389,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;
     }
@@ -2234,15 +2401,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;
     }
@@ -2260,10 +2427,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];
   }
@@ -2280,10 +2447,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;
     }
@@ -2291,7 +2458,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];
   }
@@ -2303,7 +2470,7 @@ function pythonCandidateImportPaths(basePath) {
   ];
 }
 function rustCandidateImportPaths(basePath) {
-  const ext = extname2(basePath);
+  const ext = extname3(basePath);
   if (RUST_SOURCE_EXTENSIONS.includes(ext)) {
     return [basePath];
   }
@@ -2313,7 +2480,7 @@ function rustCandidateImportPaths(basePath) {
   ];
 }
 function rubyCandidateImportPaths(basePath) {
-  const ext = extname2(basePath);
+  const ext = extname3(basePath);
   if (RUBY_SOURCE_EXTENSIONS.includes(ext)) {
     return [basePath];
   }
@@ -2323,14 +2490,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,34 +2540,34 @@ function normalizePath(path2) {
   return path2.replace(/\\/g, "/");
 }
 function isJavaScriptSourcePath(relativePath) {
-  return SOURCE_EXTENSIONS.includes(extname2(relativePath).toLowerCase());
+  return SOURCE_EXTENSIONS.includes(extname3(relativePath).toLowerCase());
 }
 function isPythonSourcePath(relativePath) {
-  return PYTHON_SOURCE_EXTENSIONS.includes(extname2(relativePath).toLowerCase());
+  return PYTHON_SOURCE_EXTENSIONS.includes(extname3(relativePath).toLowerCase());
 }
 function isJvmSourcePath(relativePath) {
-  return JVM_SOURCE_EXTENSIONS.includes(extname2(relativePath).toLowerCase());
+  return JVM_SOURCE_EXTENSIONS.includes(extname3(relativePath).toLowerCase());
 }
 function isRustSourcePath(relativePath) {
-  return RUST_SOURCE_EXTENSIONS.includes(extname2(relativePath).toLowerCase());
+  return RUST_SOURCE_EXTENSIONS.includes(extname3(relativePath).toLowerCase());
 }
 function isRubySourcePath(relativePath) {
-  return RUBY_SOURCE_EXTENSIONS.includes(extname2(relativePath).toLowerCase());
+  return RUBY_SOURCE_EXTENSIONS.includes(extname3(relativePath).toLowerCase());
 }
 function isCLikeSourcePath(relativePath) {
-  return C_LIKE_SOURCE_EXTENSIONS.includes(extname2(relativePath).toLowerCase());
+  return C_LIKE_SOURCE_EXTENSIONS.includes(extname3(relativePath).toLowerCase());
 }
 function isDotNetSourcePath(relativePath) {
-  return DOTNET_SOURCE_EXTENSIONS.includes(extname2(relativePath).toLowerCase());
+  return DOTNET_SOURCE_EXTENSIONS.includes(extname3(relativePath).toLowerCase());
 }
 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 DART_SOURCE_EXTENSIONS.includes(extname3(relativePath).toLowerCase());
 }
 function isPhpSourcePath(relativePath) {
-  return PHP_SOURCE_EXTENSIONS.includes(extname2(relativePath).toLowerCase());
+  return PHP_SOURCE_EXTENSIONS.includes(extname3(relativePath).toLowerCase());
 }
 function extensionFamilyFor(relativePath) {
   if (isJvmSourcePath(relativePath)) return JVM_SOURCE_EXTENSIONS;
@@ -2526,7 +2693,6 @@ function parseDescriptors(input) {
       const closingTick = input.indexOf("`", i + 1);
       if (closingTick === -1) {
         name = input.slice(i + 1);
-        i = input.length;
         descriptors.push({ name, suffix: "term" });
         break;
       }
@@ -2707,6 +2873,10 @@ function buildFileDepGraph(db, scope) {
   return graph;
 }
 function findFirstSymbolMatch(db, symbolPattern) {
+  const exact = findExactSymbolMatch(db, symbolPattern.trim());
+  if (exact) {
+    return exact;
+  }
   const fileLineMatch = symbolPattern.match(/^(.+):(\d+)-(\d+)$/);
   if (fileLineMatch) {
     const [, filePath, startStr, endStr] = fileLineMatch;
@@ -2744,19 +2914,16 @@ function findFirstSymbolMatch(db, symbolPattern) {
       );
     }
     if (row && !db.isIgnored(row.relative_path)) {
-      return {
-        symbolId: row.id,
-        symbol: row.symbol,
-        documentId: row.document_id,
-        startLine: row.start_line,
-        endLine: row.end_line,
-        relativePath: row.relative_path
-      };
+      return hydrateSymbolMatch(db, row);
     }
   }
   const cleaned = normalizeLookupPattern(symbolPattern);
   const tokens = lookupTokens(symbolPattern);
   const candidates = getSymbolLookupCandidates(db, tokens);
+  const direct = findDirectSymbolCandidate(candidates, symbolPattern, cleaned);
+  if (direct && !db.isIgnored(direct.relative_path)) {
+    return hydrateSymbolMatch(db, direct);
+  }
   let best = null;
   for (const row of candidates) {
     if (db.isIgnored(row.relative_path)) continue;
@@ -2767,14 +2934,7 @@ function findFirstSymbolMatch(db, symbolPattern) {
     }
   }
   if (best) {
-    return {
-      symbolId: best.row.id,
-      symbol: best.row.symbol,
-      documentId: best.row.document_id,
-      startLine: best.row.start_line,
-      endLine: best.row.end_line,
-      relativePath: best.row.relative_path
-    };
+    return hydrateSymbolMatch(db, best.row);
   }
   return null;
 }
@@ -2793,14 +2953,7 @@ function findExactSymbolMatch(db, symbol) {
   if (!row || db.isIgnored(row.relative_path)) {
     return null;
   }
-  return {
-    symbolId: row.id,
-    symbol: row.symbol,
-    documentId: row.document_id,
-    startLine: row.start_line,
-    endLine: row.end_line,
-    relativePath: row.relative_path
-  };
+  return hydrateSymbolMatch(db, row);
 }
 function resolveIndexedFile(db, filePattern) {
   return resolveDocumentCandidates(db, filePattern, { allowMultiple: false })[0]?.relativePath ?? null;
@@ -2941,27 +3094,10 @@ function getCalleeRowsForSymbol(db, symbol, opts = {}) {
     });
   }
   const sourceFallback = getSourceBackedCalleeRows(db, symbol, opts.limit);
-  if (sourceFallback.length === 0) {
-    return primary;
-  }
-  if (primary.length === 0) {
+  if (sourceFallback.length > 0) {
     return applyLimit(sourceFallback, opts.limit);
   }
-  const merged = [...sourceFallback];
-  const seen = new Set(merged.map((row) => `${row.symbol}|${row.file}`));
-  const preferredFallbackLeaves = new Set(
-    sourceFallback.filter((row) => !isLikelyTestPath(row.file)).map((row) => leafName(row.symbol))
-  );
-  for (const row of primary) {
-    if (isLikelyTestPath(row.file) && preferredFallbackLeaves.has(leafName(row.symbol))) {
-      continue;
-    }
-    const key = `${row.symbol}|${row.file}`;
-    if (seen.has(key)) continue;
-    seen.add(key);
-    merged.push(row);
-  }
-  return applyLimit(merged, opts.limit);
+  return primary;
 }
 function getCallerRowsForSymbol(db, symbol, opts = {}) {
   const match = getFullSymbolMatch(db, symbol);
@@ -2994,11 +3130,13 @@ function getCallerRowsForSymbol(db, symbol, opts = {}) {
     ...getGenericSourceCallerRows(db, match, opts.limit)
   ]);
   if (sourceFallback.length === 0) {
-    return primary;
+    return dedupeCallerRows(primary);
   }
   const merged = [...sourceFallback];
+  const fallbackFiles = new Set(sourceFallback.map((row) => row.file));
   const seen = new Set(merged.map((row) => `${row.symbol}|${row.file}`));
   for (const row of primary) {
+    if (fallbackFiles.has(row.file)) continue;
     const key = `${row.symbol}|${row.file}`;
     if (seen.has(key)) continue;
     if (isFunctionLikeSymbol(row.symbol) || merged.length === 0) {
@@ -3379,14 +3517,7 @@ function getFullSymbolMatch(db, symbol) {
   if (!row) {
     return null;
   }
-  return {
-    symbolId: row.id,
-    documentId: row.document_id,
-    startLine: row.start_line,
-    endLine: row.end_line,
-    symbol: row.symbol,
-    relativePath: row.relative_path
-  };
+  return hydrateSymbolMatch(db, row);
 }
 function getDefinitionsForFile(db, relativePath) {
   let cache = FILE_DEFINITION_CACHE.get(db);
@@ -3406,6 +3537,7 @@ function getDefinitionsForFile(db, relativePath) {
       der.start_line,
       der.end_line,
       d.relative_path,
+      gs.display_name,
       gs.kind,
       gs.documentation,
       gs.enclosing_symbol
@@ -3425,6 +3557,7 @@ function getDefinitionsForFile(db, relativePath) {
       MIN(c.start_line) AS start_line,
       MAX(c.end_line) AS end_line,
       d.relative_path,
+      gs.display_name,
       gs.kind,
       gs.documentation,
       gs.enclosing_symbol
@@ -3439,23 +3572,222 @@ function getDefinitionsForFile(db, relativePath) {
      ORDER BY start_line, end_line`,
     relativePath
   );
-  const definitions = (primary.length > 0 ? primary : fallback).map((row) => ({
+  const definitions = correctDefinitionRangesFromSource(
+    db,
+    relativePath,
+    (primary.length > 0 ? primary : fallback).map((row) => ({
+      symbolId: row.id,
+      symbol: row.symbol,
+      documentId: row.document_id,
+      startLine: row.start_line,
+      endLine: row.end_line,
+      relativePath: row.relative_path,
+      leaf: leafName(row.symbol),
+      parentTypeName: parentTypeName(row.symbol),
+      isFunctionLike: isFunctionLikeSymbol(row.symbol),
+      isTypeLike: leafSuffix(row.symbol) === "type",
+      kind: row.kind ?? null,
+      documentation: row.documentation ?? null,
+      enclosingSymbol: row.enclosing_symbol ?? null
+    }))
+  );
+  cache.set(relativePath, definitions);
+  return definitions;
+}
+function hydrateSymbolMatch(db, row) {
+  const corrected = getDefinitionsForFile(db, row.relative_path).find((definition) => definition.symbolId === row.id);
+  if (corrected) {
+    return {
+      symbolId: corrected.symbolId,
+      symbol: corrected.symbol,
+      documentId: corrected.documentId,
+      startLine: corrected.startLine,
+      endLine: corrected.endLine,
+      relativePath: corrected.relativePath
+    };
+  }
+  return {
     symbolId: row.id,
     symbol: row.symbol,
     documentId: row.document_id,
     startLine: row.start_line,
     endLine: row.end_line,
-    relativePath: row.relative_path,
-    leaf: leafName(row.symbol),
-    parentTypeName: parentTypeName(row.symbol),
-    isFunctionLike: isFunctionLikeSymbol(row.symbol),
-    isTypeLike: leafSuffix(row.symbol) === "type",
-    kind: row.kind,
-    documentation: row.documentation,
-    enclosingSymbol: row.enclosing_symbol
-  }));
-  cache.set(relativePath, definitions);
-  return definitions;
+    relativePath: row.relative_path
+  };
+}
+function findDirectSymbolCandidate(candidates, symbolPattern, cleanedPattern) {
+  const trimmed = symbolPattern.trim();
+  const directMatches = candidates.filter((row) => {
+    const short = shortenSymbol(row.symbol);
+    const display = (row.display_name ?? "").trim();
+    return row.symbol === trimmed || short === trimmed || short === cleanedPattern || display === trimmed || display === cleanedPattern || `${display}()` === trimmed || row.relative_path === trimmed;
+  });
+  if (directMatches.length === 0) {
+    return null;
+  }
+  directMatches.sort(
+    (left, right) => left.end_line - left.start_line - (right.end_line - right.start_line) || left.relative_path.localeCompare(right.relative_path) || left.symbol.localeCompare(right.symbol)
+  );
+  return directMatches[0] ?? null;
+}
+function correctDefinitionRangesFromSource(db, relativePath, definitions) {
+  const source = getSourceText(db, relativePath);
+  if (!source) {
+    return definitions;
+  }
+  const lines = source.split(/\r?\n/);
+  const correctedStarts = /* @__PURE__ */ new Map();
+  for (const definition of definitions) {
+    correctedStarts.set(
+      definition.symbolId,
+      resolveCallableDefinitionStartLine(lines, definition)
+    );
+  }
+  const correctedRanges = /* @__PURE__ */ new Map();
+  const callableDefinitions = definitions.filter((definition) => isCallableDefinition(definition.symbol)).map((definition) => ({
+    definition,
+    startLine: correctedStarts.get(definition.symbolId) ?? definition.startLine
+  })).sort(
+    (left, right) => left.startLine - right.startLine || left.definition.startLine - right.definition.startLine || left.definition.symbol.localeCompare(right.definition.symbol)
+  );
+  for (let index = 0; index < callableDefinitions.length; index += 1) {
+    const current = callableDefinitions[index];
+    const next = callableDefinitions[index + 1];
+    const maxEndLine = next ? Math.max(current.startLine, next.startLine - 1) : lines.length - 1;
+    correctedRanges.set(current.definition.symbolId, {
+      startLine: current.startLine,
+      endLine: resolveCallableDefinitionEndLine(
+        lines,
+        current.definition,
+        current.startLine,
+        maxEndLine
+      )
+    });
+  }
+  return definitions.map((definition) => {
+    const corrected = correctedRanges.get(definition.symbolId);
+    if (!corrected) {
+      return definition;
+    }
+    return {
+      ...definition,
+      startLine: corrected.startLine,
+      endLine: corrected.endLine
+    };
+  });
+}
+function resolveCallableDefinitionStartLine(lines, definition) {
+  if (!isCallableDefinition(definition.symbol)) {
+    return definition.startLine;
+  }
+  const escapedLeaf = escapeRegex2(definition.leaf);
+  const strongPatterns = [
+    new RegExp(`\\b(?:function|def|fn)\\s+${escapedLeaf}\\b`),
+    new RegExp(`\\b${escapedLeaf}\\b\\s*[:=]\\s*(?:async\\s*)?(?:function\\b|\\()`)
+  ];
+  const fallbackPatterns = [
+    new RegExp(`\\b${escapedLeaf}\\b\\s*\\(`)
+  ];
+  return findNearestMatchingLine(
+    lines,
+    [...strongPatterns, ...fallbackPatterns],
+    definition.startLine,
+    definition.endLine
+  );
+}
+function findNearestMatchingLine(lines, patterns, preferredStartLine, preferredEndLine) {
+  const windowStart = Math.max(0, preferredStartLine - 40);
+  const windowEnd = Math.min(lines.length - 1, Math.max(preferredEndLine + 40, preferredStartLine + 5));
+  const windowMatch = matchNearestLine(lines, patterns, preferredStartLine, windowStart, windowEnd);
+  if (windowMatch !== null) {
+    return windowMatch;
+  }
+  const fullMatch = matchNearestLine(lines, patterns, preferredStartLine, 0, lines.length - 1);
+  return fullMatch ?? Math.max(0, Math.min(preferredStartLine, lines.length - 1));
+}
+function matchNearestLine(lines, patterns, preferredLine, startLine, endLine) {
+  let best = null;
+  for (let lineIndex = startLine; lineIndex <= endLine; lineIndex += 1) {
+    const line = lines[lineIndex] ?? "";
+    if (!patterns.some((pattern) => pattern.test(line))) continue;
+    const distance = Math.abs(lineIndex - preferredLine);
+    if (!best || distance < best.distance) {
+      best = { line: lineIndex, distance };
+    }
+  }
+  return best?.line ?? null;
+}
+function resolveCallableDefinitionEndLine(lines, definition, startLine, maxEndLine) {
+  const boundedEndLine = Math.max(startLine, Math.min(lines.length - 1, maxEndLine));
+  const fallbackEndLine = Math.max(startLine, Math.min(boundedEndLine, definition.endLine));
+  let braceDepth = 0;
+  let parenDepth = 0;
+  let sawOpeningBrace = false;
+  for (let lineIndex = startLine; lineIndex <= boundedEndLine; lineIndex += 1) {
+    const masked = maskStructuralLine(lines[lineIndex] ?? "");
+    for (const char of masked) {
+      if (char === "{") {
+        braceDepth += 1;
+        sawOpeningBrace = true;
+      } else if (char === "}") {
+        braceDepth = Math.max(0, braceDepth - 1);
+      } else if (char === "(") {
+        parenDepth += 1;
+      } else if (char === ")") {
+        parenDepth = Math.max(0, parenDepth - 1);
+      }
+    }
+    if (sawOpeningBrace && braceDepth === 0) {
+      return lineIndex;
+    }
+    if (!sawOpeningBrace && parenDepth === 0 && lineIndex >= fallbackEndLine) {
+      return lineIndex;
+    }
+  }
+  return fallbackEndLine;
+}
+function maskStructuralLine(line) {
+  let masked = "";
+  let quote = null;
+  let escaping = false;
+  for (let index = 0; index < line.length; index += 1) {
+    const char = line[index];
+    const next = line[index + 1];
+    if (!quote && char === "/" && next === "/") {
+      masked += " ".repeat(line.length - index);
+      break;
+    }
+    if (quote) {
+      if (escaping) {
+        escaping = false;
+        masked += " ";
+        continue;
+      }
+      if (char === "\\") {
+        escaping = true;
+        masked += " ";
+        continue;
+      }
+      if (char === quote) {
+        quote = null;
+      }
+      masked += " ";
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      quote = char;
+      masked += " ";
+      continue;
+    }
+    masked += char;
+  }
+  return masked;
+}
+function isCallableDefinition(symbol) {
+  return symbol.includes("().");
+}
+function escapeRegex2(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function getAllDefinitions(db, opts = {}) {
   const { scope } = opts;
@@ -4008,8 +4340,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;
@@ -4055,7 +4387,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) {
@@ -4064,7 +4396,7 @@ 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,
@@ -4448,11 +4780,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");
@@ -5526,7 +5858,7 @@ function similar(db, symbolPattern, opts = {}) {
   const results = [];
   for (const candidate of candidates) {
     if (candidate.callees.size < 3) continue;
-    const { similarity, significantShared, trivialShared } = weightedSimilarity(
+    const { similarity, significantShared } = weightedSimilarity(
       target.callees,
       candidate.callees,
       idfWeights
@@ -5763,11 +6095,11 @@ function definitionSnippet(db, relativePath, startLine, endLine, leaf) {
     return lines.slice(startLine, endLine + 1).join("\n");
   }
   const markerPatterns = [
-    new RegExp(`\\bdef\\s+${escapeRegex2(leaf)}\\b`),
-    new RegExp(`\\bfun\\s+${escapeRegex2(leaf)}\\b`),
-    new RegExp(`\\bfn\\s+${escapeRegex2(leaf)}\\b`),
-    new RegExp(`\\bfunction\\s+${escapeRegex2(leaf)}\\b`),
-    new RegExp(`\\b${escapeRegex2(leaf)}\\s*\\(`)
+    new RegExp(`\\bdef\\s+${escapeRegex3(leaf)}\\b`),
+    new RegExp(`\\bfun\\s+${escapeRegex3(leaf)}\\b`),
+    new RegExp(`\\bfn\\s+${escapeRegex3(leaf)}\\b`),
+    new RegExp(`\\bfunction\\s+${escapeRegex3(leaf)}\\b`),
+    new RegExp(`\\b${escapeRegex3(leaf)}\\s*\\(`)
   ];
   const definitionStart = lines.findIndex((line) => markerPatterns.some((pattern) => pattern.test(line)));
   if (definitionStart >= 0) {
@@ -5829,7 +6161,7 @@ function splitIdentifier(value) {
 function looksLikeDefinitionBoundary(line) {
   return /^\s*(?:def|fun|fn|function|class|trait|module|object|enum|interface|public|private|protected)\b/.test(line);
 }
-function escapeRegex2(value) {
+function escapeRegex3(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
@@ -5955,8 +6287,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) {
@@ -6130,8 +6462,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;
@@ -6643,21 +6975,21 @@ 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));
@@ -6665,10 +6997,10 @@ function wrapperCandidates(db, opts) {
   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);
@@ -6690,7 +7022,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
     });
   }
@@ -6745,11 +7077,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;
     }
@@ -6830,8 +7162,8 @@ function getFilesWithFunctions(db, scope) {
   return new Set(getScopedDefinitions4(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;
   }
@@ -7820,17 +8152,17 @@ function normalizeSignature(raw) {
 }
 function normalizeSourceSignature(raw, leaf) {
   if (!raw || !raw.trim()) return null;
-  let declaration = raw.replace(/\s+/g, " ").trim();
+  const declaration = raw.replace(/\s+/g, " ").trim();
   const parenIdx = declaration.indexOf("(");
   if (parenIdx === -1) return null;
   let prefix = declaration.slice(0, parenIdx);
-  const leafPattern = new RegExp(`\\b${escapeRegex3(leaf)}\\b`, "i");
+  const leafPattern = new RegExp(`\\b${escapeRegex4(leaf)}\\b`, "i");
   const leafMatch = leafPattern.exec(prefix);
   if (leafMatch && typeof leafMatch.index === "number") {
     prefix = prefix.slice(0, leafMatch.index);
   }
   prefix = prefix.replace(/\b(public|private|protected|internal|final|static|abstract|sealed|virtual|override|async|suspend|inline|constexpr|consteval|constinit|const|pub|fn|function|def|sub|friend|shared|readonly|new|open|partial|export)\b/gi, " ").replace(/\s+/g, " ").trim();
-  let suffix = declaration.slice(parenIdx).replace(/\s*\{[\s\S]*$/, "").replace(/\s*=>[\s\S]*$/, "").replace(/\)\s*=\s*[\s\S]*$/, ")").replace(/\s+throws\s+[^={]+$/i, "").replace(/\s+where\s+.+$/i, "").replace(/\s+/g, " ").trim();
+  const suffix = declaration.slice(parenIdx).replace(/\s*\{[\s\S]*$/, "").replace(/\s*=>[\s\S]*$/, "").replace(/\)\s*=\s*[\s\S]*$/, ")").replace(/\s+throws\s+[^={]+$/i, "").replace(/\s+where\s+.+$/i, "").replace(/\s+/g, " ").trim();
   if (!suffix.startsWith("(")) {
     return null;
   }
@@ -7838,7 +8170,7 @@ function normalizeSourceSignature(raw, leaf) {
   return normalized.length >= 3 ? normalized : null;
 }
 function declarationStartLines(lines, startLine, endLine, leaf) {
-  const escapedLeaf = escapeRegex3(leaf);
+  const escapedLeaf = escapeRegex4(leaf);
   const callablePattern = new RegExp(`\\b${escapedLeaf}\\b\\s*\\(`, "i");
   const rubyPattern = new RegExp(`\\bdef\\s+${escapedLeaf}\\b`, "i");
   const candidates = [];
@@ -7869,7 +8201,7 @@ function parenBalance(value) {
   }
   return balance;
 }
-function escapeRegex3(value) {
+function escapeRegex4(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
@@ -7881,7 +8213,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";
@@ -7896,7 +8228,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")
@@ -7907,7 +8239,7 @@ function installSkills(opts = {}) {
     alreadyLinked: []
   };
   for (const targetDir of targets) {
-    const parentDir = dirname3(targetDir);
+    const parentDir = dirname4(targetDir);
     if (!existsSync9(parentDir)) {
       continue;
     }
@@ -7923,7 +8255,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;
@@ -8050,11 +8382,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) {
@@ -9039,6 +9375,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)}`);
     },