scip-query 0.5.0 → 0.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scip-query",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Language-agnostic code intelligence CLI powered by SCIP indexes",
   "type": "module",
   "main": "dist/index.js",
@@ -66,9 +66,27 @@
     "commander": "^13.1.0",
     "ignore": "^7.0.3"
   },
+  "//optionalDependencies": "Native parsers and bundled SCIP indexers go in optionalDependencies so a failed install (missing build tools, restricted registry, incompatible platform) downgrades scip-query gracefully — the affected language falls back to regex parsing or asks the user to install its indexer manually — instead of blocking npm install.",
+  "optionalDependencies": {
+    "@sourcegraph/scip-typescript": "^0.4.0",
+    "scip-python-plus": "^0.7.4",
+    "tree-sitter": "^0.22.4",
+    "tree-sitter-c": "^0.21.4",
+    "tree-sitter-c-sharp": "^0.21.3",
+    "tree-sitter-cpp": "^0.22.3",
+    "tree-sitter-java": "^0.21.0",
+    "tree-sitter-javascript": "^0.23.1",
+    "tree-sitter-kotlin": "^0.3.8",
+    "tree-sitter-php": "^0.23.11",
+    "tree-sitter-python": "^0.23.6",
+    "tree-sitter-ruby": "^0.23.1",
+    "tree-sitter-rust": "^0.23.3",
+    "tree-sitter-scala": "^0.24.0",
+    "tree-sitter-typescript": "^0.23.2",
+    "tree-sitter-vb-dotnet": "^0.1.9"
+  },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
-    "@sourcegraph/scip-typescript": "^0.4.0",
     "@types/better-sqlite3": "^7.6.12",
     "@types/node": "^22.10.0",
     "eslint": "^10.2.0",

package/dist/chunk-2MQ5DPY6.js

@@ -1,61 +0,0 @@
-import {
-  buildFileDepGraph
-} from "./chunk-OMCRXXDX.js";
-
-// src/queries/cycles.ts
-function cycles(db, opts = {}) {
-  const { scope, maxDepth = 10 } = opts;
-  const graph = buildFileDepGraph(db, scope);
-  const allCycles = [];
-  const visited = /* @__PURE__ */ new Set();
-  const inStack = /* @__PURE__ */ new Set();
-  const stack = [];
-  function dfs(node, depth) {
-    if (depth > maxDepth) return;
-    if (inStack.has(node)) {
-      const cycleStart = stack.indexOf(node);
-      if (cycleStart !== -1) {
-        const cyclePath = stack.slice(cycleStart).concat(node);
-        const minIdx = cyclePath.indexOf(
-          cyclePath.reduce((a, b) => a < b ? a : b)
-        );
-        const normalized = [
-          ...cyclePath.slice(minIdx, -1),
-          ...cyclePath.slice(0, minIdx),
-          cyclePath[minIdx]
-        ];
-        const key = normalized.join(" -> ");
-        if (!seenCycles.has(key)) {
-          seenCycles.add(key);
-          allCycles.push({ path: normalized });
-        }
-      }
-      return;
-    }
-    if (visited.has(node)) return;
-    visited.add(node);
-    inStack.add(node);
-    stack.push(node);
-    const neighbors = graph.get(node);
-    if (neighbors) {
-      for (const neighbor of neighbors) {
-        dfs(neighbor, depth + 1);
-      }
-    }
-    stack.pop();
-    inStack.delete(node);
-  }
-  const seenCycles = /* @__PURE__ */ new Set();
-  for (const node of graph.keys()) {
-    if (!visited.has(node)) {
-      dfs(node, 0);
-    }
-  }
-  allCycles.sort((a, b) => a.path.length - b.path.length);
-  return allCycles;
-}
-
-export {
-  cycles
-};
-//# sourceMappingURL=chunk-2MQ5DPY6.js.map

package/dist/chunk-2QTYIOJ5.js

