scip-query 0.3.5 → 0.4.1

package/README.md

@@ -19,6 +19,7 @@ For goal-oriented usage guides (not just command reference), see **[Agent Guide]
 ```bash
 # Install
 npm install -g scip-query
+scip-query install-skills            # installs built-in Codex/Claude skills, including scip-language-playbook
 
 # Index your project (auto-detects language)
 scip-query reindex
@@ -61,7 +62,7 @@ For Python, the npm package is `scip-python-plus`. Depending on which version yo
 2. The `scip` CLI converts the protobuf to a SQLite database (`index.db`).
 3. `scip-query` runs SQL queries against that database to answer questions about your codebase.
 
-Because the index comes from the real compiler, results are precise — not grep-based approximations. A reference to `login()` in file A is provably the same `login()` defined in file B, not just a string match.
+Because the index comes from the real compiler, direct symbol, definition, and reference queries are precise — not grep-based approximations. When a language index is missing enough call-site detail for higher-level analyses, `scip-query` can fall back to source parsing and identifier recovery so those commands stay useful, but they should be treated as source-backed heuristics rather than compiler-proof facts.
 
 ## Configuration
 

package/dist/{chunk-VMM4SYV4.js → chunk-24LF6IZB.js}

@@ -1,10 +1,11 @@
 import {
+  buildFileDepGraph,
   findFirstSymbolMatch,
   resolveIndexedFile
-} from "./chunk-AXQKUYKF.js";
+} from "./chunk-ALUFWH3U.js";
 import {
   shortenSymbol
-} from "./chunk-QIXNAB5K.js";
+} from "./chunk-TO3L4YNK.js";
 
 // src/queries/fan.ts
 function fanIn(db, symbolPattern) {
@@ -45,10 +46,22 @@ function fanOut(db, filePattern) {
     ORDER BY symbol_count DESC`,
     resolvedFile
   );
