scip-query 0.4.0 → 0.4.1

package/dist/cli.js

@@ -1048,7 +1048,8 @@ 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);
@@ -1065,7 +1066,7 @@ 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 });
   }
   const durationMs = Date.now() - start;
   onStatus(`Done in ${(durationMs / 1e3).toFixed(1)}s`);
@@ -1328,7 +1329,7 @@ import { basename as basename2 } from "path";
 // src/source-analysis.ts
 import {
   existsSync as existsSync8,
-  readFileSync as readFileSync4
+  readFileSync as readFileSync3
 } from "fs";
 import {
   basename,
@@ -1365,7 +1366,7 @@ function getSourceImports(db, relativePath) {
     cache.set(normalized, []);
     return [];
   }
-  const source = readFileSync4(fullPath, "utf-8");
+  const source = readFileSync3(fullPath, "utf-8");
   const parsed = isPythonSourcePath(normalized) ? parsePythonImports(db, normalized, source) : isJavaScriptSourcePath(normalized) ? parseJavaScriptImports(db, normalized, source) : isJvmSourcePath(normalized) ? parseJvmImports(db, normalized, source) : isRustSourcePath(normalized) ? parseRustImports(db, normalized, source) : isRubySourcePath(normalized) ? parseRubyImports(db, normalized, source) : isCLikeSourcePath(normalized) ? parseCLikeImports(db, normalized, source) : isDotNetSourcePath(normalized) ? parseDotNetImports(db, normalized, source) : isDartSourcePath(normalized) ? parseDartImports(db, normalized, source) : isPhpSourcePath(normalized) ? parsePhpImports(db, normalized, source) : [];
   cache.set(normalized, parsed);
   return parsed;
@@ -1382,7 +1383,7 @@ function getSourceExports(db, relativePath) {
     cache.set(normalized, []);
     return [];
   }
-  const source = readFileSync4(fullPath, "utf-8");
+  const source = readFileSync3(fullPath, "utf-8");
   const parsed = isDartSourcePath(normalized) ? parseDartExports(db, normalized, source) : isRustSourcePath(normalized) ? parseRustExports(db, normalized, source) : [];
   cache.set(normalized, parsed);
   return parsed;
@@ -2424,7 +2425,7 @@ function getSourceText(db, relativePath) {
     cache.set(normalized, "");
     return "";
   }
-  const source = readFileSync4(fullPath, "utf-8");
+  const source = readFileSync3(fullPath, "utf-8");
   cache.set(normalized, source);
   return source;
 }
@@ -2526,7 +2527,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 +2707,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 +2748,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 +2768,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 +2787,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 +2928,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 +2964,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 +3351,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 +3371,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 +3391,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 +3406,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;
@@ -5526,7 +5692,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 +5929,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 +5995,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, "\\$&");
 }
 
@@ -7229,7 +7395,7 @@ function convergence(db, symbolPatternA, symbolPatternB) {
 }
 
 // src/queries/code.ts
-import { readFileSync as readFileSync5 } from "fs";
+import { readFileSync as readFileSync4 } from "fs";
 import { join as join9 } from "path";
 function code(db, symbolPattern, opts = {}) {
   const { context = 0 } = opts;
@@ -7246,7 +7412,7 @@ function code(db, symbolPattern, opts = {}) {
   const filePath = join9(db.config.projectRoot, match.relativePath);
   let fileContent;
   try {
-    fileContent = readFileSync5(filePath, "utf-8");
+    fileContent = readFileSync4(filePath, "utf-8");
   } catch {
     return null;
   }
@@ -7276,7 +7442,7 @@ function readFileRange(db, filePath, startLine, endLine, context) {
   const fullPath = join9(db.config.projectRoot, doc.relative_path);
   let fileContent;
   try {
-    fileContent = readFileSync5(fullPath, "utf-8");
+    fileContent = readFileSync4(fullPath, "utf-8");
   } catch {
     return null;
   }
@@ -7296,7 +7462,7 @@ function readFileRange(db, filePath, startLine, endLine, context) {
 }
 
 // src/queries/complexity.ts
-import { readFileSync as readFileSync6 } from "fs";
+import { readFileSync as readFileSync5 } from "fs";
 import { join as join10 } from "path";
 function complexity(db, symbolPattern) {
   const match = findFirstSymbolMatch(db, symbolPattern);
@@ -7309,7 +7475,7 @@ function complexity(db, symbolPattern) {
   const filePath = join10(db.config.projectRoot, match.relativePath);
   let source = "";
   try {
-    const lines = readFileSync6(filePath, "utf-8").split("\n");
+    const lines = readFileSync5(filePath, "utf-8").split("\n");
     source = lines.slice(match.startLine, match.endLine + 1).join("\n");
   } catch {
   }
@@ -7820,17 +7986,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 +8004,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 +8035,7 @@ function parenBalance(value) {
   }
   return balance;
 }
-function escapeRegex3(value) {
+function escapeRegex4(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }