scip-query 0.3.5 → 0.4.0

package/dist/{chunk-GEXE2T6I.js → chunk-EOHPASDV.js}

@@ -3,8 +3,9 @@ import {
 } from "./chunk-4TYLS5XX.js";
 import {
   findFirstSymbolMatch,
-  getSourceReferenceSites
-} from "./chunk-AXQKUYKF.js";
+  getSourceReferenceSites,
+  getSourceText
+} from "./chunk-QGCEAVJD.js";
 import {
   isFunctionLikeSymbol,
   shortenSymbol
@@ -16,24 +17,22 @@ function trace(db, symbolPattern) {
   if (!match) {
     return { definitions: [], referencedBy: [] };
   }
-  const defRows = db.all(
-    `SELECT d.relative_path, der.start_line, der.end_line,
+  const definitionMeta = db.get(
+    `SELECT
       gs.display_name,
       REPLACE(SUBSTR(gs.documentation, INSTR(gs.documentation, '|') + 1), char(10), ' ') AS sig
     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 gs.id = ?
-    ORDER BY d.relative_path, der.start_line
     LIMIT 10`,
     match.symbolId
   );
-  const definitions = defRows.filter((r) => !db.isIgnored(r.relative_path)).map((r) => ({
-    relativePath: r.relative_path,
-    startLine: r.start_line,
-    endLine: r.end_line,
-    signature: buildTraceSignature(r.sig, r.display_name, match.symbol)
-  }));
+  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),
+    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) => ({
     relativePath: site.file,
@@ -66,6 +65,15 @@ function trace(db, symbolPattern) {
   }));
   return { definitions, referencedBy };
 }
+function definitionSource(db, relativePath, startLine, endLine) {
+  const source = getSourceText(db, relativePath);
+  if (!source) {
+    return null;
+  }
+  const lines = source.split("\n");
+  const slice = lines.slice(startLine, endLine + 1).join("\n").trimEnd();
+  return slice.length > 0 ? slice : null;
+}
 function buildTraceSignature(signature, displayName, rawSymbol) {
   const cleaned = cleanSignature(signature);
   if (cleaned && !looksBogusSignature(cleaned)) {
@@ -84,4 +92,4 @@ function looksBogusSignature(signature) {
 export {
   trace
 };
-//# sourceMappingURL=chunk-GEXE2T6I.js.map
+//# sourceMappingURL=chunk-EOHPASDV.js.map

package/dist/chunk-GIBETK3W.js

@@ -0,0 +1,37 @@
+import {
+  findFirstSymbolMatch,
+  getDefinitionsForFile
+} from "./chunk-QGCEAVJD.js";
+import {
+  leafName,
+  leafSuffix
+} from "./chunk-QIXNAB5K.js";
+
+// src/queries/methods.ts
+import { basename } from "path";
+function methods(db, className) {
+  const classMatch = findFirstSymbolMatch(db, className);
+  if (!classMatch) {
+    return [];
+  }
+  const ownerName = leafName(classMatch.symbol);
+  const definitions = getDefinitionsForFile(db, classMatch.relativePath).filter((definition) => isCallableSymbol(definition.symbol));
+  const directMethods = definitions.filter((definition) => definition.parentTypeName === ownerName || definition.symbol.includes(ownerName));
+  const fileScopedMethods = directMethods.length > 0 ? directMethods : stripExtension(basename(classMatch.relativePath)) === ownerName ? definitions.filter((definition) => definition.symbol.includes("<invalid-global-code>")) : [];
+  return fileScopedMethods.map((definition) => ({
+    startLine: definition.startLine,
+    endLine: definition.endLine,
+    name: leafName(definition.symbol)
+  }));
+}
+function isCallableSymbol(rawSymbol) {
+  return rawSymbol.endsWith("().") || leafSuffix(rawSymbol) === "method";
+}
+function stripExtension(relativePath) {
+  return relativePath.replace(/\.[^.]+$/, "");
+}
+
+export {
+  methods
+};
+//# sourceMappingURL=chunk-GIBETK3W.js.map

package/dist/{chunk-SMDCNPMK.js → chunk-H3FPW5YN.js}

@@ -1,6 +1,6 @@
 import {
   resolveIndexedFile
-} from "./chunk-AXQKUYKF.js";
+} from "./chunk-QGCEAVJD.js";
 import {
   shortenSymbol
 } from "./chunk-QIXNAB5K.js";
@@ -68,4 +68,4 @@ function changeSurface(db, filePattern) {
 export {
   changeSurface
 };
-//# sourceMappingURL=chunk-SMDCNPMK.js.map
+//# sourceMappingURL=chunk-H3FPW5YN.js.map

package/dist/{chunk-VMM4SYV4.js → chunk-HNURMDF4.js}

@@ -1,7 +1,8 @@
 import {
+  buildFileDepGraph,
   findFirstSymbolMatch,
   resolveIndexedFile
-} from "./chunk-AXQKUYKF.js";
+} from "./chunk-QGCEAVJD.js";
 import {
   shortenSymbol
 } from "./chunk-QIXNAB5K.js";
@@ -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-HNURMDF4.js.map

package/dist/{chunk-7KIMF5PV.js → chunk-HRDPUTIQ.js}

@@ -1,6 +1,6 @@
 import {
   buildFileDepGraph
-} from "./chunk-AXQKUYKF.js";
+} from "./chunk-QGCEAVJD.js";
 
 // src/queries/drift.ts
 import path from "path";
@@ -162,4 +162,4 @@ function isTestLikePath(filePath) {
 export {
   drift
 };
-//# sourceMappingURL=chunk-7KIMF5PV.js.map
+//# sourceMappingURL=chunk-HRDPUTIQ.js.map

package/dist/{chunk-OIDHN6GD.js → chunk-I2JM34UV.js}

@@ -1,9 +1,12 @@
 import {
   findFirstSymbolMatch,
-  getCalleeRowsForSymbol
-} from "./chunk-AXQKUYKF.js";
+  getAllDefinitions,
+  getCalleeRowsForSymbol,
+  getSourceText
+} from "./chunk-QGCEAVJD.js";
 import {
   isFunctionLikeSymbol,
+  leafName,
   shortenSymbol
 } from "./chunk-QIXNAB5K.js";
 
@@ -11,7 +14,7 @@ import {
 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,
@@ -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-I2JM34UV.js.map

package/dist/{chunk-EPWLXXBL.js → chunk-IV6NZ426.js}

@@ -1,38 +1,22 @@
 import {
-  getCalleeRowsForSymbol
-} from "./chunk-AXQKUYKF.js";
+  getCalleeRowsForSymbol,
+  getDefinitionsForFile
+} from "./chunk-QGCEAVJD.js";
 import {
+  isFunctionLikeSymbol,
   shortenSymbol
 } from "./chunk-QIXNAB5K.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-IV6NZ426.js.map

package/dist/{chunk-VT4JBH6L.js → chunk-KDCQJTYW.js}

@@ -1,6 +1,6 @@
 import {
   resolveIndexedFile
-} from "./chunk-AXQKUYKF.js";
+} from "./chunk-QGCEAVJD.js";
 
 // src/queries/deps.ts
 function deps(db, filePattern) {
@@ -50,4 +50,4 @@ export {
   deps,
   rdeps
 };
-//# sourceMappingURL=chunk-VT4JBH6L.js.map
+//# sourceMappingURL=chunk-KDCQJTYW.js.map

package/dist/{chunk-5OMVSV6E.js → chunk-LOVDB4C6.js}

@@ -1,6 +1,6 @@
 import {
   resolveIndexedPaths
-} from "./chunk-AXQKUYKF.js";
+} from "./chunk-QGCEAVJD.js";
 import {
   shortenSymbol
 } from "./chunk-QIXNAB5K.js";
@@ -48,4 +48,4 @@ function outline(db, filePattern) {
 export {
   outline
 };
-//# sourceMappingURL=chunk-5OMVSV6E.js.map
+//# sourceMappingURL=chunk-LOVDB4C6.js.map

package/dist/chunk-MA3B3IUT.js

@@ -0,0 +1,75 @@
+import {
+  getDefinitionsForFile,
+  resolveIndexedPaths
+} from "./chunk-QGCEAVJD.js";
+import {
+  leafSuffix,
+  shortenSymbol
+} from "./chunk-QIXNAB5K.js";
+
+// src/queries/surface.ts
+function surface(db, modulePattern) {
+  const matchedPaths = resolveIndexedPaths(db, modulePattern);
+  if (matchedPaths.length === 0) {
+    return [];
+  }
+  const placeholders = matchedPaths.map(() => "?").join(", ");
+  const rows = db.all(
+    `SELECT DISTINCT d1.relative_path, gs.symbol
+    FROM mentions m
+    JOIN chunks c ON m.chunk_id = c.id
+    JOIN documents d1 ON c.document_id = d1.id
+    JOIN global_symbols gs ON m.symbol_id = gs.id
+    WHERE d1.relative_path NOT IN (${placeholders})
+      AND (
+        EXISTS (
+          SELECT 1
+          FROM defn_enclosing_ranges der
+          JOIN documents d2 ON der.document_id = d2.id
+          WHERE der.symbol_id = gs.id
+            AND d2.relative_path IN (${placeholders})
+        )
+        OR EXISTS (
+          SELECT 1
+          FROM mentions def_m
+          JOIN chunks def_c ON def_m.chunk_id = def_c.id
+          JOIN documents d2 ON def_c.document_id = d2.id
+          WHERE def_m.symbol_id = gs.id
+            AND def_m.role = 1
+            AND d2.relative_path IN (${placeholders})
+        )
+      )
+      AND m.role != 1
+      AND ${db.localSymbolPredicate}
+      ${db.pathExclusionsFor("d1")}
+    ORDER BY d1.relative_path`,
+    ...matchedPaths,
+    ...matchedPaths,
+    ...matchedPaths
+  );
+  const exposedDefinitions = matchedPaths.flatMap(
+    (relativePath) => getDefinitionsForFile(db, relativePath).filter((definition) => isCallableSymbol(definition.symbol)).map((definition) => ({
+      relative_path: relativePath,
+      symbol: definition.symbol
+    }))
+  );
+  const seen = /* @__PURE__ */ new Set();
+  return [...rows, ...exposedDefinitions].filter((r) => !db.isIgnored(r.relative_path)).filter((r) => {
+    const key = `${r.relative_path}|${r.symbol}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  }).map((r) => ({
+    consumer: r.relative_path,
+    symbol: r.symbol,
+    shortName: shortenSymbol(r.symbol)
+  }));
+}
+function isCallableSymbol(rawSymbol) {
+  return rawSymbol.endsWith("().") || leafSuffix(rawSymbol) === "method";
+}
+
+export {
+  surface
+};
+//# sourceMappingURL=chunk-MA3B3IUT.js.map

