scip-query 0.3.5 → 0.4.1

package/dist/{chunk-P3E6L7KW.js → chunk-TWVXFKJA.js}

@@ -1,9 +1,15 @@
 import {
   isLiveBarrel
-} from "./chunk-YY4QGUQ5.js";
+} from "./chunk-JKXHHV4B.js";
 import {
+  getDefinitionsForFile,
+  getSourceExports,
+  getSourceImports
+} from "./chunk-ALUFWH3U.js";
+import {
+  leafSuffix,
   shortenSymbol
-} from "./chunk-QIXNAB5K.js";
+} from "./chunk-TO3L4YNK.js";
 
 // src/queries/redundant-reexports.ts
 function redundantReexports(db, opts = {}) {
@@ -96,10 +102,84 @@ function redundantReexports(db, opts = {}) {
   results.sort(
     (a, b) => b.directConsumers - a.directConsumers || a.barrelFile.localeCompare(b.barrelFile) || a.shortName.localeCompare(b.shortName)
   );
-  return limit ? results.slice(0, limit) : results;
+  const withDartFallback = dedupeReexports([
+    ...results,
+    ...findSourceRedundantReexports(db, scope)
+  ]);
+  withDartFallback.sort(
+    (a, b) => b.directConsumers - a.directConsumers || a.barrelFile.localeCompare(b.barrelFile) || a.shortName.localeCompare(b.shortName)
+  );
+  return limit ? withDartFallback.slice(0, limit) : withDartFallback;
+}
+function findSourceRedundantReexports(db, scope) {
+  const files = db.all(
+    `SELECT relative_path
+     FROM documents
+     WHERE 1 = 1
+       ${scope ? "AND relative_path LIKE ?" : ""}
+       ${db.pathExclusionsFor("documents")}
+     ORDER BY relative_path`,
+    ...scope ? [`%${scope}%`] : []
+  );
+  const candidates = files.map((row) => row.relative_path).filter((relativePath) => !db.isIgnored(relativePath)).filter((relativePath) => getSourceExports(db, relativePath).length > 0);
+  const results = [];
+  for (const barrelPath of candidates) {
+    const exports = getSourceExports(db, barrelPath).filter((entry) => entry.sourcePath && !db.isIgnored(entry.sourcePath));
+    if (exports.length === 0) continue;
+    const barrelConsumers = countDirectImporters(db, barrelPath, barrelPath);
+    if (barrelConsumers > 0) continue;
+    for (const exported of exports) {
+      const sourcePath = exported.sourcePath;
+      const representative = representativeExportSymbol(db, sourcePath);
+      if (!representative) continue;
+      results.push({
+        barrelFile: barrelPath,
+        symbol: representative.symbol,
+        shortName: shortenSymbol(representative.symbol),
+        originalFile: sourcePath,
+        barrelConsumers: 0,
+        directConsumers: countDirectImporters(db, sourcePath, barrelPath)
+      });
+    }
+  }
+  return results;
+}
+function countDirectImporters(db, targetPath, excludedPath) {
+  const files = db.all(
+    `SELECT relative_path
+     FROM documents
+     WHERE 1 = 1
+       ${db.pathExclusionsFor("documents")}
+     ORDER BY relative_path`
+  );
+  const importers = /* @__PURE__ */ new Set();
+  for (const row of files) {
+    if (db.isIgnored(row.relative_path) || row.relative_path === excludedPath) continue;
+    for (const imported of getSourceImports(db, row.relative_path)) {
+      if (imported.sourcePath === targetPath) {
+        importers.add(row.relative_path);
+      }
+    }
+  }
+  return importers.size;
+}
+function representativeExportSymbol(db, sourcePath) {
+  const definitions = getDefinitionsForFile(db, sourcePath);
+  return definitions.find((definition) => leafSuffix(definition.symbol) === "method") ?? definitions[0] ?? null;
+}
+function dedupeReexports(rows) {
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const row of rows) {
+    const key = `${row.barrelFile}|${row.symbol}|${row.originalFile}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    unique.push(row);
+  }
+  return unique;
 }
 
 export {
   redundantReexports
 };
-//# sourceMappingURL=chunk-P3E6L7KW.js.map
+//# sourceMappingURL=chunk-TWVXFKJA.js.map

package/dist/chunk-UJWI5CBB.js

@@ -0,0 +1,75 @@
+import {
+  getDefinitionsForFile,
+  resolveIndexedPaths
+} from "./chunk-ALUFWH3U.js";
+import {
+  leafSuffix,
+  shortenSymbol
+} from "./chunk-TO3L4YNK.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-UJWI5CBB.js.map

package/dist/{chunk-J3JSOSUO.js → chunk-VKBOLNYN.js}

@@ -1,10 +1,10 @@
 import {
   findFirstSymbolMatch,
   resolveIndexedFile
-} from "./chunk-AXQKUYKF.js";
+} from "./chunk-ALUFWH3U.js";
 import {
   shortenSymbol
-} from "./chunk-QIXNAB5K.js";
+} from "./chunk-TO3L4YNK.js";
 
 // src/queries/code.ts
 import { readFileSync } from "fs";
@@ -76,4 +76,4 @@ function readFileRange(db, filePath, startLine, endLine, context) {
 export {
   code
 };
-//# sourceMappingURL=chunk-J3JSOSUO.js.map
+//# sourceMappingURL=chunk-VKBOLNYN.js.map

package/dist/{chunk-KBOQX573.js → chunk-VY2L4TP6.js}

@@ -1,6 +1,10 @@
+import {
+  getAllDefinitions,
+  getCallerRowsForSymbol
+} from "./chunk-ALUFWH3U.js";
 import {
   shortenSymbol
-} from "./chunk-QIXNAB5K.js";
+} from "./chunk-TO3L4YNK.js";
 
 // src/queries/hotspots.ts
 function hotspots(db, opts = {}) {
@@ -27,16 +31,29 @@ function hotspots(db, opts = {}) {
     LIMIT ?`,
     limit
   );
-  return rows.filter((r) => !db.isIgnored(r.defined_in)).map((r) => ({
+  const indexedResults = rows.filter((r) => !db.isIgnored(r.defined_in)).map((r) => ({
     symbol: r.symbol,
     shortName: shortenSymbol(r.symbol),
     refCount: r.ref_count,
     fileCount: r.file_count,
     definedIn: r.defined_in
   }));
+  if (indexedResults.length > 0) {
+    return indexedResults;
+  }
+  return getAllDefinitions(db, { scope }).filter((definition) => !db.isIgnored(definition.relativePath)).map((definition) => {
+    const callerRows = getCallerRowsForSymbol(db, definition, { limit: 500 });
+    return {
+      symbol: definition.symbol,
+      shortName: shortenSymbol(definition.symbol),
+      refCount: callerRows.length,
+      fileCount: new Set(callerRows.map((row) => row.file)).size,
+      definedIn: definition.relativePath
+    };
+  }).filter((row) => row.refCount > 0).sort((left, right) => right.refCount - left.refCount || right.fileCount - left.fileCount).slice(0, limit);
 }
 
 export {
   hotspots
 };
-//# sourceMappingURL=chunk-KBOQX573.js.map
+//# sourceMappingURL=chunk-VY2L4TP6.js.map

package/dist/{chunk-KKCHYLVI.js → chunk-W46L2BXT.js}

@@ -1,6 +1,6 @@
 import {
   resolveIndexedFile
-} from "./chunk-AXQKUYKF.js";
+} from "./chunk-ALUFWH3U.js";
 
 // src/queries/coupling.ts
 function coupling(db, file1, file2) {
@@ -81,4 +81,4 @@ export {
   coupling,
   topCoupling
 };
-//# sourceMappingURL=chunk-KKCHYLVI.js.map
+//# sourceMappingURL=chunk-W46L2BXT.js.map

package/dist/chunk-XUVPQDXW.js

@@ -0,0 +1,34 @@
+import {
+  isEntrySurface
+} from "./chunk-JKXHHV4B.js";
+import {
+  getAllDefinitions,
+  getCalleeRowsForSymbol,
+  getCallerRowsForSymbol
+} from "./chunk-ALUFWH3U.js";
+import {
+  shortenSymbol
+} from "./chunk-TO3L4YNK.js";
+
+// src/queries/isolated.ts
+function isolated(db, opts = {}) {
+  const { scope, minLoc = 3 } = opts;
+  return getAllDefinitions(db, { scope }).filter((definition) => !db.isIgnored(definition.relativePath)).filter((definition) => !isEntrySurface(db, definition.relativePath)).filter((definition) => definition.isFunctionLike).map((definition) => ({
+    definition,
+    loc: definition.endLine - definition.startLine + 1
+  })).filter((entry) => entry.loc >= minLoc).filter((entry) => getCallerRowsForSymbol(db, entry.definition, { limit: 1 }).length === 0).filter((entry) => getCalleeRowsForSymbol(db, entry.definition, { limit: 1 }).length === 0).sort(
+    (left, right) => right.loc - left.loc || left.definition.relativePath.localeCompare(right.definition.relativePath) || left.definition.startLine - right.definition.startLine
+  ).map((entry) => ({
+    symbol: entry.definition.symbol,
+    shortName: shortenSymbol(entry.definition.symbol),
+    relativePath: entry.definition.relativePath,
+    startLine: entry.definition.startLine,
+    endLine: entry.definition.endLine,
+    loc: entry.loc
+  }));
+}
+
+export {
+  isolated
+};
+//# sourceMappingURL=chunk-XUVPQDXW.js.map

package/dist/{chunk-DH7G3DDV.js → chunk-Z5VSUOEE.js}

@@ -1,6 +1,6 @@
 import {
   buildFileDepGraph
-} from "./chunk-AXQKUYKF.js";
+} from "./chunk-ALUFWH3U.js";
 
 // src/queries/deep-chains.ts
 function deepChains(db, opts = {}) {
@@ -41,4 +41,4 @@ function deepChains(db, opts = {}) {
 export {
   deepChains
 };
-//# sourceMappingURL=chunk-DH7G3DDV.js.map
+//# sourceMappingURL=chunk-Z5VSUOEE.js.map

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

@@ -3,12 +3,13 @@ import {
 } from "./chunk-4TYLS5XX.js";
 import {
   findFirstSymbolMatch,
-  getSourceReferenceSites
-} from "./chunk-AXQKUYKF.js";
+  getSourceReferenceSites,
+  getSourceText
+} from "./chunk-ALUFWH3U.js";
 import {
   isFunctionLikeSymbol,
   shortenSymbol
-} from "./chunk-QIXNAB5K.js";
+} from "./chunk-TO3L4YNK.js";
 
 // src/queries/trace.ts
 function trace(db, symbolPattern) {
@@ -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-ZVZAIIB5.js.map