-  return rows.filter((r) => !db.isIgnored(r.relative_path)).map((r) => ({
+  const indexedResults = rows.filter((r) => !db.isIgnored(r.relative_path)).map((r) => ({
     name: r.relative_path,
     count: r.symbol_count
   }));
+  if (indexedResults.length > 0) {
+    return indexedResults;
+  }
+  const graph = buildFileDepGraph(db);
+  const deps = graph.get(resolvedFile);
+  if (!deps || deps.size === 0) {
+    return [];
+  }
+  return [{
+    name: resolvedFile,
+    count: deps.size
+  }];
 }
 function topFanIn(db, opts = {}) {
   const { limit = 30, scope } = opts;
@@ -108,4 +121,4 @@ export {
   topFanIn,
   topFanOut
 };
-//# sourceMappingURL=chunk-VMM4SYV4.js.map
+//# sourceMappingURL=chunk-24LF6IZB.js.map

package/dist/{chunk-EPWLXXBL.js → chunk-3NJSJ7TE.js}

@@ -1,38 +1,22 @@
 import {
-  getCalleeRowsForSymbol
-} from "./chunk-AXQKUYKF.js";
+  getCalleeRowsForSymbol,
+  getDefinitionsForFile
+} from "./chunk-ALUFWH3U.js";
 import {
+  isFunctionLikeSymbol,
   shortenSymbol
-} from "./chunk-QIXNAB5K.js";
+} from "./chunk-TO3L4YNK.js";
 
 // src/queries/extract-candidates.ts
 function extractCandidates(db, opts = {}) {
   const { scope, minLoc = 10, minCallees = 6, limit = 20 } = opts;
-  const scopeFilter = scope ? `AND d.relative_path LIKE '%${scope}%'` : "";
-  const symbols = 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) >= ?
-      ${scopeFilter}
-    ORDER BY (der.end_line - der.start_line + 1) DESC`,
-    minLoc
-  );
+  const symbols = getScopedDefinitions(db, scope).filter((definition) => definitionLoc(definition) >= minLoc && isFunctionLikeSymbol(definition.symbol)).sort((left, right) => definitionLoc(right) - definitionLoc(left));
   const results = [];
   for (const sym of symbols) {
-    if (db.isIgnored(sym.relative_path)) continue;
-    const basename = sym.relative_path.split("/").pop() ?? "";
+    if (db.isIgnored(sym.relativePath)) continue;
+    const basename = sym.relativePath.split("/").pop() ?? "";
     if (basename.includes("types")) continue;
-    const calleeChunks = getCalleeRowsForSymbol(db, {
-      documentId: sym.document_id,
-      startLine: sym.start_line,
-      endLine: sym.end_line,
-      symbolId: sym.id
-    });
+    const calleeChunks = getCalleeRowsForSymbol(db, sym);
     const calleeSet = new Set(calleeChunks.map((c) => c.symbol));
     if (calleeSet.size < minCallees) continue;
     const cooccurrence = /* @__PURE__ */ new Map();
@@ -95,10 +79,10 @@ function extractCandidates(db, opts = {}) {
       results.push({
         symbol: sym.symbol,
         shortName: shortenSymbol(sym.symbol),
-        relativePath: sym.relative_path,
-        startLine: sym.start_line,
-        endLine: sym.end_line,
-        loc: sym.end_line - sym.start_line + 1,
+        relativePath: sym.relativePath,
+        startLine: sym.startLine,
+        endLine: sym.endLine,
+        loc: definitionLoc(sym),
         totalCallees: calleeSet.size,
         clusters: scoredClusters
       });
@@ -107,8 +91,22 @@ 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;
+}
 
 export {
   extractCandidates
 };
-//# sourceMappingURL=chunk-EPWLXXBL.js.map
+//# sourceMappingURL=chunk-3NJSJ7TE.js.map

package/dist/{chunk-SMDCNPMK.js → chunk-43A4UCS7.js}

@@ -1,9 +1,9 @@
 import {
   resolveIndexedFile
-} from "./chunk-AXQKUYKF.js";
+} from "./chunk-ALUFWH3U.js";
 import {
   shortenSymbol
-} from "./chunk-QIXNAB5K.js";
+} from "./chunk-TO3L4YNK.js";
 
 // src/queries/change-surface.ts
 function changeSurface(db, filePattern) {
@@ -68,4 +68,4 @@ function changeSurface(db, filePattern) {
 export {
   changeSurface
 };
-//# sourceMappingURL=chunk-SMDCNPMK.js.map
+//# sourceMappingURL=chunk-43A4UCS7.js.map

package/dist/{chunk-CHDJXYBG.js → chunk-5GCORUNV.js}

@@ -1,10 +1,10 @@
 import {
   findFirstSymbolMatch,
   getCalleeRowsForSymbol
-} from "./chunk-AXQKUYKF.js";
+} from "./chunk-ALUFWH3U.js";
 import {
   shortenSymbol
-} from "./chunk-QIXNAB5K.js";
+} from "./chunk-TO3L4YNK.js";
 
 // src/queries/slice.ts
 function slice(db, symbolPattern, opts = {}) {
@@ -97,4 +97,4 @@ function forwardSlice(db, match) {
 export {
   slice
 };
-//# sourceMappingURL=chunk-CHDJXYBG.js.map
+//# sourceMappingURL=chunk-5GCORUNV.js.map

package/dist/{chunk-OIDHN6GD.js → chunk-6CH23IAS.js}

@@ -1,17 +1,20 @@
 import {
   findFirstSymbolMatch,
-  getCalleeRowsForSymbol
-} from "./chunk-AXQKUYKF.js";
+  getAllDefinitions,
+  getCalleeRowsForSymbol,
+  getSourceText
+} from "./chunk-ALUFWH3U.js";
 import {
   isFunctionLikeSymbol,
+  leafName,
   shortenSymbol
-} from "./chunk-QIXNAB5K.js";
+} from "./chunk-TO3L4YNK.js";
 
 // src/queries/similar.ts
 function similar(db, symbolPattern, opts = {}) {
   const { minSimilarity = 0.4, limit = 20 } = opts;
   const target = findCallees(db, symbolPattern);
-  if (!target || target.callees.size === 0) return [];
+  if (!target) return [];
   if (!isFunctionLikeSymbol(target.symbol)) return [];
   const candidates = getAllCalleeFingerprints(db, {
     minCallees: 3,
@@ -22,7 +25,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
@@ -43,7 +46,10 @@ function similar(db, symbolPattern, opts = {}) {
     });
   }
   results.sort((a, b) => b.similarity - a.similarity);
-  return results.slice(0, limit);
+  if (results.length > 0) {
+    return results.slice(0, limit);
+  }
+  return similarBySourceShape(db, symbolPattern, { minSimilarity, limit });
 }
 function similarAll(db, opts = {}) {
   const { minSimilarity = 0.5, limit = 20, scope, minCallees = 4 } = opts;
@@ -190,9 +196,144 @@ function difference(a, b) {
   }
   return result;
 }
+function similarBySourceShape(db, symbolPattern, opts) {
+  const target = findSourceFingerprint(db, symbolPattern);
+  if (!target || target.tokens.size < 3) {
+    return [];
+  }
+  const minSimilarity = opts.minSimilarity >= 0.5 ? opts.minSimilarity : 0.3;
+  const results = [];
+  for (const candidate of getAllSourceFingerprints(db)) {
+    if (candidate.symbol === target.symbol || candidate.tokens.size < 3) continue;
+    const shared = intersection(target.tokens, candidate.tokens);
+    if (shared.size < 2) continue;
+    const union = /* @__PURE__ */ new Set([...target.tokens, ...candidate.tokens]);
+    const similarity = union.size > 0 ? shared.size / union.size : 0;
+    if (similarity < minSimilarity) continue;
+    results.push({
+      symbolA: target.symbol,
+      shortNameA: shortenSymbol(target.symbol),
+      fileA: target.file,
+      symbolB: candidate.symbol,
+      shortNameB: shortenSymbol(candidate.symbol),
+      fileB: candidate.file,
+      similarity,
+      sharedCallees: [...shared].sort(),
+      uniqueToA: [...difference(target.tokens, candidate.tokens)].sort(),
+      uniqueToB: [...difference(candidate.tokens, target.tokens)].sort()
+    });
+  }
+  results.sort((a, b) => b.similarity - a.similarity || a.shortNameB.localeCompare(b.shortNameB));
+  return results.slice(0, opts.limit);
+}
+function findSourceFingerprint(db, symbolPattern) {
+  const match = findFirstSymbolMatch(db, symbolPattern);
+  if (!match || !isFunctionLikeSymbol(match.symbol)) {
+    return null;
+  }
+  const snippet = definitionSnippet(db, match.relativePath, match.startLine, match.endLine, leafName(match.symbol));
+  const tokens = sourceTokens(snippet, leafName(match.symbol));
+  if (tokens.size === 0) {
+    return null;
+  }
+  return {
+    symbol: match.symbol,
+    file: match.relativePath,
+    tokens
+  };
+}
+function getAllSourceFingerprints(db) {
+  return getAllDefinitions(db).filter((definition) => definition.isFunctionLike).map((definition) => ({
+    symbol: definition.symbol,
+    file: definition.relativePath,
+    tokens: sourceTokens(
+      definitionSnippet(db, definition.relativePath, definition.startLine, definition.endLine, definition.leaf),
+      definition.leaf
+    )
+  })).filter((fingerprint) => fingerprint.tokens.size > 0);
+}
+function definitionSnippet(db, relativePath, startLine, endLine, leaf) {
+  const source = getSourceText(db, relativePath);
+  if (!source) {
+    return "";
+  }
+  const lines = source.split("\n");
+  if (endLine >= startLine && endLine - startLine <= 12) {
+    return lines.slice(startLine, endLine + 1).join("\n");
+  }
+  const markerPatterns = [
+    new RegExp(`\\bdef\\s+${escapeRegex(leaf)}\\b`),
+    new RegExp(`\\bfun\\s+${escapeRegex(leaf)}\\b`),
+    new RegExp(`\\bfn\\s+${escapeRegex(leaf)}\\b`),
+    new RegExp(`\\bfunction\\s+${escapeRegex(leaf)}\\b`),
+    new RegExp(`\\b${escapeRegex(leaf)}\\s*\\(`)
+  ];
+  const definitionStart = lines.findIndex((line) => markerPatterns.some((pattern) => pattern.test(line)));
+  if (definitionStart >= 0) {
+    let definitionEnd = definitionStart;
+    for (let index = definitionStart + 1; index < lines.length && index <= definitionStart + 8; index++) {
+      const line = lines[index] ?? "";
+      if (index > definitionStart && looksLikeDefinitionBoundary(line)) {
+        break;
+      }
+      definitionEnd = index;
+      if (line.trim() === "" && index > definitionStart + 1) {
+        break;
+      }
+    }
+    return lines.slice(definitionStart, definitionEnd + 1).join("\n");
+  }
+  return lines.slice(startLine, Math.min(lines.length, startLine + 8)).join("\n");
+}
+function sourceTokens(snippet, leaf) {
+  if (!snippet) {
+    return /* @__PURE__ */ new Set();
+  }
+  const stopWords = /* @__PURE__ */ new Set([
+    "public",
+    "private",
+    "protected",
+    "final",
+    "static",
+    "class",
+    "def",
+    "fun",
+    "fn",
+    "function",
+    "return",
+    "string",
+    "bool",
+    "boolean",
+    "void",
+    "unit",
+    "self",
+    "this",
+    "new",
+    "const",
+    "let",
+    "var",
+    "end",
+    "pub"
+  ]);
+  const normalizedLeafParts = splitIdentifier(leaf);
+  const normalized = snippet.replace(/["'`]/g, " ").replace(/\b\d+\b/g, " NUM ").replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[^A-Za-z0-9_]+/g, " ").replace(/_/g, " ").toLowerCase();
+  const tokens = normalized.split(/\s+/).map((token) => token.trim()).filter((token) => token.length > 1).filter((token) => !stopWords.has(token)).filter((token) => !normalizedLeafParts.has(token));
+  return new Set(tokens);
+}
+function splitIdentifier(value) {
+  return new Set(
+    value.replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[^A-Za-z0-9_]+|_/).map((part) => part.toLowerCase()).filter((part) => part.length > 1)
+  );
+}
+function looksLikeDefinitionBoundary(line) {
+  return /^\s*(?:def|fun|fn|function|class|trait|module|object|enum|interface|public|private|protected)\b/.test(line);
+}
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 
 export {
   similar,
   similarAll
 };