@@ -1,165 +0,0 @@
-import {
-  buildFileDepGraph
-} from "./chunk-OMCRXXDX.js";
-
-// src/queries/drift.ts
-import path from "path";
-function drift(db, opts) {
-  const { scope } = opts ?? {};
-  const depGraph = buildFileDepGraph(db, scope);
-  const symbolRefs = buildSymbolRefGraph(db, scope);
-  const results = [];
-  for (const [file, deps] of depGraph) {
-    if (shouldSkipDriftFile(file)) continue;
-    const referencedFiles = symbolRefs.get(file) ?? /* @__PURE__ */ new Set();
-    for (const dep of deps) {
-      if (shouldSkipDriftFile(dep)) continue;
-      if (!referencedFiles.has(dep)) {
-        if (isLikelyTypeOnlyDep(dep)) continue;
-        results.push({
-          file,
-          kind: "unused-import",
-          description: `Depends on ${dep} but references none of its symbols`,
-          dep
-        });
-      }
-    }
-  }
-  const layerRules = inferLayerRules(depGraph);
-  for (const [file, deps] of depGraph) {
-    if (shouldSkipDriftFile(file)) continue;
-    const fileLayer = getArchitecturalLayer(file);
-    for (const dep of deps) {
-      if (shouldSkipDriftFile(dep)) continue;
-      const depLayer = getArchitecturalLayer(dep);
-      if (fileLayer === depLayer) continue;
-      const violation = layerRules.get(`${fileLayer}->${depLayer}`);
-      if (violation === "violation") {
-        results.push({
-          file,
-          kind: "layer-violation",
-          description: `Imports from ${depLayer}/ (${dep}) \u2014 may cross architectural boundary`,
-          dep,
-          detail: `${fileLayer}/ should not depend on ${depLayer}/`
-        });
-      }
-    }
-  }
-  const dirToFiles = /* @__PURE__ */ new Map();
-  for (const file of depGraph.keys()) {
-    const dir = path.dirname(file);
-    if (!dirToFiles.has(dir)) dirToFiles.set(dir, []);
-    dirToFiles.get(dir).push(file);
-  }
-  for (const [dir, files] of dirToFiles) {
-    if (files.length < 3) continue;
-    const depFreq = /* @__PURE__ */ new Map();
-    for (const file of files) {
-      if (shouldSkipDriftFile(file)) continue;
-      for (const dep of depGraph.get(file) ?? []) {
-        if (shouldSkipDriftFile(dep)) continue;
-        depFreq.set(dep, (depFreq.get(dep) ?? 0) + 1);
-      }
-    }
-    for (const file of files) {
-      if (shouldSkipDriftFile(file)) continue;
-      for (const dep of depGraph.get(file) ?? []) {
-        if (shouldSkipDriftFile(dep)) continue;
-        if ((depFreq.get(dep) ?? 0) === 1) {
-          if (path.dirname(dep) === dir) continue;
-          results.push({
-            file,
-            kind: "pattern-deviation",
-            description: `Only file in ${dir}/ that depends on ${dep}`,
-            dep
-          });
-        }
-      }
-    }
-  }
-  return {
-    results,
-    unusedImports: results.filter((r) => r.kind === "unused-import").length,
-    layerViolations: results.filter((r) => r.kind === "layer-violation").length,
-    patternDeviations: results.filter((r) => r.kind === "pattern-deviation").length
-  };
-}
-function buildSymbolRefGraph(db, scope) {
-  const scopeFilter = scope ? `AND d1.relative_path LIKE '%${scope}%'` : "";
-  const rows = db.all(
-    `SELECT DISTINCT d1.relative_path AS from_file, d2.relative_path AS to_file
-    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
-    JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
-    JOIN documents d2 ON der.document_id = d2.id
-    WHERE d1.id != d2.id
-      AND m.role != 1
-      ${db.pathExclusionsFor("d1", "d2")}
-      ${scopeFilter}`
-  );
-  const graph = /* @__PURE__ */ new Map();
-  for (const r of rows) {
-    if (db.isIgnored(r.from_file) || db.isIgnored(r.to_file)) continue;
-    if (!graph.has(r.from_file)) graph.set(r.from_file, /* @__PURE__ */ new Set());
-    graph.get(r.from_file).add(r.to_file);
-  }
-  return graph;
-}
-function inferLayerRules(depGraph) {
-  const layerEdges = /* @__PURE__ */ new Map();
-  const layerSet = /* @__PURE__ */ new Set();
-  for (const [file, deps] of depGraph) {
-    if (shouldSkipDriftFile(file)) continue;
-    const fromLayer = getArchitecturalLayer(file);
-    layerSet.add(fromLayer);
-    for (const dep of deps) {
-      if (shouldSkipDriftFile(dep)) continue;
-      const toLayer = getArchitecturalLayer(dep);
-      if (fromLayer === toLayer) continue;
-      layerSet.add(toLayer);
-      const key = `${fromLayer}->${toLayer}`;
-      layerEdges.set(key, (layerEdges.get(key) ?? 0) + 1);
-    }
-  }
-  const rules = /* @__PURE__ */ new Map();
-  for (const [edge, count] of layerEdges) {
-    rules.set(edge, count <= 2 ? "violation" : "ok");
-  }
-  return rules;
-}
-function getArchitecturalLayer(filePath) {
-  const normalized = filePath.replace(/\\/g, "/");
-  const parts = normalized.split("/").filter(Boolean);
-  if (parts.length <= 1) {
-    return "(root)";
-  }
-  if (parts.length >= 3 && ["src", "lib", "app", "server", "client"].includes(parts[0])) {
-    return `${parts[0]}/${parts[1]}`;
-  }
-  return parts[0];
-}
-function isLikelyTypeOnlyDep(dep) {
-  return dep.includes("types") || dep.endsWith(".d.ts");
-}
-function shouldSkipDriftFile(filePath) {
-  return isStructuralRole(path.basename(filePath)) || isTestLikePath(filePath);
-}
-function isStructuralRole(basename) {
-  if (basename === "index.ts" || basename === "index.js") return true;
-  if (basename === "cli.ts" || basename === "main.ts" || basename === "main.rs") return true;
-  if (basename.includes("worker.") || basename.includes("postinstall.")) return true;
-  if (basename === "health.ts" || basename === "health.js") return true;
-  return false;
-}
-function isTestLikePath(filePath) {
-  const normalized = filePath.replace(/\\/g, "/");
-  const basename = path.basename(normalized);
-  return normalized.includes("/__tests__/") || normalized.includes("/tests/") || normalized.includes("/test/") || /\.(test|spec)\.[A-Za-z0-9]+$/.test(basename) || /_(test|spec)\.[A-Za-z0-9]+$/.test(basename) || /^test[_-]/.test(basename) || /^test\./.test(basename);
-}
-
-export {
-  drift
-};
-//# sourceMappingURL=chunk-2QTYIOJ5.js.map

