scip-query 0.3.4 → 0.4.0

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
@@ -487,31 +488,6 @@ scip-query isolated --scope src/utils
 
 ---
 
-#### `doc-coverage`
-
-Check what percentage of symbols have documentation strings. Lists undocumented symbols.
-
-```bash
-scip-query doc-coverage --min-loc 5
-# Documentation coverage: 78%
-#   Total symbols:   122
-#   Documented:      95
-#   Undocumented:    27
-#
-# Undocumented:
-#   src/utils/format.ts:15  formatCurrency
-#   src/utils/format.ts:28  formatDate
-```
-
-**Options:**
-- `-s, --scope <path>` — Limit to files matching path
-- `--min-loc <n>` — Minimum LOC to consider (default: 3)
-- `-n, --limit <n>` — Max undocumented symbols to show (default: 50)
-
-**Value:** Documentation health check. Focus efforts on the undocumented list.
-
----
-
 ### Codebase Metrics
 
 These commands measure structural properties of the codebase — hotspots, coupling, bottlenecks, fan-in/out.
@@ -1148,7 +1124,7 @@ scip-query similar-signatures --min-loc 5
 
 ## Programmatic API
 
-All 50 commands are available as TypeScript functions:
+All 49 commands are available as TypeScript functions:
 
 ```typescript
 import {

package/dist/{chunk-FYYOWQXK.js → chunk-2F2WH5WQ.js}

@@ -1,39 +1,39 @@
-import {
-  staleAbstractions
-} from "./chunk-P4WO3BBW.js";
 import {
   stats
 } from "./chunk-74RFWB5T.js";
 import {
   wrapperCandidates
-} from "./chunk-4JCSOF2O.js";
-import {
-  passthroughCandidates
-} from "./chunk-ZEUCXQBN.js";
+} from "./chunk-AS7N27JK.js";
 import {
   similarAll
-} from "./chunk-OIDHN6GD.js";
+} from "./chunk-I2JM34UV.js";
+import {
+  staleAbstractions
+} from "./chunk-5RKYZSQ6.js";
 import {
   isolated
-} from "./chunk-UQEQ6AHX.js";
+} from "./chunk-VISMEWYP.js";
+import {
+  passthroughCandidates
+} from "./chunk-5AJJGPZE.js";
 import {
   drift
-} from "./chunk-7KIMF5PV.js";
+} from "./chunk-HRDPUTIQ.js";
 import {
   extractCandidates
-} from "./chunk-EPWLXXBL.js";
+} from "./chunk-IV6NZ426.js";
 import {
   complexityHotspots
-} from "./chunk-VIYSWZCO.js";
+} from "./chunk-SL674KAW.js";
 import {
   cycles
-} from "./chunk-LFJQVJYJ.js";
+} from "./chunk-VU7FDTWV.js";
 import {
   dead
-} from "./chunk-LQJUPXQY.js";
+} from "./chunk-SRELHCMG.js";
 import {
   isEntrySurface
-} from "./chunk-YY4QGUQ5.js";
+} from "./chunk-X3J4VPWM.js";
 
 // src/queries/health.ts
 function health(db, opts = {}) {
@@ -57,20 +57,7 @@ function health(db, opts = {}) {
   const trueIsolatedCount = isolatedResult.filter(
     (s2) => !isEntrySurface(db, s2.relativePath)
   ).length;
-  const filesWithFunctions = new Set(
-    db.all(
-      `SELECT DISTINCT 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 gs.symbol LIKE '%().'
-         ${db.pathExclusionsFor("d")}`
-    ).map((r) => r.relative_path)
-  );
-  const trueStaleCount = staleResult.filter((s2) => {
-    if (s2.consumers === 0 && filesWithFunctions.has(s2.file)) return false;
-    return true;
-  }).length;
+  const trueStaleCount = staleResult.length;
   const trueDriftCount = driftResult.results.length;
   const trueSimilarCount = similarResult.length;
   const actions = [];
@@ -145,11 +132,7 @@ function health(db, opts = {}) {
     });
   }
   if (trueStaleCount > 0) {
-    const trueStaleSymbols = staleResult.filter((s2) => {
-      if (s2.consumers === 0 && filesWithFunctions.has(s2.file)) return false;
-      return true;
-    });
-    const unused = trueStaleSymbols.filter((s2) => s2.consumers === 0).length;
+    const unused = staleResult.filter((s2) => s2.consumers === 0).length;
     const singleUse = trueStaleCount - unused;
     const parts = [];
     if (unused > 0) parts.push(`${unused} unused`);
@@ -160,7 +143,7 @@ function health(db, opts = {}) {
       effort: "low",
       impact: "medium",
       count: trueStaleCount,
-      locRecoverable: staleResult.filter((s2) => s2.consumers === 0 || !s2.file.includes("types")).reduce((sum, r) => sum + r.loc, 0)
+      locRecoverable: staleResult.reduce((sum, r) => sum + r.loc, 0)
     });
   }
   if (trueDriftCount > 0) {
@@ -235,4 +218,4 @@ function health(db, opts = {}) {
 export {
   health
 };
-//# sourceMappingURL=chunk-FYYOWQXK.js.map
+//# sourceMappingURL=chunk-2F2WH5WQ.js.map

package/dist/{chunk-C7H5WBTJ.js → chunk-2UISVZGQ.js}

@@ -2,7 +2,7 @@ import {
   findFirstSymbolMatch,
   getCalleeRowsForSymbol,
   getCallerRowsForSymbol
-} from "./chunk-AXQKUYKF.js";
+} from "./chunk-QGCEAVJD.js";
 import {
   shortenSymbol
 } from "./chunk-QIXNAB5K.js";
@@ -43,4 +43,4 @@ function uniqueRows(rows) {
 export {
   callGraph
 };
-//# sourceMappingURL=chunk-C7H5WBTJ.js.map
+//# sourceMappingURL=chunk-2UISVZGQ.js.map

package/dist/{chunk-HLKAFWWJ.js → chunk-4ZT7UGWW.js}

@@ -1,3 +1,6 @@
+import {
+  getAllDefinitions
+} from "./chunk-QGCEAVJD.js";
 import {
   leafSuffix,
   parseSymbol,
@@ -115,102 +118,26 @@ function byKind(db, kindQuery, opts = {}) {
   if (kindNum === null) {
     return [];
   }
-  const scopeFilter = scope ? `AND d.relative_path LIKE '%${scope}%'` : "";
-  const hasKinds = db.get(
-    `SELECT COUNT(*) AS c FROM global_symbols WHERE kind IS NOT NULL`
-  );
-  if (!hasKinds || hasKinds.c === 0) {
-    return inferByKind(db, kindNum, scope, limit);
-  }
-  const rows = db.all(
-    `SELECT gs.symbol, gs.kind, d.relative_path, der.start_line, der.end_line
-    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.kind = ?
-      ${db.pathExclusionsFor("d")}
-      ${scopeFilter}
-    ORDER BY d.relative_path, der.start_line
-    LIMIT ?`,
-    kindNum,
-    limit
-  );
-  return rows.filter((r) => !db.isIgnored(r.relative_path)).map((r) => ({
-    symbol: r.symbol,
-    shortName: shortenSymbol(r.symbol),
-    kind: r.kind,
-    kindName: KIND_NAMES[r.kind] ?? "Unknown",
-    relativePath: r.relative_path,
-    startLine: r.start_line,
-    endLine: r.end_line
-  }));
-}
-function kindCounts(db, opts = {}) {
-  const scopeFilter = opts.scope ? `AND d.relative_path LIKE '%${opts.scope}%'` : "";
-  const rows = db.all(
-    `SELECT gs.kind, COUNT(*) AS cnt
-    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")}
-      AND gs.kind IS NOT NULL
-      AND gs.kind != 0
-      ${scopeFilter}
-    GROUP BY gs.kind
-    ORDER BY cnt DESC`
-  );
-  if (rows.length === 0) {
-    return inferKindCounts(db, opts.scope);
-  }
-  return rows.map((r) => ({
-    kind: r.kind,
-    kindName: KIND_NAMES[r.kind] ?? "Unknown",
-    count: r.cnt
-  }));
-}
-function inferByKind(db, kindNum, scope, limit = 100) {
-  const scopeFilter = scope ? `AND d.relative_path LIKE '%${scope}%'` : "";
-  const rows = db.all(
-    `SELECT gs.symbol, d.relative_path, der.start_line, der.end_line, gs.documentation, gs.enclosing_symbol
-     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")}
-       ${scopeFilter}
-     ORDER BY d.relative_path, der.start_line`
-  );
-  return rows.filter((row) => !db.isIgnored(row.relative_path)).map((row) => ({
+  const rows = loadKindRows(db, scope).map((row) => ({
     row,
-    inferredKind: inferKindNumber(row.symbol, row.documentation, row.enclosing_symbol)
-  })).filter((entry) => entry.inferredKind === kindNum).slice(0, limit).map(({ row, inferredKind }) => ({
+    resolvedKind: resolveKindNumber(row)
+  })).filter((entry) => entry.resolvedKind === kindNum).slice(0, limit);
+  return rows.map(({ row, resolvedKind }) => ({
     symbol: row.symbol,
     shortName: shortenSymbol(row.symbol),
-    kind: inferredKind,
-    kindName: KIND_NAMES[inferredKind] ?? "Unknown",
+    kind: resolvedKind,
+    kindName: KIND_NAMES[resolvedKind] ?? "Unknown",
     relativePath: row.relative_path,
     startLine: row.start_line,
     endLine: row.end_line
   }));
 }
-function inferKindCounts(db, scope) {
-  const scopeFilter = scope ? `AND d.relative_path LIKE '%${scope}%'` : "";
-  const rows = db.all(
-    `SELECT gs.symbol, gs.documentation, gs.enclosing_symbol, 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")}
-       ${scopeFilter}`
-  );
+function kindCounts(db, opts = {}) {
   const counts = /* @__PURE__ */ new Map();
-  for (const row of rows) {
-    if (db.isIgnored(row.relative_path)) continue;
-    const inferred = inferKindNumber(row.symbol, row.documentation, row.enclosing_symbol);
-    if (inferred === null || inferred === 0) continue;
-    counts.set(inferred, (counts.get(inferred) ?? 0) + 1);
+  for (const row of loadKindRows(db, opts.scope)) {
+    const kind = resolveKindNumber(row);
+    if (kind === null || kind === 0) continue;
+    counts.set(kind, (counts.get(kind) ?? 0) + 1);
   }
   return [...counts.entries()].sort((a, b) => b[1] - a[1] || a[0] - b[0]).map(([kind, count]) => ({
     kind,
@@ -218,22 +145,60 @@ function inferKindCounts(db, scope) {
     count
   }));
 }
+function loadKindRows(db, scope) {
+  return getAllDefinitions(db, { scope }).map(mapDefinitionToKindRow);
+}
+function mapDefinitionToKindRow(definition) {
+  return {
+    symbol: definition.symbol,
+    kind: definition.kind,
+    documentation: definition.documentation,
+    enclosing_symbol: definition.enclosingSymbol,
+    relative_path: definition.relativePath,
+    start_line: definition.startLine,
+    end_line: definition.endLine
+  };
+}
+function resolveKindNumber(row) {
+  if (row.kind !== null && row.kind !== 0) {
+    return normalizeIndexedKind(row.kind, row.symbol, row.documentation);
+  }
+  return inferKindNumber(row.symbol, row.documentation, row.enclosing_symbol);
+}
+function normalizeIndexedKind(kind, symbol, documentation) {
+  const signature = (documentation ?? "").toLowerCase();
+  const suffix = leafSuffix(symbol);
+  if (suffix === "type") {
+    if (signature.includes("type ")) return 76;
+    if (signature.includes("interface ")) return 27;
+    if (signature.includes("struct ")) return 68;
+    if (signature.includes("trait ")) return 73;
+    if (signature.includes("class ")) return 9;
+  }
+  return kind;
+}
 function inferKindNumber(symbol, documentation, enclosingSymbol) {
   const parsed = parseSymbol(symbol);
   if ("kind" in parsed) {
     return null;
   }
   const descriptors = parsed.descriptors;
-  const last = descriptors[descriptors.length - 1] ?? null;
   const parent = descriptors[descriptors.length - 2] ?? null;
   const suffix = leafSuffix(symbol);
-  if (suffix === "type") return 9;
+  const signature = (documentation ?? "").toLowerCase();
+  if (suffix === "type") {
+    if (signature.includes("type ")) return 76;
+    if (signature.includes("interface ")) return 27;
+    if (signature.includes("struct ")) return 68;
+    if (signature.includes("trait ")) return 73;
+    if (signature.includes("class ")) return 9;
+    return 9;
+  }
   if (suffix === "method") {
     return parent?.suffix === "type" ? 33 : 23;
   }
   if (suffix === "namespace") return 39;
   if (suffix !== "term") return null;
-  const signature = (documentation ?? "").toLowerCase();
   if (signature.includes("async def ") || signature.includes("def ")) {
     return 23;
   }
@@ -248,4 +213,4 @@ export {
   byKind,
   kindCounts
 };
-//# sourceMappingURL=chunk-HLKAFWWJ.js.map
+//# sourceMappingURL=chunk-4ZT7UGWW.js.map

package/dist/chunk-5AJJGPZE.js

@@ -0,0 +1,60 @@
+import {
+  getCalleeRowsForSymbol,
+  getDefinitionsForFile
+} from "./chunk-QGCEAVJD.js";
+import {
+  isFunctionLikeSymbol,
+  shortenSymbol
+} from "./chunk-QIXNAB5K.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-5AJJGPZE.js.map

package/dist/chunk-5RKYZSQ6.js

@@ -0,0 +1,75 @@
+import {
+  getDefinitionsForFile
+} from "./chunk-QGCEAVJD.js";
+import {
+  shortenSymbol
+} from "./chunk-QIXNAB5K.js";
+
+// src/queries/stale-abstractions.ts
+function staleAbstractions(db, opts) {
+  const { scope, minLoc = 3, limit = 30 } = opts ?? {};
+  const rows = getScopedDefinitions(db, scope).filter((definition) => definition.isTypeLike && definitionLoc(definition) >= minLoc).map((definition) => ({
+    symbol: definition.symbol,
+    file: definition.relativePath,
+    start_line: definition.startLine,
+    end_line: definition.endLine,
+    loc: definitionLoc(definition),
+    consumers: countCrossFileConsumers(db, definition)
+  })).filter((row) => row.consumers <= 1).sort((left, right) => right.loc - left.loc || left.file.localeCompare(right.file) || left.start_line - right.start_line);
+  const filesWithFunctions = getFilesWithFunctions(db, scope);
+  return rows.filter((r) => !db.isIgnored(r.file)).filter((r) => isTrueStaleAbstraction(r, filesWithFunctions)).map((r) => ({
+    symbol: r.symbol,
+    shortName: shortenSymbol(r.symbol),
+    file: r.file,
+    startLine: r.start_line,
+    endLine: r.end_line,
+    loc: r.loc,
+    consumers: r.consumers
+  })).slice(0, limit);
+}
+function getFilesWithFunctions(db, scope) {
+  return new Set(getScopedDefinitions(db, scope).filter((definition) => definition.isFunctionLike).map((definition) => definition.relativePath));
+}
+function isTrueStaleAbstraction(row, filesWithFunctions) {
+  const basename = row.file.split("/").pop() ?? "";
+  const isTypeFile = basename.includes("types") || row.file.includes("/types/");
+  if (isTypeFile && row.consumers > 0) {
+    return false;
+  }
+  if (row.consumers === 0 && filesWithFunctions.has(row.file)) {
+    return false;
+  }
+  return true;
+}
+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 countCrossFileConsumers(db, definition) {
+  const callers = db.all(
+    `SELECT DISTINCT d.relative_path
+     FROM mentions m
+     JOIN chunks c ON m.chunk_id = c.id
+     JOIN documents d ON c.document_id = d.id
+     WHERE m.symbol_id = ?
+       AND m.role != 1
+       ${db.pathExclusionsFor("d")}`,
+    definition.symbolId
+  ).map((row) => row.relative_path).filter((relativePath) => relativePath !== definition.relativePath && !db.isIgnored(relativePath));
+  return new Set(callers).size;
+}
+function definitionLoc(definition) {
+  return definition.endLine - definition.startLine + 1;
+}
+
+export {
+  staleAbstractions
+};
+//# sourceMappingURL=chunk-5RKYZSQ6.js.map

package/dist/chunk-7YBLWIXY.js

@@ -0,0 +1,115 @@
+import {
+  findFirstSymbolMatch,
+  getSourceReferenceSites,
+  getSourceText
+} from "./chunk-QGCEAVJD.js";
+import {
+  isFunctionLikeSymbol
+} from "./chunk-QIXNAB5K.js";
+
+// src/queries/refs.ts
+function refs(db, symbolPattern) {
+  const match = findFirstSymbolMatch(db, symbolPattern);
+  if (match) {
+    const includeDefinitionSite = !isFunctionLikeSymbol(match.symbol);
+    const definitionRows = includeDefinitionSite ? [{
+      relativePath: match.relativePath,
+      line: match.startLine
+    }] : [];
+    const sourceSites = getSourceReferenceSites(db, match).filter((site) => !db.isIgnored(site.file)).map((site) => ({
+      relativePath: site.file,
+      line: site.line
+    }));
+    if (sourceSites.length > 0) {
+      const seen2 = /* @__PURE__ */ new Set();
+      const rows2 = [...definitionRows, ...sourceSites, ...getRubySemanticRefs(db, match)].filter((site) => {
+        const key = `${site.relativePath}:${site.line}`;
+        if (seen2.has(key)) return false;
+        seen2.add(key);
+        return true;
+      });
+      return rows2;
+    }
+  }
+  const rows = db.all(
+    `SELECT DISTINCT d.relative_path, c.start_line
+    FROM mentions m
+    JOIN chunks c ON m.chunk_id = c.id
+    JOIN documents d ON c.document_id = d.id
+    JOIN global_symbols gs ON m.symbol_id = gs.id
+    WHERE m.symbol_id = ?
+      AND ${db.localSymbolPredicate}
+      AND m.role != 1
+    ORDER BY d.relative_path, c.start_line`,
+    match?.symbolId ?? -1
+  );
+  const referenceRows = rows.filter((r) => !db.isIgnored(r.relative_path)).map((r) => ({
+    relativePath: r.relative_path,
+    line: r.start_line
+  }));
+  if (!match || db.isIgnored(match.relativePath) || isFunctionLikeSymbol(match.symbol)) {
+    return referenceRows;
+  }
+  const seen = new Set(referenceRows.map((row) => `${row.relativePath}:${row.line}`));
+  if (!seen.has(`${match.relativePath}:${match.startLine}`)) {
+    referenceRows.unshift({
+      relativePath: match.relativePath,
+      line: match.startLine
+    });
+  }
+  for (const row of getRubySemanticRefs(db, match)) {
+    const key = `${row.relativePath}:${row.line}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    referenceRows.push(row);
+  }
+  return referenceRows;
+}
+function getRubySemanticRefs(db, match) {
+  if (!match.relativePath.endsWith(".rb")) {
+    return [];
+  }
+  const tokens = rubyReferenceTokens(match.symbol);
+  if (tokens.length === 0) {
+    return [];
+  }
+  const rows = db.all(
+    `SELECT relative_path
+     FROM documents
+     WHERE relative_path LIKE '%.rb'
+       ${db.pathExclusionsFor("documents")}
+     ORDER BY relative_path`
+  );
+  const results = [];
+  for (const row of rows) {
+    if (db.isIgnored(row.relative_path)) continue;
+    const source = getSourceText(db, row.relative_path);
+    if (!source) continue;
+    const lines = source.split("\n");
+    for (let index = 0; index < lines.length; index++) {
+      const line = lines[index] ?? "";
+      if (tokens.some((token) => new RegExp(`@${token}\\b|\\b${token}:`).test(line))) {
+        results.push({
+          relativePath: row.relative_path,
+          line: index
+        });
+      }
+    }
+  }
+  return results;
+}
+function rubyReferenceTokens(rawSymbol) {
+  const leaf = rawSymbol.split(":").pop() ?? rawSymbol;
+  const snake = leaf.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[^A-Za-z0-9_]+/g, "_").toLowerCase().replace(/^_+|_+$/g, "");
+  const parts = snake.split("_").filter(Boolean);
+  const candidates = /* @__PURE__ */ new Set();
+  if (snake) candidates.add(snake);
+  if (parts.length >= 1) candidates.add(parts[parts.length - 1]);
+  if (parts.length >= 2) candidates.add(parts.slice(-2).join("_"));
+  return [...candidates];
+}
+
+export {
+  refs
+};
+//# sourceMappingURL=chunk-7YBLWIXY.js.map

package/dist/{chunk-O7Q7FDUJ.js → chunk-A4GWYETB.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-4TYLS5XX.js";
 import {
   resolveIndexedPaths
-} from "./chunk-AXQKUYKF.js";
+} from "./chunk-QGCEAVJD.js";
 import {
   shortenSymbol
 } from "./chunk-QIXNAB5K.js";
@@ -79,4 +79,4 @@ function system(db, modulePattern) {
 export {
   system
 };
-//# sourceMappingURL=chunk-O7Q7FDUJ.js.map
+//# sourceMappingURL=chunk-A4GWYETB.js.map

package/dist/{chunk-CHDJXYBG.js → chunk-A5BGEBM7.js}

@@ -1,7 +1,7 @@
 import {
   findFirstSymbolMatch,
   getCalleeRowsForSymbol
-} from "./chunk-AXQKUYKF.js";
+} from "./chunk-QGCEAVJD.js";
 import {
   shortenSymbol
 } from "./chunk-QIXNAB5K.js";
@@ -97,4 +97,4 @@ function forwardSlice(db, match) {
 export {
   slice
 };
-//# sourceMappingURL=chunk-CHDJXYBG.js.map
+//# sourceMappingURL=chunk-A5BGEBM7.js.map

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

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