-//# sourceMappingURL=chunk-OIDHN6GD.js.map
+//# sourceMappingURL=chunk-6CH23IAS.js.map

package/dist/chunk-6ECR2FLR.js

@@ -0,0 +1,60 @@
+import {
+  getCalleeRowsForSymbol,
+  getDefinitionsForFile
+} from "./chunk-ALUFWH3U.js";
+import {
+  isFunctionLikeSymbol,
+  shortenSymbol
+} from "./chunk-TO3L4YNK.js";
+
+// src/queries/passthrough-candidates.ts
+function passthroughCandidates(db, opts) {
+  const { scope, maxLoc = 15, limit = 30 } = opts ?? {};
+  const symbols = getScopedDefinitions(db, scope).filter((definition) => definitionLoc(definition) >= 3 && definitionLoc(definition) <= maxLoc);
+  const results = [];
+  for (const sym of symbols) {
+    if (db.isIgnored(sym.relativePath) || !isFunctionLikeSymbol(sym.symbol)) continue;
+    const rawCallees = getCalleeRowsForSymbol(db, sym);
+    const callees = rawCallees.some((callee2) => isFunctionLikeSymbol(callee2.symbol)) ? rawCallees.filter((callee2) => isFunctionLikeSymbol(callee2.symbol)) : rawCallees;
+    const uniqueCallees = /* @__PURE__ */ new Map();
+    for (const c of callees) {
+      if (!uniqueCallees.has(c.symbol)) {
+        uniqueCallees.set(c.symbol, { symbol: c.symbol, file: c.file });
+      }
+    }
+    if (uniqueCallees.size !== 1) continue;
+    const [, callee] = [...uniqueCallees.entries()][0];
+    results.push({
+      symbol: sym.symbol,
+      shortName: shortenSymbol(sym.symbol),
+      file: sym.relativePath,
+      startLine: sym.startLine,
+      endLine: sym.endLine,
+      loc: definitionLoc(sym),
+      forwardsTo: callee.symbol,
+      forwardsToShort: shortenSymbol(callee.symbol),
+      forwardsToFile: callee.file
+    });
+  }
+  results.sort((a, b) => a.loc - b.loc || a.file.localeCompare(b.file));
+  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;
+}
+
+export {
+  passthroughCandidates
+};
+//# sourceMappingURL=chunk-6ECR2FLR.js.map