package/dist/chunk-3VI4YXCL.js

@@ -1,172 +0,0 @@
-import {
-  findFirstSymbolMatch,
-  getSourceImports,
-  resolveIndexedFile
-} from "./chunk-OMCRXXDX.js";
-import {
-  isModuleLikeSymbol,
-  leafName,
-  shortenSymbol
-} from "./chunk-YMSJCSRG.js";
-
-// src/queries/imports.ts
-function imports(db, filePattern) {
-  const importer = resolveIndexedFile(db, filePattern);
-  if (!importer) return [];
-  const rows = db.all(
-    `SELECT DISTINCT gs.symbol, def_d.relative_path AS from_file, imp_d.relative_path AS importer
-    FROM mentions m
-    JOIN chunks c ON m.chunk_id = c.id
-    JOIN documents imp_d ON c.document_id = imp_d.id
-    JOIN global_symbols gs ON m.symbol_id = gs.id
-    LEFT JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
-    LEFT JOIN documents def_d ON der.document_id = def_d.id
-    WHERE imp_d.relative_path = ?
-      AND m.role = 2
-    ORDER BY def_d.relative_path, gs.symbol`,
-    importer
-  );
-  const indexedResults = rows.filter((row) => !db.isIgnored(row.importer)).map((r) => ({
-    symbol: r.symbol,
-    shortName: shortenSymbol(r.symbol),
-    fromFile: r.from_file ?? "(external)"
-  }));
-  if (indexedResults.length > 0) {
-    return indexedResults;
-  }
-  return getSourceImports(db, importer).map((entry) => ({
-    symbol: renderImportSymbol(entry.importedName, entry.localName, entry.kind),
-    shortName: renderImportSymbol(entry.importedName, entry.localName, entry.kind),
-    fromFile: entry.sourcePath ?? "(external)"
-  }));
-}
-function importedBy(db, symbolPattern) {
-  const rows = db.all(
-    `SELECT DISTINCT gs.symbol, d.relative_path AS importer
-    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 gs.symbol LIKE ?
-      AND m.role = 2
-    ORDER BY d.relative_path`,
-    `%${symbolPattern}%`
-  );
-  const indexedResults = rows.filter((r) => !db.isIgnored(r.importer)).map((r) => ({
-    symbol: r.symbol,
-    shortName: shortenSymbol(r.symbol),
-    fromFile: r.importer
-  }));
-  if (indexedResults.length > 0) {
-    return indexedResults;
-  }
-  const target = findFirstSymbolMatch(db, symbolPattern);
-  const targetFile = target?.relativePath ?? null;
-  const targetLeaf = target ? leafName(target.symbol) : symbolPattern.replace(/\(\)$/, "");
-  const targetIsModule = target ? isModuleLikeSymbol(target.symbol) : false;
-  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)) continue;
-    for (const entry of getSourceImports(db, row.relative_path)) {
-      if (!entry.sourcePath) continue;
-      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;
-      }
-      if (entry.kind === "named" && entry.importedName === targetLeaf) {
-        importers.add(row.relative_path);
-        continue;
-      }
-      if (entry.kind === "namespace" && entry.usedMembers.includes(targetLeaf)) {
-        importers.add(row.relative_path);
-      }
-    }
-  }
-  return [...importers].sort().map((importer) => ({
-    symbol: target?.symbol ?? targetLeaf,
-    shortName: target ? shortenSymbol(target.symbol) : targetLeaf,
-    fromFile: importer
-  }));
-}
-function unusedImports(db, filePattern) {
-  const importer = resolveIndexedFile(db, filePattern);
-  if (!importer) return [];
-  const rows = db.all(
-    `SELECT gs.symbol, d.relative_path AS imported_in, d.relative_path AS importer
-    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 d.relative_path = ?
-      AND m.role = 2
-      AND NOT EXISTS (
-        SELECT 1
-        FROM mentions ref_m
-        JOIN chunks ref_c ON ref_m.chunk_id = ref_c.id
-        WHERE ref_m.symbol_id = gs.id
-          AND ref_m.role != 1
-          AND ref_c.document_id = d.id
-      )
-    ORDER BY d.relative_path, gs.symbol`,
-    importer
-  );
-  const indexedResults = rows.filter((row) => !db.isIgnored(row.importer)).map((r) => ({
-    symbol: r.symbol,
-    shortName: shortenSymbol(r.symbol),
-    importedIn: r.imported_in
-  }));
-  if (indexedResults.length > 0) {
-    return indexedResults;
-  }
-  return getSourceImports(db, importer).filter((entry) => entry.kind !== "side-effect" && !entry.used).map((entry) => ({
-    symbol: renderImportSymbol(entry.importedName, entry.localName, entry.kind),
-    shortName: renderImportSymbol(entry.importedName, entry.localName, entry.kind),
-    importedIn: importer
-  }));
-}
-function renderImportSymbol(importedName, localName, kind) {
-  if (kind === "namespace" && importedName === "*" && localName) {
-    return `* as ${localName}`;
-  }
-  if (kind === "default" && localName) {
-    return `default as ${localName}`;
-  }
-  if (kind === "side-effect") {
-    return "(side effect import)";
-  }
-  if (localName && localName !== importedName) {
-    return `${importedName} as ${localName}`;
-  }
-  return importedName;
-}
-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-3VI4YXCL.js.map

