scip-query 0.3.4 → 0.4.0

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

@@ -1,3 +1,7 @@
+import {
+  getAllDefinitions,
+  getCallerRowsForSymbol
+} from "./chunk-QGCEAVJD.js";
 import {
   shortenSymbol
 } from "./chunk-QIXNAB5K.js";
@@ -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-RIEA5DOB.js.map

package/dist/{chunk-VIYSWZCO.js → chunk-SL674KAW.js}

@@ -1,6 +1,9 @@
 import {
+  getAllDefinitions,
+  getCalleeRowsForSymbol,
+  getCallerRowsForSymbol,
   testFileExclusionSql
-} from "./chunk-AXQKUYKF.js";
+} from "./chunk-QGCEAVJD.js";
 import {
   shortenSymbol
 } from "./chunk-QIXNAB5K.js";
@@ -80,7 +83,7 @@ function complexityHotspots(db, opts) {
     minLoc,
     limit
   );
-  return rows.filter((r) => !db.isIgnored(r.file)).map((r) => ({
+  const indexedResults = rows.filter((r) => !db.isIgnored(r.file)).map((r) => ({
     symbol: r.symbol,
     shortName: shortenSymbol(r.symbol),
     file: r.file,
@@ -94,9 +97,34 @@ function complexityHotspots(db, opts) {
       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 });
+    const calleeRows = getCalleeRowsForSymbol(db, definition, { limit: 500 });
+    const fanIn = new Set(callerRows.map((row) => row.file)).size;
+    const fanOut = new Set(
+      calleeRows.filter((row) => row.file !== definition.relativePath).map((row) => `${row.symbol}|${row.file}`)
+    ).size;
+    const calleeCount = new Set(calleeRows.map((row) => `${row.symbol}|${row.file}`)).size;
+    return {
+      symbol: definition.symbol,
+      shortName: shortenSymbol(definition.symbol),
+      file: definition.relativePath,
+      startLine: definition.startLine,
+      endLine: definition.endLine,
+      loc,
+      fanIn,
+      fanOut,
+      calleeCount,
+      score: Math.round(loc / 50 * (fanIn / 5) * Math.max(fanOut / 5, 1) * 100) / 100
+    };
+  }).filter((row) => row.loc >= minLoc).sort((left, right) => right.score - left.score || right.loc - left.loc).slice(0, limit);
 }
 
 export {
   complexityHotspots
 };
-//# sourceMappingURL=chunk-VIYSWZCO.js.map
+//# sourceMappingURL=chunk-SL674KAW.js.map

package/dist/chunk-SRELHCMG.js

@@ -0,0 +1,110 @@
+import {
+  getInactiveBarrelPaths,
+  isEntrySurface
+} from "./chunk-X3J4VPWM.js";
+import {
+  TEST_FILE_PATTERNS,
+  TEST_SUPPORT_PATH_PATTERNS,
+  getAllDefinitions
+} from "./chunk-QGCEAVJD.js";
+import {
+  isFunctionLikeSymbol,
+  isModuleLikeSymbol,
+  shortenSymbol
+} from "./chunk-QIXNAB5K.js";
+
+// src/queries/dead.ts
+function dead(db, opts = {}) {
+  const {
+    scope,
+    minLoc = 1,
+    includeTests = false,
+    skipBarrels = false,
+    includeMembers = false
+  } = opts;
+  const inactiveBarrelPaths = skipBarrels ? new Set(getInactiveBarrelPaths(db)) : /* @__PURE__ */ new Set();
+  const referenceRows = db.all(
+    `SELECT
+      m.symbol_id,
+      d.relative_path,
+      COUNT(*) AS ref_count
+     FROM mentions m
+     JOIN chunks c ON m.chunk_id = c.id
+     JOIN documents d ON c.document_id = d.id
+     WHERE m.role != 1
+       ${db.pathExclusionsFor("d")}
+     GROUP BY m.symbol_id, d.relative_path`
+  );
+  const referencesBySymbol = /* @__PURE__ */ new Map();
+  for (const row of referenceRows) {
+    if (db.isIgnored(row.relative_path)) continue;
+    if (inactiveBarrelPaths.has(row.relative_path)) continue;
+    let refsForSymbol = referencesBySymbol.get(row.symbol_id);
+    if (!refsForSymbol) {
+      refsForSymbol = /* @__PURE__ */ new Map();
+      referencesBySymbol.set(row.symbol_id, refsForSymbol);
+    }
+    refsForSymbol.set(row.relative_path, row.ref_count);
+  }
+  const definitions = getAllDefinitions(db, { scope }).filter((definition) => !db.isIgnored(definition.relativePath)).filter((definition) => !isModuleLikeSymbol(definition.symbol)).filter((definition) => looksValueLikeDefinition(definition.symbol)).filter((definition) => definition.isFunctionLike || !definition.enclosingSymbol || !looksValueLikeDefinition(definition.enclosingSymbol)).filter((definition) => includeTests || passesTestFileFilter(definition.relativePath)).filter((definition) => includeMembers || looksValueLikeDefinition(definition.symbol)).filter((definition) => definition.endLine - definition.startLine + 1 >= minLoc);
+  const rows = definitions.map((definition) => {
+    const refMap = referencesBySymbol.get(definition.symbolId) ?? /* @__PURE__ */ new Map();
+    const sameFileRefs = refMap.get(definition.relativePath) ?? 0;
+    let crossFileRefs = 0;
+    for (const [relativePath, count] of refMap) {
+      if (relativePath === definition.relativePath) continue;
+      crossFileRefs += count;
+    }
+    return {
+      relative_path: definition.relativePath,
+      start_line: definition.startLine,
+      end_line: definition.endLine,
+      loc: definition.endLine - definition.startLine + 1,
+      symbol: definition.symbol,
+      same_file_refs: sameFileRefs,
+      cross_file_refs: crossFileRefs
+    };
+  }).filter((row) => row.cross_file_refs === 0).sort((a, b) => b.loc - a.loc || a.relative_path.localeCompare(b.relative_path) || a.start_line - b.start_line);
+  let deadCodeCount = 0;
+  let fileInternalCount = 0;
+  let totalLoc = 0;
+  const symbols = rows.filter((r) => !db.isIgnored(r.relative_path)).filter((r) => !isEntrySurface(db, r.relative_path)).map((r) => {
+    const kind = r.same_file_refs === 0 ? "dead-code" : "file-internal";
+    if (kind === "dead-code") deadCodeCount++;
+    else fileInternalCount++;
+    totalLoc += r.loc;
+    return {
+      relativePath: r.relative_path,
+      startLine: r.start_line,
+      endLine: r.end_line,
+      loc: r.loc,
+      symbol: r.symbol,
+      shortName: shortenSymbol(r.symbol),
+      sameFileRefs: r.same_file_refs,
+      kind
+    };
+  });
+  return {
+    symbols,
+    totalCount: symbols.length,
+    deadCodeCount,
+    fileInternalCount,
+    totalLoc
+  };
+}
+function passesTestFileFilter(relativePath) {
+  const patterns = [.../* @__PURE__ */ new Set([...TEST_FILE_PATTERNS, ...TEST_SUPPORT_PATH_PATTERNS])];
+  return patterns.every((pattern) => !likeMatches(relativePath, pattern));
+}
+function likeMatches(value, pattern) {
+  const regex = new RegExp(`^${pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/%/g, ".*").replace(/_/g, ".")}$`);
+  return regex.test(value);
+}
+function looksValueLikeDefinition(rawSymbol) {
+  return isFunctionLikeSymbol(rawSymbol) || rawSymbol.endsWith("().") || rawSymbol.endsWith(".");
+}
+
+export {
+  dead
+};
+//# sourceMappingURL=chunk-SRELHCMG.js.map

package/dist/chunk-UTRKBUCB.js

@@ -0,0 +1,87 @@
+import {
+  findExactSymbolMatch,
+  findFirstSymbolMatch,
+  getCallerRowsForSymbol
+} from "./chunk-QGCEAVJD.js";
+import {
+  shortenSymbol
+} from "./chunk-QIXNAB5K.js";
+
+// src/queries/affected.ts
+function affected(db, symbolPattern, opts = {}) {
+  const { maxDepth = 5, scope } = opts;
+  const target = findFirstSymbolMatch(db, symbolPattern);
+  if (!target) return [];
+  const results = [];
+  const visited = /* @__PURE__ */ new Set([target.symbolId]);
+  const seenResults = /* @__PURE__ */ new Set();
+  let frontier = [target];
+  for (let depth = 1; depth <= maxDepth; depth++) {
+    if (frontier.length === 0) break;
+    const nextFrontier = [];
+    for (const current of frontier) {
+      for (const row of getDirectAffectedRows(db, current, scope)) {
+        const resultKey = `${row.file}|${row.shortName}`;
+        if (row.symbolId !== null) {
+          if (visited.has(row.symbolId)) continue;
+          visited.add(row.symbolId);
+        } else if (seenResults.has(resultKey)) {
+          continue;
+        }
+        seenResults.add(resultKey);
+        results.push({
+          symbol: row.symbol,
+          shortName: row.shortName,
+          file: row.file,
+          depth
+        });
+        if (row.symbolId !== null && row.symbolMatch) {
+          nextFrontier.push(row.symbolMatch);
+        }
+      }
+    }
+    frontier = nextFrontier;
+  }
+  results.sort((a, b) => a.depth - b.depth || a.file.localeCompare(b.file));
+  return results;
+}
+function getDirectAffectedRows(db, target, scope) {
+  const callerRows = getCallerRowsForSymbol(db, target, { limit: 500 }).filter((row) => !db.isIgnored(row.file)).filter((row) => !scope || row.file.includes(scope));
+  const results = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const row of callerRows) {
+    const match = findExactSymbolMatch(db, row.symbol);
+    if (!match) {
+      const key2 = `${row.file}|${row.symbol}`;
+      if (seen.has(key2)) continue;
+      seen.add(key2);
+      results.push({
+        symbolId: null,
+        symbol: row.symbol,
+        shortName: shortenSymbol(row.symbol),
+        file: row.file,
+        symbolMatch: null
+      });
+      continue;
+    }
+    if (match.symbolId === target.symbolId || db.isIgnored(match.relativePath)) {
+      continue;
+    }
+    const key = `${match.symbolId}|${match.relativePath}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    results.push({
+      symbolId: match.symbolId,
+      symbol: match.symbol,
+      shortName: shortenSymbol(match.symbol),
+      file: match.relativePath,
+      symbolMatch: match
+    });
+  }
+  return results;
+}
+
+export {
+  affected
+};
+//# sourceMappingURL=chunk-UTRKBUCB.js.map

package/dist/{chunk-HJZUSUPU.js → chunk-VCOJRQPP.js}

@@ -1,7 +1,7 @@
 import {
   findFirstSymbolMatch,
   getCalleeRowsForSymbol
-} from "./chunk-AXQKUYKF.js";
+} from "./chunk-QGCEAVJD.js";
 import {
   shortenSymbol
 } from "./chunk-QIXNAB5K.js";
@@ -37,11 +37,11 @@ function convergence(db, symbolPatternA, symbolPatternB) {
   } else if (shared.length === 0) {
     strategy = "These functions do not share any callees. They are not a callee-based consolidation candidate.";
   } else if (uniqueA.length === 0 && uniqueB.length === 0) {
-    strategy = "These functions have identical callee sets. One can replace the other directly.";
+    strategy = "These functions have identical tracked callee sets. They are a strong structural match, but identical callees do not prove interchangeable semantics; inspect signatures, control flow, and return values before consolidating.";
   } else if (uniqueA.length === 0) {
-    strategy = `A is a subset of B. A can be replaced by calling B (B does everything A does plus more).`;
+    strategy = `A's tracked callees are a subset of B's. B may subsume part of A's structure, but verify signatures, guards, and non-call logic before replacing A with B.`;
   } else if (uniqueB.length === 0) {
-    strategy = `B is a subset of A. B can be replaced by calling A (A does everything B does plus more).`;
+    strategy = `B's tracked callees are a subset of A's. A may subsume part of B's structure, but verify signatures, guards, and non-call logic before replacing B with A.`;
   } else if (uniqueA.length <= 2 && uniqueB.length <= 2) {
     strategy = `Create a shared function with the ${shared.length} common callees. Pass the ${uniqueA.length + uniqueB.length} divergent callees as parameters or strategy callbacks.`;
   } else {
@@ -73,4 +73,4 @@ function convergence(db, symbolPatternA, symbolPatternB) {
 export {
   convergence
 };
-//# sourceMappingURL=chunk-HJZUSUPU.js.map
+//# sourceMappingURL=chunk-VCOJRQPP.js.map

package/dist/chunk-VISMEWYP.js

@@ -0,0 +1,34 @@
+import {
+  isEntrySurface
+} from "./chunk-X3J4VPWM.js";
+import {
+  getAllDefinitions,
+  getCalleeRowsForSymbol,
+  getCallerRowsForSymbol
+} from "./chunk-QGCEAVJD.js";
+import {
+  shortenSymbol
+} from "./chunk-QIXNAB5K.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-VISMEWYP.js.map

package/dist/{chunk-LFJQVJYJ.js → chunk-VU7FDTWV.js}

@@ -1,6 +1,6 @@
 import {
   buildFileDepGraph
-} from "./chunk-AXQKUYKF.js";
+} from "./chunk-QGCEAVJD.js";
 
 // src/queries/cycles.ts
 function cycles(db, opts = {}) {
@@ -58,4 +58,4 @@ function cycles(db, opts = {}) {
 export {
   cycles
 };
-//# sourceMappingURL=chunk-LFJQVJYJ.js.map
+//# sourceMappingURL=chunk-VU7FDTWV.js.map

package/dist/{chunk-HLUS2HEB.js → chunk-VUBLUTMU.js}

@@ -1,10 +1,11 @@
 import {
   buildFileDepGraph
-} from "./chunk-AXQKUYKF.js";
+} from "./chunk-QGCEAVJD.js";
 
 // src/queries/similar-files.ts
 function similarFiles(db, opts = {}) {
-  const { minSimilarity = 0.5, limit = 20, scope, minDeps = 3, filePattern } = opts;
+  const { minSimilarity = 0.5, limit = 20, scope, filePattern } = opts;
+  const minDeps = opts.minDeps ?? (filePattern ? 1 : 3);
   const profiles = buildFileProfiles(db, { scope, minDeps });
   const results = [];
   if (filePattern) {
@@ -53,7 +54,7 @@ function findUniversalDependencies(depMap) {
     }
   }
   for (const [dep, count] of depCounts) {
-    if (count / fileCount > 0.5) {
+    if (count >= 6 && count / fileCount > 0.8) {
       universalDeps.add(dep);
     }
   }
@@ -89,4 +90,4 @@ function compareProfiles(a, b, minSimilarity) {
 export {
   similarFiles
 };
-//# sourceMappingURL=chunk-HLUS2HEB.js.map
+//# sourceMappingURL=chunk-VUBLUTMU.js.map

package/dist/{chunk-WGAD3GNR.js → chunk-WNPF2I25.js}

@@ -1,6 +1,6 @@
 import {
   buildFileDepGraph
-} from "./chunk-AXQKUYKF.js";
+} from "./chunk-QGCEAVJD.js";
 
 // src/queries/similar-chains.ts
 function similarChains(db, opts = {}) {
@@ -28,8 +28,8 @@ function similarChains(db, opts = {}) {
       tailFreq.set(chain[t], (tailFreq.get(chain[t]) ?? 0) + 1);
     }
   }
-  const infraThreshold = rawChains.length * 0.4;
-  const tailThreshold = rawChains.length * 0.3;
+  const infraThreshold = rawChains.length * 0.9;
+  const tailThreshold = rawChains.length * 0.8;
   const infraNodes = /* @__PURE__ */ new Set();
   for (const [node, freq] of nodeFreq) {
     if (freq > infraThreshold) infraNodes.add(node);
@@ -45,7 +45,7 @@ function similarChains(db, opts = {}) {
   const filteredChains = [];
   for (const chain of rawChains) {
     const filtered = chain.filter((n) => !infraNodes.has(n));
-    if (filtered.length >= 3) {
+    if (filtered.length >= 2) {
       filteredChains.push({ original: chain, filtered });
     }
   }
@@ -210,4 +210,4 @@ function isSubChain(sub, full) {
 export {
   similarChains
 };
-//# sourceMappingURL=chunk-WGAD3GNR.js.map
+//# sourceMappingURL=chunk-WNPF2I25.js.map

package/dist/{chunk-YY4QGUQ5.js → chunk-X3J4VPWM.js}

@@ -1,6 +1,6 @@
 import {
   buildFileDepGraph
-} from "./chunk-AXQKUYKF.js";
+} from "./chunk-QGCEAVJD.js";
 
 // src/entry-surfaces.ts
 var liveBarrelCache = /* @__PURE__ */ new WeakMap();
@@ -81,4 +81,4 @@ export {
   isEntrySurface,
   getInactiveBarrelPaths
 };
-//# sourceMappingURL=chunk-YY4QGUQ5.js.map
+//# sourceMappingURL=chunk-X3J4VPWM.js.map

package/dist/{chunk-GSH2FPKV.js → chunk-XH56HXLC.js}

@@ -2,7 +2,7 @@ import {
   findFirstSymbolMatch,
   getCalleeRowsForSymbol,
   getSourceReferenceSites
-} from "./chunk-AXQKUYKF.js";
+} from "./chunk-QGCEAVJD.js";
 import {
   shortenSymbol
 } from "./chunk-QIXNAB5K.js";
@@ -84,4 +84,4 @@ function uniqueSymbolRows(rows) {
 export {
   dataflow
 };
-//# sourceMappingURL=chunk-GSH2FPKV.js.map
+//# sourceMappingURL=chunk-XH56HXLC.js.map

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

@@ -1,6 +1,6 @@
 import {
   buildFileDepGraph
-} from "./chunk-AXQKUYKF.js";
+} from "./chunk-QGCEAVJD.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-ZU2AQQB5.js.map