package/dist/{chunk-C7H5WBTJ.js → chunk-6UZU7DFL.js}

@@ -2,10 +2,10 @@ import {
   findFirstSymbolMatch,
   getCalleeRowsForSymbol,
   getCallerRowsForSymbol
-} from "./chunk-AXQKUYKF.js";
+} from "./chunk-ALUFWH3U.js";
 import {
   shortenSymbol
-} from "./chunk-QIXNAB5K.js";
+} from "./chunk-TO3L4YNK.js";
 
 // src/queries/call-graph.ts
 function callGraph(db, symbolPattern) {
@@ -43,4 +43,4 @@ function uniqueRows(rows) {
 export {
   callGraph
 };
-//# sourceMappingURL=chunk-C7H5WBTJ.js.map
+//# sourceMappingURL=chunk-6UZU7DFL.js.map

package/dist/chunk-7BS4CPJX.js

@@ -0,0 +1,162 @@
+import {
+  getAllDefinitions,
+  getSourceText
+} from "./chunk-ALUFWH3U.js";
+import {
+  shortenSymbol
+} from "./chunk-TO3L4YNK.js";
+
+// src/queries/similar-signatures.ts
+function similarSignatures(db, opts = {}) {
+  const { scope, minLoc = 1, limit } = opts;
+  const sigGroups = /* @__PURE__ */ new Map();
+  for (const definition of getAllDefinitions(db, { scope })) {
+    if (!definition.isFunctionLike || db.isIgnored(definition.relativePath)) continue;
+    const loc = definition.endLine - definition.startLine + 1;
+    if (loc < minLoc) continue;
+    const normalized = resolveNormalizedSignature(db, definition);
+    if (!normalized) continue;
+    const entry = {
+      symbol: definition.symbol,
+      shortName: shortenSymbol(definition.symbol),
+      file: definition.relativePath,
+      startLine: definition.startLine,
+      endLine: definition.endLine,
+      loc
+    };
+    const existing = sigGroups.get(normalized);
+    if (existing) {
+      existing.push(entry);
+    } else {
+      sigGroups.set(normalized, [entry]);
+    }
+  }
+  const results = [];
+  for (const [signature, functions] of sigGroups) {
+    if (functions.length < 2) continue;
+    results.push({ signature, functions });
+  }
+  results.sort((a, b) => {
+    const sizeDiff = b.functions.length - a.functions.length;
+    if (sizeDiff !== 0) return sizeDiff;
+    const locA = a.functions.reduce((sum, f) => sum + f.loc, 0);
+    const locB = b.functions.reduce((sum, f) => sum + f.loc, 0);
+    return locB - locA;
+  });
+  return limit ? results.slice(0, limit) : results;
+}
+function resolveNormalizedSignature(db, definition) {
+  const documented = extractDocumentedSignature(definition.documentation);
+  const normalizedDocumented = documented ? normalizeSignature(documented) : null;
+  if (normalizedDocumented) {
+    return normalizedDocumented;
+  }
+  return normalizeSourceSignature(
+    extractDeclarationHead(db, definition.relativePath, definition.startLine, definition.endLine, definition.leaf),
+    definition.leaf
+  );
+}
+function extractDocumentedSignature(documentation) {
+  if (!documentation || !documentation.includes("|")) {
+    return null;
+  }
+  const extracted = documentation.slice(documentation.indexOf("|") + 1).replace(/\n/g, " ").trim();
+  return extracted.length > 0 ? extracted : null;
+}
+function extractDeclarationHead(db, relativePath, startLine, endLine, leaf) {
+  const source = getSourceText(db, relativePath);
+  if (!source) return null;
+  const lines = source.split(/\r?\n/);
+  const candidates = declarationStartLines(lines, startLine, endLine, leaf);
+  for (const candidate of candidates) {
+    const maxLine = Math.min(lines.length - 1, Math.max(candidate, candidate + 4));
+    let collected = "";
+    for (let lineIndex = candidate; lineIndex <= maxLine; lineIndex += 1) {
+      const line = lines[lineIndex]?.trim();
+      if (!line) continue;
+      collected = collected ? `${collected} ${line}` : line;
+      if (looksCompleteDeclaration(collected)) {
+        return collected;
+      }
+    }
+    if (collected && collected.includes("(")) {
+      return collected;
+    }
+  }
+  return null;
+}
+function looksCompleteDeclaration(declaration) {
+  const normalized = declaration.replace(/\s+/g, " ").trim();
+  if (!normalized.includes("(")) return false;
+  if (parenBalance(normalized) > 0) return false;
+  return /[;{]$/.test(normalized) || /\)\s*(?::\s*[^={]+)?\s*(?:=>|=|throws\b|where\b|$)/i.test(normalized) || /\)\s*As\s+.+$/i.test(normalized);
+}
+function normalizeSignature(raw) {
+  if (!raw || !raw.trim()) return null;
+  let sig = raw.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();
+  const parenIdx = sig.indexOf("(");
+  if (parenIdx === -1) return null;
+  sig = sig.slice(parenIdx);
+  sig = sig.replace(/\s+/g, "").toLowerCase();
+  if (sig.length < 3) return null;
+  return sig;
+}
+function normalizeSourceSignature(raw, leaf) {
+  if (!raw || !raw.trim()) return null;
+  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${escapeRegex(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();
+  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;
+  }
+  const normalized = `${prefix ? `${prefix} ` : ""}${suffix}`.replace(/\s+/g, "").toLowerCase();
+  return normalized.length >= 3 ? normalized : null;
+}
+function declarationStartLines(lines, startLine, endLine, leaf) {
+  const escapedLeaf = escapeRegex(leaf);
+  const callablePattern = new RegExp(`\\b${escapedLeaf}\\b\\s*\\(`, "i");
+  const rubyPattern = new RegExp(`\\bdef\\s+${escapedLeaf}\\b`, "i");
+  const candidates = [];
+  const seen = /* @__PURE__ */ new Set();
+  const preferredStart = Math.max(0, Math.min(startLine, lines.length - 1));
+  const preferredEnd = Math.max(preferredStart, Math.min(lines.length - 1, Math.max(endLine, startLine + 4)));
+  for (let lineIndex = preferredStart; lineIndex <= preferredEnd; lineIndex += 1) {
+    const line = lines[lineIndex] ?? "";
+    if ((callablePattern.test(line) || rubyPattern.test(line)) && !seen.has(lineIndex)) {
+      seen.add(lineIndex);
+      candidates.push(lineIndex);
+    }
+  }
+  for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
+    const line = lines[lineIndex] ?? "";
+    if ((callablePattern.test(line) || rubyPattern.test(line)) && !seen.has(lineIndex)) {
+      seen.add(lineIndex);
+      candidates.push(lineIndex);
+    }
+  }
+  return candidates;
+}
+function parenBalance(value) {
+  let balance = 0;
+  for (const char of value) {
+    if (char === "(") balance += 1;
+    if (char === ")") balance -= 1;
+  }
+  return balance;
+}
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+export {
+  similarSignatures
+};
+//# sourceMappingURL=chunk-7BS4CPJX.js.map

package/dist/{chunk-UGQKAVCD.js → chunk-A6XLXV6W.js}

@@ -1,10 +1,10 @@
 import {
   findFirstSymbolMatch,
   getCalleeRowsForSymbol
-} from "./chunk-AXQKUYKF.js";
+} from "./chunk-ALUFWH3U.js";
 import {
   shortenSymbol
-} from "./chunk-QIXNAB5K.js";
+} from "./chunk-TO3L4YNK.js";
 
 // src/queries/complexity.ts
 import { readFileSync } from "fs";
@@ -107,4 +107,4 @@ function stripCommentsAndStrings(source) {
 export {
   complexity
 };
-//# sourceMappingURL=chunk-UGQKAVCD.js.map
+//# sourceMappingURL=chunk-A6XLXV6W.js.map