package/dist/{chunk-26DOJ63W.js → chunk-N2LH3M2P.js}

@@ -2,7 +2,7 @@ import {
   findFirstSymbolMatch,
   getSourceImports,
   resolveIndexedFile
-} from "./chunk-AXQKUYKF.js";
+} from "./chunk-QGCEAVJD.js";
 import {
   isModuleLikeSymbol,
   leafName,
@@ -79,6 +79,14 @@ function importedBy(db, symbolPattern) {
       if (targetFile && normalizePath(entry.sourcePath) !== normalizePath(targetFile)) {
         continue;
       }
+      if (entry.kind === "side-effect") {
+        importers.add(row.relative_path);
+        continue;
+      }
+      if (targetFile && isCLikeImporter(row.relative_path)) {
+        importers.add(row.relative_path);
+        continue;
+      }
       if (targetIsModule) {
         importers.add(row.relative_path);
         continue;
@@ -152,10 +160,13 @@ function renderImportSymbol(importedName, localName, kind) {
 function normalizePath(path) {
   return path.replace(/\\/g, "/");
 }
+function isCLikeImporter(relativePath) {
+  return /\.(?:c|h|cc|cpp|cxx|hpp|hh|hxx)$/i.test(relativePath);
+}
 
 export {
   imports,
   importedBy,
   unusedImports
 };
-//# sourceMappingURL=chunk-26DOJ63W.js.map
+//# sourceMappingURL=chunk-N2LH3M2P.js.map