scip-query 0.4.2 → 0.5.0

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
@@ -1323,10 +1315,6 @@ 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 = relative2(this.projectRoot, join7(this.projectRoot, filename));
@@ -1479,12 +1467,20 @@ 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 }));
 }
@@ -2539,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(extname3(relativePath).toLowerCase());
+  return hasExtensionIn(relativePath, SOURCE_EXTENSIONS);
 }
 function isPythonSourcePath(relativePath) {
-  return PYTHON_SOURCE_EXTENSIONS.includes(extname3(relativePath).toLowerCase());
+  return hasExtensionIn(relativePath, PYTHON_SOURCE_EXTENSIONS);
 }
 function isJvmSourcePath(relativePath) {
-  return JVM_SOURCE_EXTENSIONS.includes(extname3(relativePath).toLowerCase());
+  return hasExtensionIn(relativePath, JVM_SOURCE_EXTENSIONS);
 }
 function isRustSourcePath(relativePath) {
-  return RUST_SOURCE_EXTENSIONS.includes(extname3(relativePath).toLowerCase());
+  return hasExtensionIn(relativePath, RUST_SOURCE_EXTENSIONS);
 }
 function isRubySourcePath(relativePath) {
-  return RUBY_SOURCE_EXTENSIONS.includes(extname3(relativePath).toLowerCase());
+  return hasExtensionIn(relativePath, RUBY_SOURCE_EXTENSIONS);
 }
 function isCLikeSourcePath(relativePath) {
-  return C_LIKE_SOURCE_EXTENSIONS.includes(extname3(relativePath).toLowerCase());
+  return hasExtensionIn(relativePath, C_LIKE_SOURCE_EXTENSIONS);
 }
 function isDotNetSourcePath(relativePath) {
-  return DOTNET_SOURCE_EXTENSIONS.includes(extname3(relativePath).toLowerCase());
+  return hasExtensionIn(relativePath, DOTNET_SOURCE_EXTENSIONS);
 }
 function isVisualBasicSourcePath(relativePath) {
   return extname3(relativePath).toLowerCase() === ".vb";
 }
 function isDartSourcePath(relativePath) {
-  return DART_SOURCE_EXTENSIONS.includes(extname3(relativePath).toLowerCase());
+  return hasExtensionIn(relativePath, DART_SOURCE_EXTENSIONS);
 }
 function isPhpSourcePath(relativePath) {
-  return PHP_SOURCE_EXTENSIONS.includes(extname3(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) {
@@ -2778,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";
@@ -2822,10 +2832,6 @@ var TEST_FILE_PATTERNS = [
 var TEST_SUPPORT_PATH_PATTERNS = [
   "%/test-utils/%"
 ];
-function testFileExclusionSql(alias, extraPatterns = []) {
-  const patterns = uniquePatterns([...TEST_FILE_PATTERNS, ...extraPatterns]);
-  return patterns.map((pattern) => `${alias}.relative_path NOT LIKE '${pattern}'`).join("\n      AND ");
-}
 function buildFileDepGraph(db, scope) {
   const scopeFilter = scope ? `AND d1.relative_path LIKE '%${scope}%'` : "";
   const edges = db.all(
@@ -2880,6 +2886,8 @@ function findFirstSymbolMatch(db, symbolPattern) {
   const fileLineMatch = symbolPattern.match(/^(.+):(\d+)-(\d+)$/);
   if (fileLineMatch) {
     const [, filePath, startStr, endStr] = fileLineMatch;
+    const userStart0 = Math.max(0, parseInt(startStr, 10) - 1);
+    const userEnd0 = Math.max(userStart0, parseInt(endStr, 10) - 1);
     let row = db.get(
       `SELECT gs.id, gs.symbol, der.document_id, der.start_line, der.end_line, d.relative_path
       FROM global_symbols gs
@@ -2891,8 +2899,8 @@ function findFirstSymbolMatch(db, symbolPattern) {
       ORDER BY (der.end_line - der.start_line) ASC
         LIMIT 1`,
       `%${filePath}%`,
-      parseInt(startStr, 10),
-      parseInt(endStr, 10)
+      userStart0,
+      userEnd0
     );
     if (!row) {
       row = db.get(
@@ -2909,8 +2917,8 @@ function findFirstSymbolMatch(db, symbolPattern) {
          ORDER BY (MAX(c.end_line) - MIN(c.start_line)) ASC
          LIMIT 1`,
         `%${filePath}%`,
-        parseInt(startStr, 10),
-        parseInt(endStr, 10)
+        userStart0,
+        userEnd0
       );
     }
     if (row && !db.isIgnored(row.relative_path)) {
@@ -3202,6 +3210,59 @@ function getSourceReferenceSites(db, symbol) {
   }
   return sites;
 }
+function getResolvedReferenceSites(db, symbol) {
+  const match = getFullSymbolMatch(db, symbol);
+  if (!match) {
+    return [];
+  }
+  const rows = db.all(
+    `SELECT DISTINCT d.relative_path, c.start_line, c.end_line
+     FROM mentions m
+     JOIN chunks c ON m.chunk_id = c.id
+     JOIN documents d ON c.document_id = d.id
+     WHERE m.symbol_id = ?
+       AND m.role != 1
+       ${db.pathExclusionsFor("d")}
+     ORDER BY d.relative_path, c.start_line`,
+    match.symbolId
+  );
+  const chunksByFile = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    if (db.isIgnored(row.relative_path)) continue;
+    let bucket = chunksByFile.get(row.relative_path);
+    if (!bucket) {
+      bucket = [];
+      chunksByFile.set(row.relative_path, bucket);
+    }
+    bucket.push({ start_line: row.start_line, end_line: row.end_line });
+  }
+  const identifier = leafName(match.symbol);
+  const sites = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const [file, chunks] of chunksByFile) {
+    const definitions = getDefinitionsForFile(db, file);
+    const excludeOpts = file === match.relativePath ? { excludeStartLine: match.startLine, excludeEndLine: match.endLine } : {};
+    const allHits = identifier ? findIdentifierLines(db, file, identifier, excludeOpts) : [];
+    for (const chunk of chunks) {
+      const hitsInChunk = allHits.filter(
+        (line) => line >= chunk.start_line && line <= chunk.end_line
+      );
+      const lines = hitsInChunk.length > 0 ? hitsInChunk : [chunk.start_line];
+      for (const line of lines) {
+        const enclosing = findEnclosingDefinition(definitions, line);
+        const key = `${file}|${line}|${enclosing?.symbol ?? ""}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        sites.push({
+          file,
+          line,
+          enclosingSymbol: enclosing?.symbol ?? null
+        });
+      }
+    }
+  }
+  return sites;
+}
 function calleeQueryParams(symbol, limit) {
   const params = [
     symbol.documentId,
@@ -3231,56 +3292,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) {
@@ -3299,7 +3345,7 @@ function getJavaScriptSourceCalleeRows(db, symbol, limit) {
     startLine: match.startLine,
     endLine: match.endLine
   })) {
-    const resolved = resolveJavaScriptCallTarget(
+    const resolved = config.resolver(
       db,
       current,
       definitions,
@@ -3321,134 +3367,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 [];
 }
@@ -3458,9 +3401,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;
@@ -3683,7 +3628,16 @@ function resolveCallableDefinitionStartLine(lines, definition) {
   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|\\()`)
+    new RegExp(`\\b${escapedLeaf}\\b\\s*[:=]\\s*(?:async\\s*)?(?:function\\b|\\()`),
+    // Method/function declaration with optional TypeScript generic
+    // parameters: matches `foo(`, `foo<T>(`, `foo<T = Record<string, unknown>>(`.
+    // `[^(]*` with greedy backtracking handles nested generics as long as
+    // the generic block itself doesn't contain a `(`. Anchored to start of
+    // line content (optional leading whitespace + optional access modifiers)
+    // so it prefers the declaration line over call sites.
+    new RegExp(
+      `^\\s*(?:export\\s+|public\\s+|private\\s+|protected\\s+|static\\s+|readonly\\s+|async\\s+|abstract\\s+|get\\s+|set\\s+)*${escapedLeaf}\\s*(?:<[^(]*>)?\\s*\\(`
+    )
   ];
   const fallbackPatterns = [
     new RegExp(`\\b${escapedLeaf}\\b\\s*\\(`)
@@ -3802,6 +3756,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);
 }
@@ -4219,89 +4184,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;
@@ -4353,15 +4258,18 @@ function scoreDocumentPath(relativePath, rawPattern) {
 function normalizeLookupPath(filePattern) {
   return filePattern.trim().replace(/\\/g, "/").replace(/^\.\//, "").replace(/^\/+/, "").replace(/\/+$/, "");
 }
-function uniquePatterns(patterns) {
-  return [...new Set(patterns)];
-}
 
 // src/queries/clean-signature.ts
 function cleanSignature(sig) {
   if (!sig || !sig.trim()) return null;
   return sig.replace(/^```\w*\s*/, "").replace(/\s*```$/, "").replace(/^\(method\)\s*/, "").replace(/^\(property\)\s*/, "").replace(/^\(function\)\s*/, "").replace(/^\(class\)\s*/, "").replace(/^\(interface\)\s*/, "").replace(/^\(enum\)\s*/, "").replace(/^\(type alias\)\s*/, "").replace(/^\(const\)\s*/, "").replace(/^\(var\)\s*/, "").trim() || null;
 }
+function extractSignature(doc) {
+  if (!doc) return null;
+  const pipeIdx = doc.indexOf("|");
+  if (pipeIdx === -1) return doc.replace(/\n/g, " ");
+  return doc.slice(pipeIdx + 1).replace(/\n/g, " ");
+}
 
 // src/queries/symbols.ts
 function symbols(db, filePattern) {
@@ -4371,9 +4279,7 @@ function symbols(db, filePattern) {
   }
   return resolvedPaths.flatMap((relativePath) => getDefinitionsForFile(db, relativePath)).filter((row) => !db.isIgnored(row.relativePath)).map((row) => {
     const docRow = db.get(
-      `SELECT REPLACE(SUBSTR(documentation, INSTR(documentation, '|') + 1), char(10), ' ') AS sig
-         FROM global_symbols
-         WHERE id = ?`,
+      "SELECT documentation FROM global_symbols WHERE id = ?",
       row.symbolId
     );
     return {
@@ -4381,7 +4287,7 @@ function symbols(db, filePattern) {
       endLine: row.endLine,
       symbol: row.symbol,
       shortName: shortenSymbol(row.symbol),
-      signature: cleanSignature(docRow?.sig ?? null)
+      signature: cleanSignature(extractSignature(docRow?.documentation ?? null))
     };
   });
 }
@@ -4403,9 +4309,6 @@ function methods(db, className) {
     name: leafName(definition.symbol)
   }));
 }
-function isCallableSymbol(rawSymbol) {
-  return rawSymbol.endsWith("().") || leafSuffix(rawSymbol) === "method";
-}
 function stripExtension(relativePath) {
   return relativePath.replace(/\.[^.]+$/, "");
 }
@@ -4413,60 +4316,21 @@ function stripExtension(relativePath) {
 // src/queries/refs.ts
 function refs(db, symbolPattern) {
   const match = findFirstSymbolMatch(db, symbolPattern);
-  if (match) {
-    const includeDefinitionSite = !isFunctionLikeSymbol(match.symbol);
-    const definitionRows = includeDefinitionSite ? [{
-      relativePath: match.relativePath,
-      line: match.startLine
-    }] : [];
-    const sourceSites = getSourceReferenceSites(db, match).filter((site) => !db.isIgnored(site.file)).map((site) => ({
-      relativePath: site.file,
-      line: site.line
-    }));
-    if (sourceSites.length > 0) {
-      const seen2 = /* @__PURE__ */ new Set();
-      const rows2 = [...definitionRows, ...sourceSites, ...getRubySemanticRefs(db, match)].filter((site) => {
-        const key = `${site.relativePath}:${site.line}`;
-        if (seen2.has(key)) return false;
-        seen2.add(key);
-        return true;
-      });
-      return rows2;
-    }
-  }
-  const rows = db.all(
-    `SELECT DISTINCT d.relative_path, c.start_line
-    FROM mentions m
-    JOIN chunks c ON m.chunk_id = c.id
-    JOIN documents d ON c.document_id = d.id
-    JOIN global_symbols gs ON m.symbol_id = gs.id
-    WHERE m.symbol_id = ?
-      AND ${db.localSymbolPredicate}
-      AND m.role != 1
-    ORDER BY d.relative_path, c.start_line`,
-    match?.symbolId ?? -1
-  );
-  const referenceRows = rows.filter((r) => !db.isIgnored(r.relative_path)).map((r) => ({
-    relativePath: r.relative_path,
-    line: r.start_line
-  }));
-  if (!match || db.isIgnored(match.relativePath) || isFunctionLikeSymbol(match.symbol)) {
-    return referenceRows;
-  }
-  const seen = new Set(referenceRows.map((row) => `${row.relativePath}:${row.line}`));
-  if (!seen.has(`${match.relativePath}:${match.startLine}`)) {
-    referenceRows.unshift({
-      relativePath: match.relativePath,
-      line: match.startLine
-    });
-  }
-  for (const row of getRubySemanticRefs(db, match)) {
+  if (!match) return [];
+  const includeDefinitionSite = !isFunctionLikeSymbol(match.symbol);
+  const definitionRows = includeDefinitionSite && !db.isIgnored(match.relativePath) ? [{ relativePath: match.relativePath, line: match.startLine }] : [];
+  const sourceSites = getSourceReferenceSites(db, match);
+  const referenceSites = (sourceSites.length > 0 ? sourceSites : getResolvedReferenceSites(db, match)).filter((site) => !db.isIgnored(site.file)).map((site) => ({ relativePath: site.file, line: site.line }));
+  const rubySites = getRubySemanticRefs(db, match);
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const row of [...definitionRows, ...referenceSites, ...rubySites]) {
     const key = `${row.relativePath}:${row.line}`;
     if (seen.has(key)) continue;
     seen.add(key);
-    referenceRows.push(row);
+    out.push(row);
   }
-  return referenceRows;
+  return out;
 }
 function getRubySemanticRefs(db, match) {
   if (!match.relativePath.endsWith(".rb")) {
@@ -4519,50 +4383,24 @@ function trace(db, symbolPattern) {
     return { definitions: [], referencedBy: [] };
   }
   const definitionMeta = db.get(
-    `SELECT
-      gs.display_name,
-      REPLACE(SUBSTR(gs.documentation, INSTR(gs.documentation, '|') + 1), char(10), ' ') AS sig
-    FROM global_symbols gs
-    WHERE gs.id = ?
-    LIMIT 10`,
+    "SELECT display_name, documentation FROM global_symbols WHERE id = ?",
     match.symbolId
   );
+  const sig = extractSignature(definitionMeta?.documentation ?? null);
   const definitions = db.isIgnored(match.relativePath) ? [] : [{
     relativePath: match.relativePath,
     startLine: match.startLine,
     endLine: match.endLine,
-    signature: buildTraceSignature(definitionMeta?.sig ?? null, definitionMeta?.display_name ?? null, match.symbol),
+    signature: buildTraceSignature(sig, definitionMeta?.display_name ?? null, match.symbol),
     source: definitionSource(db, match.relativePath, match.startLine, match.endLine)
   }];
   const sourceSites = getSourceReferenceSites(db, match);
-  const referencedBy = sourceSites.length > 0 ? sourceSites.filter((site) => !db.isIgnored(site.file)).map((site) => ({
+  const resolvedSites = sourceSites.length > 0 ? sourceSites : getResolvedReferenceSites(db, match);
+  const referencedBy = resolvedSites.filter((site) => !db.isIgnored(site.file)).map((site) => ({
     relativePath: site.file,
     line: site.line,
     enclosingSymbol: site.enclosingSymbol,
     enclosingShort: site.enclosingSymbol ? shortenSymbol(site.enclosingSymbol) : "(top-level)"
-  })) : db.all(
-    `SELECT DISTINCT d.relative_path, c.start_line AS line,
-        (SELECT enc_gs.symbol
-         FROM defn_enclosing_ranges enc_der
-         JOIN global_symbols enc_gs ON enc_der.symbol_id = enc_gs.id
-         WHERE enc_der.document_id = d.id
-           AND enc_der.start_line <= c.start_line
-           AND enc_der.end_line >= c.end_line
-         ORDER BY (enc_der.end_line - enc_der.start_line) ASC
-         LIMIT 1
-        ) AS enclosing_symbol
-      FROM mentions m
-      JOIN chunks c ON m.chunk_id = c.id
-      JOIN documents d ON c.document_id = d.id
-      WHERE m.symbol_id = ?
-        AND m.role != 1
-      ORDER BY d.relative_path, c.start_line`,
-    match.symbolId
-  ).filter((r) => !db.isIgnored(r.relative_path)).map((r) => ({
-    relativePath: r.relative_path,
-    line: r.line,
-    enclosingSymbol: r.enclosing_symbol,
-    enclosingShort: r.enclosing_symbol ? shortenSymbol(r.enclosing_symbol) : "(top-level)"
   }));
   return { definitions, referencedBy };
 }
@@ -4648,26 +4486,18 @@ function system(db, modulePattern) {
     ...matchedPaths
   );
   const files2 = fileRows.map((r) => r.relative_path).filter((p) => !db.isIgnored(p));
-  const symbolRows = db.all(
-    `SELECT der.start_line, der.end_line, gs.symbol,
-      REPLACE(SUBSTR(gs.documentation, INSTR(gs.documentation, '|') + 1), char(10), ' ') AS sig
-    FROM defn_enclosing_ranges der
-    JOIN global_symbols gs ON der.symbol_id = gs.id
-    JOIN documents d ON der.document_id = d.id
-    WHERE d.relative_path IN (${placeholders})
-      AND ${db.localSymbolPredicate}
-      ${db.symbolNoise}
-      AND gs.documentation IS NOT NULL
-    ORDER BY d.relative_path, der.start_line`,
-    ...matchedPaths
-  );
-  const symbols2 = symbolRows.map((r) => ({
-    startLine: r.start_line,
-    endLine: r.end_line,
-    symbol: r.symbol,
-    shortName: shortenSymbol(r.symbol),
-    signature: cleanSignature(r.sig)
-  }));
+  const symbols2 = files2.flatMap((relativePath) => getDefinitionsForFile(db, relativePath)).filter((d) => d.documentation !== null && d.documentation !== "").sort(
+    (a, b) => a.relativePath.localeCompare(b.relativePath) || a.startLine - b.startLine || a.endLine - b.endLine
+  ).map((d) => {
+    const sig = extractSignature(d.documentation);
+    return {
+      startLine: d.startLine,
+      endLine: d.endLine,
+      symbol: d.symbol,
+      shortName: shortenSymbol(d.symbol),
+      signature: cleanSignature(sig)
+    };
+  });
   const depRows = db.all(
     `SELECT DISTINCT d2.relative_path
     FROM mentions m
@@ -4743,7 +4573,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
     }))
@@ -4760,9 +4590,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();
@@ -5137,33 +4964,40 @@ function outline(db, filePattern) {
   if (resolvedPaths.length === 0) {
     return [];
   }
-  const placeholders = resolvedPaths.map(() => "?").join(", ");
-  const rows = db.all(
-    `SELECT gs.symbol, gs.enclosing_symbol, der.start_line, der.end_line
-    FROM defn_enclosing_ranges der
-    JOIN global_symbols gs ON der.symbol_id = gs.id
-    JOIN documents d ON der.document_id = d.id
-    WHERE d.relative_path IN (${placeholders})
-      ${db.symbolNoise}
-    ORDER BY d.relative_path, der.start_line`,
-    ...resolvedPaths
+  const definitions = resolvedPaths.flatMap((relativePath) => getDefinitionsForFile(db, relativePath)).filter((d) => !db.isIgnored(d.relativePath)).sort(
+    (a, b) => a.relativePath.localeCompare(b.relativePath) || a.startLine - b.startLine || a.endLine - b.endLine
   );
+  const nodes = definitions.map((d) => ({
+    symbol: d.symbol,
+    shortName: shortenSymbol(d.symbol),
+    startLine: d.startLine,
+    endLine: d.endLine,
+    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);
-    if (r.enclosing_symbol && nodeMap.has(r.enclosing_symbol)) {
-      nodeMap.get(r.enclosing_symbol).children.push(node);
+  for (let i = 0; i < definitions.length; i++) {
+    const d = definitions[i];
+    const node = nodes[i];
+    if (d.enclosingSymbol && nodeMap.has(d.enclosingSymbol)) {
+      nodeMap.get(d.enclosingSymbol).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);
     }
@@ -5175,23 +5009,12 @@ function outline(db, filePattern) {
 function members(db, symbolPattern) {
   const parent = findFirstSymbolMatch(db, symbolPattern);
   if (!parent) return [];
-  const rows = db.all(
-    `SELECT gs.symbol, der.start_line, der.end_line
-     FROM global_symbols gs
-     JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
-     WHERE der.document_id = ?
-       AND gs.symbol != ?
-       ${db.symbolNoiseFor("gs")}
-     ORDER BY der.start_line`,
-    parent.documentId,
-    parent.symbol
-  );
-  return rows.filter((row) => isDirectChildSymbol(parent.symbol, row.symbol)).map((row) => ({
-    symbol: row.symbol,
-    shortName: shortenSymbol(row.symbol),
-    startLine: row.start_line,
-    endLine: row.end_line,
-    kind: leafSuffix(row.symbol) ?? "unknown"
+  return getDefinitionsForFile(db, parent.relativePath).filter((definition) => definition.symbol !== parent.symbol).filter((definition) => isDirectChildSymbol(parent.symbol, definition.symbol)).sort((a, b) => a.startLine - b.startLine || a.endLine - b.endLine).map((definition) => ({
+    symbol: definition.symbol,
+    shortName: shortenSymbol(definition.symbol),
+    startLine: definition.startLine,
+    endLine: definition.endLine,
+    kind: leafSuffix(definition.symbol) ?? "unknown"
   }));
 }
 
@@ -5885,7 +5708,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 = [];
@@ -5893,14 +5716,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),
@@ -5909,7 +5734,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)
       });
@@ -5983,35 +5808,21 @@ function findCallees(db, symbolPattern) {
 }
 function getAllCalleeFingerprints(db, opts) {
   const { minCallees, scope, excludeSymbol } = opts;
-  const scopeFilter = scope ? `AND d.relative_path LIKE '%${scope}%'` : "";
-  const excludeFilter = excludeSymbol ? `AND gs.symbol != '${excludeSymbol.replace(/'/g, "''")}'` : "";
-  const symbols2 = db.all(
-    `SELECT gs.id, gs.symbol, der.document_id, der.start_line, der.end_line, d.relative_path
-    FROM global_symbols gs
-    JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
-    JOIN documents d ON der.document_id = d.id
-    WHERE 1 = 1
-      ${db.pathExclusionsFor("d")}
-      ${db.symbolNoiseFor("gs")}
-      AND (der.end_line - der.start_line + 1) >= 5
-      ${scopeFilter}
-      ${excludeFilter}
-    ORDER BY d.relative_path`
-  );
   const fingerprints = [];
-  for (const sym of symbols2) {
-    if (db.isIgnored(sym.relative_path)) continue;
-    if (!isFunctionLikeSymbol(sym.symbol)) continue;
-    const calleeRows = getCalleeRowsForSymbol(db, {
-      documentId: sym.document_id,
-      startLine: sym.start_line,
-      endLine: sym.end_line,
-      symbolId: sym.id
+  for (const definition of getAllDefinitions(db, { scope })) {
+    if (db.isIgnored(definition.relativePath)) continue;
+    if (!definition.isFunctionLike) continue;
+    if (excludeSymbol && definition.symbol === excludeSymbol) continue;
+    if (definition.endLine - definition.startLine + 1 < 5) continue;
+    const callees = new Set(
+      getCalleeRowsForSymbol(db, definition).map((row) => row.symbol)
+    );
+    if (callees.size < minCallees) continue;
+    fingerprints.push({
+      symbol: definition.symbol,
+      file: definition.relativePath,
+      callees
     });
-    const callees = new Set(calleeRows.map((r) => r.symbol));
-    if (callees.size >= minCallees) {
-      fingerprints.push({ symbol: sym.symbol, file: sym.relative_path, callees });
-    }
   }
   return fingerprints;
 }
@@ -6539,17 +6350,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;
 }
@@ -6640,18 +6440,10 @@ function changeSurface(db, filePattern) {
     resolvedFile
   );
   if (!doc || db.isIgnored(doc.relative_path)) return null;
-  const syms = db.all(
-    `SELECT DISTINCT gs.id AS symbol_id, gs.symbol, der.start_line, der.end_line
-    FROM defn_enclosing_ranges der
-    JOIN global_symbols gs ON der.symbol_id = gs.id
-    WHERE der.document_id = ?
-      ${db.symbolNoiseFor("gs")}
-    ORDER BY der.start_line`,
-    doc.id
-  );
+  const definitions = getDefinitionsForFile(db, doc.relative_path).sort((a, b) => a.startLine - b.startLine || a.endLine - b.endLine);
   const symbols2 = [];
   let totalExternalConsumers = 0;
-  for (const sym of syms) {
+  for (const def of definitions) {
     const consumerRow = db.get(
       `SELECT COUNT(DISTINCT c.document_id) AS consumer_count
       FROM mentions m
@@ -6659,7 +6451,7 @@ function changeSurface(db, filePattern) {
       WHERE m.symbol_id = ?
         AND m.role != 1
         AND c.document_id != ?`,
-      sym.symbol_id,
+      def.symbolId,
       doc.id
     );
     const externalConsumers = consumerRow?.consumer_count ?? 0;
@@ -6673,10 +6465,10 @@ function changeSurface(db, filePattern) {
     }
     totalExternalConsumers += externalConsumers;
     symbols2.push({
-      symbol: sym.symbol,
-      shortName: shortenSymbol(sym.symbol),
-      startLine: sym.start_line,
-      endLine: sym.end_line,
+      symbol: def.symbol,
+      shortName: shortenSymbol(def.symbol),
+      startLine: def.startLine,
+      endLine: def.endLine,
       externalConsumers,
       riskLevel
     });
@@ -6993,7 +6785,7 @@ 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;
@@ -7032,17 +6824,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 = [];
@@ -7092,7 +6873,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;
@@ -7121,17 +6902,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;
 }
@@ -7139,7 +6909,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,
@@ -7159,7 +6929,7 @@ 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 basename6 = row.file.split("/").pop() ?? "";
@@ -7172,17 +6942,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
@@ -7203,95 +6962,6 @@ function definitionLoc4(definition) {
 // src/queries/complexity-hotspots.ts
 function complexityHotspots(db, opts) {
   const { scope, minLoc = 10, limit = 30 } = opts ?? {};
-  const scopeFilter = scope ? `AND d.relative_path LIKE '%${scope}%'` : "";
-  const rows = db.all(
-    `SELECT
-      gs.symbol,
-      d.relative_path AS file,
-      der.start_line,
-      der.end_line,
-      (der.end_line - der.start_line + 1) AS loc,
-      -- fanIn: distinct files that reference this symbol
-      (SELECT COUNT(DISTINCT ref_c.document_id)
-       FROM mentions ref_m
-       JOIN chunks ref_c ON ref_m.chunk_id = ref_c.id
-       WHERE ref_m.symbol_id = gs.id AND ref_m.role != 1
-      ) AS fan_in,
-      -- fanOut: distinct symbols referenced within this definition range
-      -- that are defined in different files
-      (SELECT COUNT(DISTINCT out_gs.id)
-       FROM mentions out_m
-       JOIN chunks out_c ON out_m.chunk_id = out_c.id
-       JOIN global_symbols out_gs ON out_m.symbol_id = out_gs.id
-       JOIN defn_enclosing_ranges out_der ON out_gs.id = out_der.symbol_id
-       WHERE out_c.document_id = der.document_id
-         AND out_c.start_line >= der.start_line
-         AND out_c.end_line <= der.end_line
-         AND out_m.role != 1
-         AND out_gs.id != gs.id
-         AND out_der.document_id != der.document_id
-      ) AS fan_out,
-      -- calleeCount: total distinct callees within definition range
-      (SELECT COUNT(DISTINCT callee_gs.id)
-       FROM mentions callee_m
-       JOIN chunks callee_c ON callee_m.chunk_id = callee_c.id
-       JOIN global_symbols callee_gs ON callee_m.symbol_id = callee_gs.id
-       WHERE callee_c.document_id = der.document_id
-         AND callee_c.start_line >= der.start_line
-         AND callee_c.end_line <= der.end_line
-         AND callee_m.role != 1
-         AND callee_gs.id != gs.id
-      ) AS callee_count
-    FROM global_symbols gs
-    JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
-    JOIN documents d ON der.document_id = d.id
-    WHERE 1 = 1
-      ${db.pathExclusionsFor("d")}
-      AND ${testFileExclusionSql("d")}
-      ${db.symbolNoiseFor("gs")}
-      AND (der.end_line - der.start_line + 1) >= ?
-      ${scopeFilter}
-    ORDER BY (
-      CAST((der.end_line - der.start_line + 1) AS REAL) / 50.0
-      * CAST((SELECT COUNT(DISTINCT ref_c2.document_id)
-              FROM mentions ref_m2
-              JOIN chunks ref_c2 ON ref_m2.chunk_id = ref_c2.id
-              WHERE ref_m2.symbol_id = gs.id AND ref_m2.role != 1
-             ) AS REAL) / 5.0
-      * MAX(CAST((SELECT COUNT(DISTINCT out_gs2.id)
-                  FROM mentions out_m2
-                  JOIN chunks out_c2 ON out_m2.chunk_id = out_c2.id
-                  JOIN global_symbols out_gs2 ON out_m2.symbol_id = out_gs2.id
-                  JOIN defn_enclosing_ranges out_der2 ON out_gs2.id = out_der2.symbol_id
-                  WHERE out_c2.document_id = der.document_id
-                    AND out_c2.start_line >= der.start_line
-                    AND out_c2.end_line <= der.end_line
-                    AND out_m2.role != 1
-                    AND out_gs2.id != gs.id
-                    AND out_der2.document_id != der.document_id
-                 ) AS REAL) / 5.0, 1.0)
-    ) DESC
-    LIMIT ?`,
-    minLoc,
-    limit
-  );
-  const indexedResults = rows.filter((r) => !db.isIgnored(r.file)).map((r) => ({
-    symbol: r.symbol,
-    shortName: shortenSymbol(r.symbol),
-    file: r.file,
-    startLine: r.start_line,
-    endLine: r.end_line,
-    loc: r.loc,
-    fanIn: r.fan_in,
-    fanOut: r.fan_out,
-    calleeCount: r.callee_count,
-    score: Math.round(
-      r.loc / 50 * (r.fan_in / 5) * Math.max(r.fan_out / 5, 1) * 100
-    ) / 100
-  }));
-  if (indexedResults.length > 0) {
-    return indexedResults;
-  }
   return getAllDefinitions(db, { scope }).filter((definition) => !db.isIgnored(definition.relativePath)).map((definition) => {
     const loc = definition.endLine - definition.startLine + 1;
     const callerRows = getCallerRowsForSymbol(db, definition, { limit: 500 });
@@ -7590,9 +7260,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
   };
@@ -7620,8 +7292,8 @@ 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
   };
@@ -7734,34 +7406,12 @@ function dataflow(db, symbolPattern) {
     line: match.startLine
   }];
   const sourceUsageSites = getSourceReferenceSites(db, match);
-  const usageSites = sourceUsageSites.length > 0 ? sourceUsageSites.map((site) => ({
+  const resolvedSites = sourceUsageSites.length > 0 ? sourceUsageSites : getResolvedReferenceSites(db, match);
+  const normalizedUsageSites = resolvedSites.filter((site) => !db.isIgnored(site.file)).map((site) => ({
     file: site.file,
     line: site.line,
-    enclosing_symbol: site.enclosingSymbol
-  })) : db.all(
-    `SELECT d.relative_path AS file, c.start_line AS line,
-        (SELECT enc_gs.symbol
-         FROM defn_enclosing_ranges enc_der
-         JOIN global_symbols enc_gs ON enc_der.symbol_id = enc_gs.id
-         WHERE enc_der.document_id = d.id
-           AND enc_der.start_line <= c.start_line
-           AND enc_der.end_line >= c.end_line
-         ORDER BY (enc_der.end_line - enc_der.start_line) ASC
-         LIMIT 1
-        ) AS enclosing_symbol
-      FROM mentions m
-      JOIN chunks c ON m.chunk_id = c.id
-      JOIN documents d ON c.document_id = d.id
-      WHERE m.symbol_id = ? AND m.role != 1
-        ${db.pathExclusionsFor("d")}
-      ORDER BY d.relative_path, c.start_line`,
-    match.symbolId
-  );
-  const normalizedUsageSites = usageSites.filter((site) => !db.isIgnored(site.file)).map((site) => ({
-    file: site.file,
-    line: site.line,
-    enclosingSymbol: site.enclosing_symbol ?? "(top-level)",
-    enclosingShort: site.enclosing_symbol ? shortenSymbol(site.enclosing_symbol) : "(top-level)"
+    enclosingSymbol: site.enclosingSymbol ?? "(top-level)",
+    enclosingShort: site.enclosingSymbol ? shortenSymbol(site.enclosingSymbol) : "(top-level)"
   }));
   const producers = uniqueSymbolRows(getCalleeRowsForSymbol(db, match, { limit: 30 }).map((row) => ({
     symbol: row.symbol,
@@ -7801,28 +7451,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,
@@ -7832,53 +7494,37 @@ function backwardSlice(db, match) {
   };
 }
 function forwardSlice(db, match) {
-  const rows = db.all(
-    `SELECT DISTINCT
-      enc_gs.symbol AS enclosing_symbol,
-      enc_d.relative_path AS enclosing_file,
-      out_gs.symbol AS output_symbol,
-      out_d.relative_path AS output_file
-    FROM mentions ref_m
-    JOIN chunks ref_c ON ref_m.chunk_id = ref_c.id
-    JOIN documents ref_d ON ref_c.document_id = ref_d.id
-    -- Find enclosing function at each reference site
-    JOIN defn_enclosing_ranges enc_der
-      ON enc_der.document_id = ref_d.id
-      AND enc_der.start_line <= ref_c.start_line
-      AND enc_der.end_line >= ref_c.end_line
-    JOIN global_symbols enc_gs ON enc_der.symbol_id = enc_gs.id
-    JOIN documents enc_d ON enc_der.document_id = enc_d.id
-    -- Find other symbols referenced within that enclosing function
-    JOIN mentions out_m ON out_m.role != 1
-    JOIN chunks out_c ON out_m.chunk_id = out_c.id
-      AND out_c.document_id = enc_der.document_id
-      AND out_c.start_line >= enc_der.start_line
-      AND out_c.end_line <= enc_der.end_line
-    JOIN global_symbols out_gs ON out_m.symbol_id = out_gs.id
-    JOIN defn_enclosing_ranges out_der ON out_gs.id = out_der.symbol_id
-    JOIN documents out_d ON out_der.document_id = out_d.id
-    WHERE ref_m.symbol_id = ? AND ref_m.role != 1
-      AND out_gs.id != ? AND out_gs.id != enc_gs.id
-      AND out_d.id != ref_d.id
-      ${db.symbolNoiseFor("out_gs")}
-      ${db.pathExclusionsFor("out_d")}
-    ORDER BY out_d.relative_path
-    LIMIT 30`,
-    match.symbolId,
-    match.symbolId
-  );
-  const seen = /* @__PURE__ */ new Set();
+  const sourceRefs = getSourceReferenceSites(db, match);
+  const refs2 = sourceRefs.length > 0 ? sourceRefs : getResolvedReferenceSites(db, match);
+  const seenOutputs = /* @__PURE__ */ new Set();
   const connected = [];
-  for (const r of rows) {
-    if (seen.has(r.output_symbol) || db.isIgnored(r.output_file)) continue;
-    seen.add(r.output_symbol);
-    connected.push({
-      symbol: r.output_symbol,
-      shortName: shortenSymbol(r.output_symbol),
-      file: r.output_file,
-      relationship: `used alongside target in ${shortenSymbol(r.enclosing_symbol)}`
-    });
+  for (const ref of refs2) {
+    if (connected.length >= 30) break;
+    if (db.isIgnored(ref.file)) continue;
+    const enclosingSymbol = ref.enclosingSymbol ?? findEnclosingDefinition(
+      getDefinitionsForFile(db, ref.file),
+      ref.line
+    )?.symbol ?? null;
+    if (!enclosingSymbol || enclosingSymbol === match.symbol) continue;
+    const enclosingMatch = findExactSymbolMatch(db, enclosingSymbol);
+    if (!enclosingMatch) continue;
+    for (const callee of getCalleeRowsForSymbol(db, enclosingMatch)) {
+      if (callee.symbol === match.symbol) continue;
+      if (callee.symbol === enclosingSymbol) continue;
+      if (callee.file === ref.file) continue;
+      if (db.isIgnored(callee.file)) continue;
+      if (seenOutputs.has(callee.symbol)) continue;
+      seenOutputs.add(callee.symbol);
+      connected.push({
+        symbol: callee.symbol,
+        shortName: shortenSymbol(callee.symbol),
+        file: callee.file,
+        relationship: `used alongside target in ${shortenSymbol(enclosingSymbol)}`
+      });
+      if (connected.length >= 30) break;
+    }
   }
+  connected.sort((a, b) => a.file.localeCompare(b.file));
   return {
     symbol: match.symbol,
     shortName: shortenSymbol(match.symbol),
@@ -8833,7 +8479,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, {
@@ -8858,7 +8504,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.");
@@ -9253,10 +8900,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();