package/dist/chunk-3VV2G6U7.js

@@ -1,34 +0,0 @@
-import {
-  isEntrySurface
-} from "./chunk-UGS7HJI4.js";
-import {
-  getAllDefinitions,
-  getCalleeRowsForSymbol,
-  getCallerRowsForSymbol
-} from "./chunk-OMCRXXDX.js";
-import {
-  shortenSymbol
-} from "./chunk-YMSJCSRG.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-3VV2G6U7.js.map

package/dist/chunk-44PFXVXG.js

@@ -1,76 +0,0 @@
-import {
-  findFirstSymbolMatch,
-  getCalleeRowsForSymbol
-} from "./chunk-OMCRXXDX.js";
-import {
-  shortenSymbol
-} from "./chunk-YMSJCSRG.js";
-
-// src/queries/convergence.ts
-function convergence(db, symbolPatternA, symbolPatternB) {
-  const matchA = findFirstSymbolMatch(db, symbolPatternA);
-  const matchB = findFirstSymbolMatch(db, symbolPatternB);
-  if (!matchA || !matchB) return null;
-  const calleesA = new Set(
-    getCalleeRowsForSymbol(db, matchA).map((r) => r.symbol)
-  );
-  const calleesB = new Set(
-    getCalleeRowsForSymbol(db, matchB).map((r) => r.symbol)
-  );
-  const shared = [];
-  for (const c of calleesA) {
-    if (calleesB.has(c)) shared.push(c);
-  }
-  const uniqueA = [];
-  for (const c of calleesA) {
-    if (!calleesB.has(c)) uniqueA.push(c);
-  }
-  const uniqueB = [];
-  for (const c of calleesB) {
-    if (!calleesA.has(c)) uniqueB.push(c);
-  }
-  const union = /* @__PURE__ */ new Set([...calleesA, ...calleesB]);
-  const similarity = union.size > 0 ? shared.length / union.size : 0;
-  let strategy;
-  if (union.size === 0) {
-    strategy = "Neither function calls other tracked symbols. There is no callee-pattern evidence for consolidation; inspect the source bodies directly.";
-  } 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 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'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'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 {
-    strategy = `Extract the ${shared.length} shared callees into a common helper. Each function calls the helper plus its own unique logic (${uniqueA.length} callees in A, ${uniqueB.length} in B).`;
-  }
-  const locA = matchA.endLine - matchA.startLine + 1;
-  const locB = matchB.endLine - matchB.startLine + 1;
-  return {
-    symbolA: {
-      symbol: matchA.symbol,
-      shortName: shortenSymbol(matchA.symbol),
-      file: matchA.relativePath,
-      loc: locA
-    },
-    symbolB: {
-      symbol: matchB.symbol,
-      shortName: shortenSymbol(matchB.symbol),
-      file: matchB.relativePath,
-      loc: locB
-    },
-    similarity,
-    sharedCallees: shared.map(shortenSymbol),
-    uniqueToA: uniqueA.map(shortenSymbol),
-    uniqueToB: uniqueB.map(shortenSymbol),
-    consolidationStrategy: strategy
-  };
-}
-
-export {
-  convergence
-};
-//# sourceMappingURL=chunk-44PFXVXG.js.map

package/dist/chunk-6SLFQR36.js

@@ -1,64 +0,0 @@
-import {
-  getScopedDefinitions
-} from "./chunk-OMCRXXDX.js";
-import {
-  shortenSymbol
-} from "./chunk-YMSJCSRG.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 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-6SLFQR36.js.map

package/dist/chunk-74RFWB5T.js

@@ -1,24 +0,0 @@
-// src/queries/stats.ts
-function stats(db) {
-  const documents = db.get("SELECT COUNT(*) as c FROM documents").c;
-  const symbols = db.get("SELECT COUNT(*) as c FROM global_symbols").c;
-  const definitions = db.get(
-    "SELECT COUNT(*) as c FROM mentions WHERE role = 1"
-  ).c;
-  const references = db.get(
-    "SELECT COUNT(*) as c FROM mentions WHERE role != 1"
-  ).c;
-  return {
-    documents,
-    symbols,
-    definitions,
-    references,
-    indexSizeBytes: db.sizeBytes(),
-    lastBuilt: db.lastModified()
-  };
-}
-
-export {
-  stats
-};
-//# sourceMappingURL=chunk-74RFWB5T.js.map