scip-query 0.1.0

package/dist/chunk-5WTJAXY2.js

@@ -0,0 +1,61 @@
+import {
+  buildFileDepGraph
+} from "./chunk-FUHJCHS4.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-5WTJAXY2.js.map

package/dist/chunk-5WTJAXY2.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/queries/cycles.ts"],"sourcesContent":["import type { ScipDatabase } from '../db.js';\nimport { buildFileDepGraph } from '../query-support.js';\nimport type { CycleResult } from '../types.js';\n\n/**\n * Detect circular dependency chains between files.\n * A cycle exists when file A depends on B, B depends on C, and C depends on A.\n *\n * Uses the same dependency edges as the `deps` command (symbol definitions\n * referenced across files), then runs DFS cycle detection.\n */\nexport function cycles(\n  db: ScipDatabase,\n  opts: { scope?: string; maxDepth?: number } = {},\n): CycleResult[] {\n  const { scope, maxDepth = 10 } = opts;\n  const graph = buildFileDepGraph(db, scope);\n\n  // DFS cycle detection\n  const allCycles: CycleResult[] = [];\n  const visited = new Set<string>();\n  const inStack = new Set<string>();\n  const stack: string[] = [];\n\n  function dfs(node: string, depth: number): void {\n    if (depth > maxDepth) return;\n    if (inStack.has(node)) {\n      // Found a cycle — extract it from the stack\n      const cycleStart = stack.indexOf(node);\n      if (cycleStart !== -1) {\n        const cyclePath = stack.slice(cycleStart).concat(node);\n        // Normalize: start from the lexicographically smallest file\n        const minIdx = cyclePath.indexOf(\n          cyclePath.reduce((a, b) => (a < b ? a : b)),\n        );\n        const normalized = [\n          ...cyclePath.slice(minIdx, -1),\n          ...cyclePath.slice(0, minIdx),\n          cyclePath[minIdx]!,\n        ];\n        // Deduplicate\n        const key = normalized.join(' -> ');\n        if (!seenCycles.has(key)) {\n          seenCycles.add(key);\n          allCycles.push({ path: normalized });\n        }\n      }\n      return;\n    }\n    if (visited.has(node)) return;\n\n    visited.add(node);\n    inStack.add(node);\n    stack.push(node);\n\n    const neighbors = graph.get(node);\n    if (neighbors) {\n      for (const neighbor of neighbors) {\n        dfs(neighbor, depth + 1);\n      }\n    }\n\n    stack.pop();\n    inStack.delete(node);\n  }\n\n  const seenCycles = new Set<string>();\n  for (const node of graph.keys()) {\n    if (!visited.has(node)) {\n      dfs(node, 0);\n    }\n  }\n\n  // Sort by cycle length (shorter cycles are more actionable)\n  allCycles.sort((a, b) => a.path.length - b.path.length);\n\n  return allCycles;\n}\n"],"mappings":";;;;;AAWO,SAAS,OACd,IACA,OAA8C,CAAC,GAChC;AACf,QAAM,EAAE,OAAO,WAAW,GAAG,IAAI;AACjC,QAAM,QAAQ,kBAAkB,IAAI,KAAK;AAGzC,QAAM,YAA2B,CAAC;AAClC,QAAM,UAAU,oBAAI,IAAY;AAChC,QAAM,UAAU,oBAAI,IAAY;AAChC,QAAM,QAAkB,CAAC;AAEzB,WAAS,IAAI,MAAc,OAAqB;AAC9C,QAAI,QAAQ,SAAU;AACtB,QAAI,QAAQ,IAAI,IAAI,GAAG;AAErB,YAAM,aAAa,MAAM,QAAQ,IAAI;AACrC,UAAI,eAAe,IAAI;AACrB,cAAM,YAAY,MAAM,MAAM,UAAU,EAAE,OAAO,IAAI;AAErD,cAAM,SAAS,UAAU;AAAA,UACvB,UAAU,OAAO,CAAC,GAAG,MAAO,IAAI,IAAI,IAAI,CAAE;AAAA,QAC5C;AACA,cAAM,aAAa;AAAA,UACjB,GAAG,UAAU,MAAM,QAAQ,EAAE;AAAA,UAC7B,GAAG,UAAU,MAAM,GAAG,MAAM;AAAA,UAC5B,UAAU,MAAM;AAAA,QAClB;AAEA,cAAM,MAAM,WAAW,KAAK,MAAM;AAClC,YAAI,CAAC,WAAW,IAAI,GAAG,GAAG;AACxB,qBAAW,IAAI,GAAG;AAClB,oBAAU,KAAK,EAAE,MAAM,WAAW,CAAC;AAAA,QACrC;AAAA,MACF;AACA;AAAA,IACF;AACA,QAAI,QAAQ,IAAI,IAAI,EAAG;AAEvB,YAAQ,IAAI,IAAI;AAChB,YAAQ,IAAI,IAAI;AAChB,UAAM,KAAK,IAAI;AAEf,UAAM,YAAY,MAAM,IAAI,IAAI;AAChC,QAAI,WAAW;AACb,iBAAW,YAAY,WAAW;AAChC,YAAI,UAAU,QAAQ,CAAC;AAAA,MACzB;AAAA,IACF;AAEA,UAAM,IAAI;AACV,YAAQ,OAAO,IAAI;AAAA,EACrB;AAEA,QAAM,aAAa,oBAAI,IAAY;AACnC,aAAW,QAAQ,MAAM,KAAK,GAAG;AAC/B,QAAI,CAAC,QAAQ,IAAI,IAAI,GAAG;AACtB,UAAI,MAAM,CAAC;AAAA,IACb;AAAA,EACF;AAGA,YAAU,KAAK,CAAC,GAAG,MAAM,EAAE,KAAK,SAAS,EAAE,KAAK,MAAM;AAEtD,SAAO;AACT;","names":[]}

package/dist/chunk-6NBLIDF4.js

@@ -0,0 +1,24 @@
+// src/queries/refs.ts
+function refs(db, symbolPattern) {
+  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 gs.symbol LIKE ?
+      AND ${db.localSymbolPredicate}
+      AND m.role = 0
+    ORDER BY d.relative_path, c.start_line`,
+    `%${symbolPattern}%`
+  );
+  return rows.filter((r) => !db.isIgnored(r.relative_path)).map((r) => ({
+    relativePath: r.relative_path,
+    line: r.start_line
+  }));
+}
+
+export {
+  refs
+};
+//# sourceMappingURL=chunk-6NBLIDF4.js.map

package/dist/chunk-6NBLIDF4.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/queries/refs.ts"],"sourcesContent":["import type { ScipDatabase } from '../db.js';\nimport type { RefResult } from '../types.js';\n\nexport function refs(db: ScipDatabase, symbolPattern: string): RefResult[] {\n  const rows = db.all<{\n    relative_path: string;\n    start_line: number;\n  }>(\n    `SELECT DISTINCT d.relative_path, c.start_line\n    FROM mentions m\n    JOIN chunks c ON m.chunk_id = c.id\n    JOIN documents d ON c.document_id = d.id\n    JOIN global_symbols gs ON m.symbol_id = gs.id\n    WHERE gs.symbol LIKE ?\n      AND ${db.localSymbolPredicate}\n      AND m.role = 0\n    ORDER BY d.relative_path, c.start_line`,\n    `%${symbolPattern}%`,\n  );\n\n  return rows\n    .filter((r) => !db.isIgnored(r.relative_path))\n    .map((r) => ({\n      relativePath: r.relative_path,\n      line: r.start_line,\n    }));\n}\n"],"mappings":";AAGO,SAAS,KAAK,IAAkB,eAAoC;AACzE,QAAM,OAAO,GAAG;AAAA,IAId;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAMQ,GAAG,oBAAoB;AAAA;AAAA;AAAA,IAG/B,IAAI,aAAa;AAAA,EACnB;AAEA,SAAO,KACJ,OAAO,CAAC,MAAM,CAAC,GAAG,UAAU,EAAE,aAAa,CAAC,EAC5C,IAAI,CAAC,OAAO;AAAA,IACX,cAAc,EAAE;AAAA,IAChB,MAAM,EAAE;AAAA,EACV,EAAE;AACN;","names":[]}

package/dist/chunk-6SXADWLW.js

@@ -0,0 +1,43 @@
+import {
+  shortenSymbol
+} from "./chunk-QOV2R2WT.js";
+
+// src/queries/outline.ts
+function outline(db, filePattern) {
+  const rows = db.all(
+    `SELECT gs.symbol, gs.enclosing_symbol, der.start_line, der.end_line
+    FROM defn_enclosing_ranges der
+    JOIN global_symbols gs ON der.symbol_id = gs.id
+    JOIN documents d ON der.document_id = d.id
+    WHERE d.relative_path LIKE ?
+      ${db.symbolNoise}
+    ORDER BY der.start_line`,
+    `%${filePattern}%`
+  );
+  const nodeMap = /* @__PURE__ */ new Map();
+  const roots = [];
+  for (const r of rows) {
+    const node = {
+      symbol: r.symbol,
+      shortName: shortenSymbol(r.symbol),
+      startLine: r.start_line,
+      endLine: r.end_line,
+      children: []
+    };
+    nodeMap.set(r.symbol, node);
+  }
+  for (const r of rows) {
+    const node = nodeMap.get(r.symbol);
+    if (r.enclosing_symbol && nodeMap.has(r.enclosing_symbol)) {
+      nodeMap.get(r.enclosing_symbol).children.push(node);
+    } else {
+      roots.push(node);
+    }
+  }
+  return roots;
+}
+
+export {
+  outline
+};
+//# sourceMappingURL=chunk-6SXADWLW.js.map

package/dist/chunk-6SXADWLW.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/queries/outline.ts"],"sourcesContent":["import type { ScipDatabase } from '../db.js';\nimport type { OutlineNode } from '../types.js';\nimport { shortenSymbol } from '../symbol-parser.js';\n\n/**\n * Build a tree-structured outline of symbols in a file,\n * using the enclosing_symbol field to establish parent-child relationships.\n */\nexport function outline(db: ScipDatabase, filePattern: string): OutlineNode[] {\n  const rows = db.all<{\n    symbol: string;\n    enclosing_symbol: string | null;\n    start_line: number;\n    end_line: number;\n  }>(\n    `SELECT gs.symbol, gs.enclosing_symbol, der.start_line, der.end_line\n    FROM defn_enclosing_ranges der\n    JOIN global_symbols gs ON der.symbol_id = gs.id\n    JOIN documents d ON der.document_id = d.id\n    WHERE d.relative_path LIKE ?\n      ${db.symbolNoise}\n    ORDER BY der.start_line`,\n    `%${filePattern}%`,\n  );\n\n  // Build a map of symbol -> node\n  const nodeMap = new Map<string, OutlineNode>();\n  const roots: OutlineNode[] = [];\n\n  for (const r of rows) {\n    const node: OutlineNode = {\n      symbol: r.symbol,\n      shortName: shortenSymbol(r.symbol),\n      startLine: r.start_line,\n      endLine: r.end_line,\n      children: [],\n    };\n    nodeMap.set(r.symbol, node);\n  }\n\n  // Wire up parent-child via enclosing_symbol\n  for (const r of rows) {\n    const node = nodeMap.get(r.symbol)!;\n    if (r.enclosing_symbol && nodeMap.has(r.enclosing_symbol)) {\n      nodeMap.get(r.enclosing_symbol)!.children.push(node);\n    } else {\n      roots.push(node);\n    }\n  }\n\n  return roots;\n}\n"],"mappings":";;;;;AAQO,SAAS,QAAQ,IAAkB,aAAoC;AAC5E,QAAM,OAAO,GAAG;AAAA,IAMd;AAAA;AAAA;AAAA;AAAA;AAAA,QAKI,GAAG,WAAW;AAAA;AAAA,IAElB,IAAI,WAAW;AAAA,EACjB;AAGA,QAAM,UAAU,oBAAI,IAAyB;AAC7C,QAAM,QAAuB,CAAC;AAE9B,aAAW,KAAK,MAAM;AACpB,UAAM,OAAoB;AAAA,MACxB,QAAQ,EAAE;AAAA,MACV,WAAW,cAAc,EAAE,MAAM;AAAA,MACjC,WAAW,EAAE;AAAA,MACb,SAAS,EAAE;AAAA,MACX,UAAU,CAAC;AAAA,IACb;AACA,YAAQ,IAAI,EAAE,QAAQ,IAAI;AAAA,EAC5B;AAGA,aAAW,KAAK,MAAM;AACpB,UAAM,OAAO,QAAQ,IAAI,EAAE,MAAM;AACjC,QAAI,EAAE,oBAAoB,QAAQ,IAAI,EAAE,gBAAgB,GAAG;AACzD,cAAQ,IAAI,EAAE,gBAAgB,EAAG,SAAS,KAAK,IAAI;AAAA,IACrD,OAAO;AACL,YAAM,KAAK,IAAI;AAAA,IACjB;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}

package/dist/chunk-6VJ6Q7IE.js

@@ -0,0 +1,65 @@
+import {
+  findFirstSymbolMatch
+} from "./chunk-FUHJCHS4.js";
+import {
+  shortenSymbol
+} from "./chunk-QOV2R2WT.js";
+
+// src/queries/affected.ts
+function affected(db, symbolPattern, opts = {}) {
+  const { maxDepth = 5, scope } = opts;
+  const target = findFirstSymbolMatch(db, symbolPattern);
+  if (!target) return [];
+  const scopeFilter = scope ? `AND enc_d.relative_path LIKE '%${scope}%'` : "";
+  const results = [];
+  const visited = /* @__PURE__ */ new Set([target.symbolId]);
+  let frontier = /* @__PURE__ */ new Set([target.symbolId]);
+  for (let depth = 1; depth <= maxDepth; depth++) {
+    if (frontier.size === 0) break;
+    const placeholders = [...frontier].map(() => "?").join(",");
+    const nextFrontier = /* @__PURE__ */ new Set();
+    const rows = db.all(
+      `SELECT DISTINCT
+        enc_gs.id AS symbol_id,
+        enc_gs.symbol AS symbol,
+        enc_d.relative_path AS relative_path
+      FROM mentions m
+      JOIN chunks c ON m.chunk_id = c.id
+      JOIN documents ref_d ON c.document_id = ref_d.id
+      JOIN defn_enclosing_ranges enc_der
+        ON enc_der.document_id = ref_d.id
+        AND c.start_line >= enc_der.start_line
+        AND c.end_line <= enc_der.end_line
+      JOIN global_symbols enc_gs ON enc_der.symbol_id = enc_gs.id
+      JOIN documents enc_d ON enc_der.document_id = enc_d.id
+      WHERE m.symbol_id IN (${placeholders})
+        AND m.role = 0
+        AND enc_gs.id NOT IN (${placeholders})
+        ${db.symbolNoiseFor("enc_gs")}
+        ${db.pathExclusionsFor("enc_d")}
+        ${scopeFilter}`,
+      ...[...frontier],
+      ...[...frontier]
+    );
+    for (const row of rows) {
+      if (visited.has(row.symbol_id)) continue;
+      if (db.isIgnored(row.relative_path)) continue;
+      visited.add(row.symbol_id);
+      nextFrontier.add(row.symbol_id);
+      results.push({
+        symbol: row.symbol,
+        shortName: shortenSymbol(row.symbol),
+        file: row.relative_path,
+        depth
+      });
+    }
+    frontier = nextFrontier;
+  }
+  results.sort((a, b) => a.depth - b.depth || a.file.localeCompare(b.file));
+  return results;
+}
+
+export {
+  affected
+};
+//# sourceMappingURL=chunk-6VJ6Q7IE.js.map

package/dist/chunk-6VJ6Q7IE.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/queries/affected.ts"],"sourcesContent":["import type { ScipDatabase } from '../db.js';\nimport { findFirstSymbolMatch } from '../query-support.js';\nimport type { AffectedResult } from '../types.js';\nimport { shortenSymbol } from '../symbol-parser.js';\n\n/**\n * Full transitive closure of symbols that could break if a given symbol changes.\n * BFS from the target through the mention graph: depth 1 = direct consumers,\n * depth 2 = consumers of consumers, etc.\n */\nexport function affected(\n  db: ScipDatabase,\n  symbolPattern: string,\n  opts: { maxDepth?: number; scope?: string } = {},\n): AffectedResult[] {\n  const { maxDepth = 5, scope } = opts;\n\n  const target = findFirstSymbolMatch(db, symbolPattern);\n  if (!target) return [];\n\n  const scopeFilter = scope\n    ? `AND enc_d.relative_path LIKE '%${scope}%'`\n    : '';\n\n  const results: AffectedResult[] = [];\n  const visited = new Set<number>([target.symbolId]);\n  let frontier = new Set<number>([target.symbolId]);\n\n  for (let depth = 1; depth <= maxDepth; depth++) {\n    if (frontier.size === 0) break;\n\n    const placeholders = [...frontier].map(() => '?').join(',');\n    const nextFrontier = new Set<number>();\n\n    // For each symbol in the frontier, find enclosing symbols whose\n    // definition ranges contain a reference (role=0) to that frontier symbol.\n    const rows = db.all<{\n      symbol_id: number;\n      symbol: string;\n      relative_path: string;\n    }>(\n      `SELECT DISTINCT\n        enc_gs.id AS symbol_id,\n        enc_gs.symbol AS symbol,\n        enc_d.relative_path AS relative_path\n      FROM mentions m\n      JOIN chunks c ON m.chunk_id = c.id\n      JOIN documents ref_d ON c.document_id = ref_d.id\n      JOIN defn_enclosing_ranges enc_der\n        ON enc_der.document_id = ref_d.id\n        AND c.start_line >= enc_der.start_line\n        AND c.end_line <= enc_der.end_line\n      JOIN global_symbols enc_gs ON enc_der.symbol_id = enc_gs.id\n      JOIN documents enc_d ON enc_der.document_id = enc_d.id\n      WHERE m.symbol_id IN (${placeholders})\n        AND m.role = 0\n        AND enc_gs.id NOT IN (${placeholders})\n        ${db.symbolNoiseFor('enc_gs')}\n        ${db.pathExclusionsFor('enc_d')}\n        ${scopeFilter}`,\n      ...[...frontier],\n      ...[...frontier],\n    );\n\n    for (const row of rows) {\n      if (visited.has(row.symbol_id)) continue;\n      if (db.isIgnored(row.relative_path)) continue;\n\n      visited.add(row.symbol_id);\n      nextFrontier.add(row.symbol_id);\n\n      results.push({\n        symbol: row.symbol,\n        shortName: shortenSymbol(row.symbol),\n        file: row.relative_path,\n        depth,\n      });\n    }\n\n    frontier = nextFrontier;\n  }\n\n  // Sort by depth then file path\n  results.sort((a, b) => a.depth - b.depth || a.file.localeCompare(b.file));\n  return results;\n}\n"],"mappings":";;;;;;;;AAUO,SAAS,SACd,IACA,eACA,OAA8C,CAAC,GAC7B;AAClB,QAAM,EAAE,WAAW,GAAG,MAAM,IAAI;AAEhC,QAAM,SAAS,qBAAqB,IAAI,aAAa;AACrD,MAAI,CAAC,OAAQ,QAAO,CAAC;AAErB,QAAM,cAAc,QAChB,kCAAkC,KAAK,OACvC;AAEJ,QAAM,UAA4B,CAAC;AACnC,QAAM,UAAU,oBAAI,IAAY,CAAC,OAAO,QAAQ,CAAC;AACjD,MAAI,WAAW,oBAAI,IAAY,CAAC,OAAO,QAAQ,CAAC;AAEhD,WAAS,QAAQ,GAAG,SAAS,UAAU,SAAS;AAC9C,QAAI,SAAS,SAAS,EAAG;AAEzB,UAAM,eAAe,CAAC,GAAG,QAAQ,EAAE,IAAI,MAAM,GAAG,EAAE,KAAK,GAAG;AAC1D,UAAM,eAAe,oBAAI,IAAY;AAIrC,UAAM,OAAO,GAAG;AAAA,MAKd;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,8BAawB,YAAY;AAAA;AAAA,gCAEV,YAAY;AAAA,UAClC,GAAG,eAAe,QAAQ,CAAC;AAAA,UAC3B,GAAG,kBAAkB,OAAO,CAAC;AAAA,UAC7B,WAAW;AAAA,MACf,GAAG,CAAC,GAAG,QAAQ;AAAA,MACf,GAAG,CAAC,GAAG,QAAQ;AAAA,IACjB;AAEA,eAAW,OAAO,MAAM;AACtB,UAAI,QAAQ,IAAI,IAAI,SAAS,EAAG;AAChC,UAAI,GAAG,UAAU,IAAI,aAAa,EAAG;AAErC,cAAQ,IAAI,IAAI,SAAS;AACzB,mBAAa,IAAI,IAAI,SAAS;AAE9B,cAAQ,KAAK;AAAA,QACX,QAAQ,IAAI;AAAA,QACZ,WAAW,cAAc,IAAI,MAAM;AAAA,QACnC,MAAM,IAAI;AAAA,QACV;AAAA,MACF,CAAC;AAAA,IACH;AAEA,eAAW;AAAA,EACb;AAGA,UAAQ,KAAK,CAAC,GAAG,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,KAAK,cAAc,EAAE,IAAI,CAAC;AACxE,SAAO;AACT;","names":[]}

package/dist/chunk-7OZPA5OO.js

@@ -0,0 +1,258 @@
+import {
+  staleAbstractions
+} from "./chunk-GJFURBEW.js";
+import {
+  stats
+} from "./chunk-XFXDXEUN.js";
+import {
+  testCoverageSummary
+} from "./chunk-3ZZJVBIO.js";
+import {
+  wrapperCandidates
+} from "./chunk-TDNNOR6D.js";
+import {
+  passthroughCandidates
+} from "./chunk-NDSQYIWT.js";
+import {
+  similarAll
+} from "./chunk-TSPZOMHC.js";
+import {
+  isolated
+} from "./chunk-LUSIFBXO.js";
+import {
+  drift
+} from "./chunk-36OMT7ZJ.js";
+import {
+  extractCandidates
+} from "./chunk-CM454WL3.js";
+import {
+  complexityHotspots
+} from "./chunk-EMDQWNYR.js";
+import {
+  cycles
+} from "./chunk-5WTJAXY2.js";
+import {
+  dead
+} from "./chunk-5FGUEU7N.js";
+
+// src/queries/health.ts
+function health(db, opts = {}) {
+  const { scope } = opts;
+  const s = stats(db);
+  const deadResult = dead(db, { scope, minLoc: 3, skipBarrels: false });
+  const isolatedResult = isolated(db, { scope, minLoc: 3 });
+  const cycleResult = cycles(db, { scope });
+  const similarResult = similarAll(db, { scope, minSimilarity: 0.6, limit: 50, minCallees: 4 });
+  const extractResult = extractCandidates(db, { scope, minLoc: 15, minCallees: 5, limit: 50 });
+  const wrapperResult = wrapperCandidates(db, { scope, maxLoc: 15, limit: 50 });
+  const passthroughResult = passthroughCandidates(db, { scope, maxLoc: 15, limit: 50 });
+  const staleResult = staleAbstractions(db, { scope, minLoc: 3, limit: 50 });
+  const driftResult = drift(db, { scope });
+  const complexResult = complexityHotspots(db, { scope, minLoc: 10, limit: 10 });
+  const testResult = testCoverageSummary(db, { scope, minLoc: 3 });
+  const isolatedLoc = isolatedResult.reduce((sum, r) => sum + r.loc, 0);
+  const entryPointPatterns = ["/index.ts", "/index.js", "cli.ts", "worker.ts", "postinstall.ts", "/mod.rs", "__init__.py", "main.ts", "main.rs", "main.go", "main.py"];
+  const isEntryPoint = (path) => entryPointPatterns.some((p) => path.endsWith(p));
+  const trueDeadSymbols = deadResult.symbols.filter(
+    (s2) => !isEntryPoint(s2.relativePath) && s2.kind === "dead-code"
+  );
+  const trueDeadCount = trueDeadSymbols.length;
+  const trueDeadLoc = trueDeadSymbols.reduce((sum, s2) => sum + s2.loc, 0);
+  const fileInternalCount = deadResult.symbols.filter(
+    (s2) => !isEntryPoint(s2.relativePath) && s2.kind === "file-internal"
+  ).length;
+  const trueIsolatedCount = isolatedResult.filter(
+    (s2) => !isEntryPoint(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 trueDriftCount = driftResult.results.length;
+  const trueSimilarCount = similarResult.length;
+  const actions = [];
+  if (trueDeadCount > 0) {
+    actions.push({
+      category: "Dead code",
+      description: `${trueDeadCount} symbols with zero references anywhere \u2014 safe to delete`,
+      effort: "low",
+      impact: "high",
+      count: trueDeadCount,
+      locRecoverable: trueDeadLoc
+    });
+  }
+  if (testResult.percent < 50) {
+    actions.push({
+      category: "Test coverage",
+      description: `${testResult.percent}% of symbols referenced by tests (${testResult.uncovered} uncovered)`,
+      effort: "high",
+      impact: "high",
+      count: testResult.uncovered,
+      locRecoverable: 0
+    });
+  }
+  if (trueIsolatedCount > 0) {
+    actions.push({
+      category: "Isolated symbols",
+      description: `${trueIsolatedCount} symbols completely disconnected from the codebase graph`,
+      effort: "low",
+      impact: "medium",
+      count: trueIsolatedCount,
+      locRecoverable: isolatedResult.filter((s2) => !isEntryPoint(s2.relativePath)).reduce((sum, s2) => sum + s2.loc, 0)
+    });
+  }
+  if (cycleResult.length > 0) {
+    actions.push({
+      category: "Circular dependencies",
+      description: `${cycleResult.length} cycle(s) \u2014 break with dependency inversion or module restructuring`,
+      effort: "medium",
+      impact: "high",
+      count: cycleResult.length,
+      locRecoverable: 0
+    });
+  }
+  if (trueSimilarCount > 0) {
+    actions.push({
+      category: "Similar functions",
+      description: `${trueSimilarCount} pairs with real logic overlap (beyond shared imports) \u2014 consolidation candidates`,
+      effort: "medium",
+      impact: "medium",
+      count: trueSimilarCount,
+      locRecoverable: 0
+    });
+  }
+  if (extractResult.length > 0) {
+    actions.push({
+      category: "Extraction candidates",
+      description: `${extractResult.length} large functions with isolated callee clusters \u2014 extract method opportunities`,
+      effort: "medium",
+      impact: "medium",
+      count: extractResult.length,
+      locRecoverable: 0
+    });
+  }
+  if (wrapperResult.length > 0) {
+    actions.push({
+      category: "Wrapper functions",
+      description: `${wrapperResult.length} single-consumer symbols that could be inlined`,
+      effort: "low",
+      impact: "low",
+      count: wrapperResult.length,
+      locRecoverable: wrapperResult.reduce((sum, r) => sum + r.loc, 0)
+    });
+  }
+  if (passthroughResult.length > 0) {
+    actions.push({
+      category: "Passthrough functions",
+      description: `${passthroughResult.length} functions that just forward to one callee \u2014 unnecessary indirection`,
+      effort: "low",
+      impact: "low",
+      count: passthroughResult.length,
+      locRecoverable: passthroughResult.reduce((sum, r) => sum + r.loc, 0)
+    });
+  }
+  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 singleUse = trueStaleCount - unused;
+    const parts = [];
+    if (unused > 0) parts.push(`${unused} unused`);
+    if (singleUse > 0) parts.push(`${singleUse} single-consumer (not in types file)`);
+    actions.push({
+      category: "Stale abstractions",
+      description: `${parts.join(", ")} \u2014 premature abstraction`,
+      effort: "low",
+      impact: "medium",
+      count: trueStaleCount,
+      locRecoverable: staleResult.filter((s2) => s2.consumers === 0 || !s2.file.includes("types")).reduce((sum, r) => sum + r.loc, 0)
+    });
+  }
+  if (trueDriftCount > 0) {
+    const parts = [];
+    if (driftResult.unusedImports > 0) parts.push(`${driftResult.unusedImports} unused imports`);
+    if (driftResult.layerViolations > 0) parts.push(`${driftResult.layerViolations} layer violations`);
+    if (driftResult.patternDeviations > 0) parts.push(`${driftResult.patternDeviations} unique deps`);
+    actions.push({
+      category: "Structural drift",
+      description: parts.join(", "),
+      effort: driftResult.layerViolations > 0 ? "medium" : "low",
+      impact: driftResult.layerViolations > 0 ? "medium" : "low",
+      count: trueDriftCount,
+      locRecoverable: 0
+    });
+  }
+  const impactWeight = { high: 3, medium: 2, low: 1 };
+  const effortWeight = { low: 3, medium: 2, high: 1 };
+  actions.sort((a, b) => {
+    const scoreA = impactWeight[a.impact] * effortWeight[a.effort];
+    const scoreB = impactWeight[b.impact] * effortWeight[b.effort];
+    return scoreB - scoreA;
+  });
+  const fileCount = Math.max(s.documents, 1);
+  const symbolCount = Math.max(s.symbols, 1);
+  let score = 100;
+  const deadPercent = trueDeadCount / symbolCount;
+  score -= Math.min(20, Math.round(deadPercent * 200));
+  const isolatedPercent = trueIsolatedCount / symbolCount;
+  score -= Math.min(10, Math.round(isolatedPercent * 200));
+  score -= Math.min(15, cycleResult.length * 5);
+  score -= Math.min(10, trueSimilarCount * 2);
+  score -= Math.min(5, extractResult.length * 2);
+  score -= Math.min(3, wrapperResult.length);
+  score -= Math.min(3, passthroughResult.length);
+  const stalePercent = trueStaleCount / Math.max(symbolCount * 0.1, 1);
+  score -= Math.min(8, Math.round(stalePercent * 10));
+  const driftPercent = trueDriftCount / fileCount;
+  score -= Math.min(5, Math.round(driftPercent * 50));
+  const extremeComplexity = complexResult.filter((r) => r.score > 50).length;
+  score -= Math.min(5, extremeComplexity * 2);
+  const coverageDeduction = Math.round(15 * (1 - testResult.percent / 100));
+  score -= coverageDeduction;
+  score = Math.max(0, Math.min(100, score));
+  return {
+    score,
+    overview: {
+      documents: s.documents,
+      symbols: s.symbols,
+      indexSizeBytes: s.indexSizeBytes
+    },
+    findings: {
+      deadSymbols: trueDeadCount,
+      deadLoc: trueDeadLoc,
+      isolatedSymbols: trueIsolatedCount,
+      isolatedLoc: isolatedResult.filter((s2) => !isEntryPoint(s2.relativePath)).reduce((sum, s2) => sum + s2.loc, 0),
+      cycles: cycleResult.length,
+      similarPairs: trueSimilarCount,
+      extractionCandidates: extractResult.length,
+      wrappers: wrapperResult.length,
+      passthroughs: passthroughResult.length,
+      staleTypes: trueStaleCount,
+      driftedFiles: trueDriftCount,
+      complexityHotspotCount: complexResult.length,
+      testCoveragePercent: testResult.percent
+    },
+    actions,
+    topComplexity: complexResult.slice(0, 5).map((r) => ({
+      symbol: r.shortName,
+      score: r.score
+    }))
+  };
+}
+
+export {
+  health
+};
+//# sourceMappingURL=chunk-7OZPA5OO.js.map

package/dist/chunk-7OZPA5OO.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/queries/health.ts"],"sourcesContent":["import type { ScipDatabase } from '../db.js';\nimport { dead } from './dead.js';\nimport { isolated } from './isolated.js';\nimport { cycles } from './cycles.js';\nimport { similarAll } from './similar.js';\nimport { extractCandidates } from './extract-candidates.js';\nimport { wrapperCandidates } from './wrapper-candidates.js';\nimport { passthroughCandidates } from './passthrough-candidates.js';\nimport { staleAbstractions } from './stale-abstractions.js';\nimport { drift } from './drift.js';\nimport { complexityHotspots } from './complexity-hotspots.js';\nimport { testCoverageSummary } from './test-coverage.js';\nimport { stats } from './stats.js';\nimport type { HealthAction, HealthReport } from '../types.js';\n\n/**\n * Single composite health report that runs all de-bloat analyses\n * and produces a prioritized action list.\n *\n * The scoring formula accounts for common false positives:\n * - Entry points (CLI, workers, barrels) appearing as \"dead code\"\n * - Typed result interfaces with 1 consumer (normal for APIs)\n * - Consistent import patterns across sibling modules (not duplication)\n * - Barrel and orchestrator files deviating from sibling patterns (expected)\n */\nexport function health(\n  db: ScipDatabase,\n  opts: { scope?: string } = {},\n): HealthReport {\n  const { scope } = opts;\n\n  // Run all analyses\n  const s = stats(db);\n  const deadResult = dead(db, { scope, minLoc: 3, skipBarrels: false });\n  const isolatedResult = isolated(db, { scope, minLoc: 3 });\n  const cycleResult = cycles(db, { scope });\n  const similarResult = similarAll(db, { scope, minSimilarity: 0.6, limit: 50, minCallees: 4 });\n  const extractResult = extractCandidates(db, { scope, minLoc: 15, minCallees: 5, limit: 50 });\n  const wrapperResult = wrapperCandidates(db, { scope, maxLoc: 15, limit: 50 });\n  const passthroughResult = passthroughCandidates(db, { scope, maxLoc: 15, limit: 50 });\n  const staleResult = staleAbstractions(db, { scope, minLoc: 3, limit: 50 });\n  const driftResult = drift(db, { scope });\n  const complexResult = complexityHotspots(db, { scope, minLoc: 10, limit: 10 });\n  const testResult = testCoverageSummary(db, { scope, minLoc: 3 });\n\n  const isolatedLoc = isolatedResult.reduce((sum, r) => sum + r.loc, 0);\n\n  // ── False-positive filtering ─────────────────────────────\n\n  // Entry points and barrels appear as dead/isolated because nothing imports them.\n  // Filter them out of the scoring (but still report them with a note).\n  const entryPointPatterns = ['/index.ts', '/index.js', 'cli.ts', 'worker.ts', 'postinstall.ts', '/mod.rs', '__init__.py', 'main.ts', 'main.rs', 'main.go', 'main.py'];\n  const isEntryPoint = (path: string) => entryPointPatterns.some((p) => path.endsWith(p));\n\n  // Dead code: only count truly dead symbols (zero refs anywhere),\n  // excluding entry points AND file-internal helpers (which are fine).\n  const trueDeadSymbols = deadResult.symbols.filter(\n    (s) => !isEntryPoint(s.relativePath) && s.kind === 'dead-code',\n  );\n  const trueDeadCount = trueDeadSymbols.length;\n  const trueDeadLoc = trueDeadSymbols.reduce((sum, s) => sum + s.loc, 0);\n  const fileInternalCount = deadResult.symbols.filter(\n    (s) => !isEntryPoint(s.relativePath) && s.kind === 'file-internal',\n  ).length;\n\n  // Isolated: same entry-point filtering\n  const trueIsolatedCount = isolatedResult.filter(\n    (s) => !isEntryPoint(s.relativePath),\n  ).length;\n\n  // Stale abstractions: the command filters out types.ts single-consumer types.\n  // Also filter out 0-consumer types in files that export functions — these are\n  // likely parameter/return types consumed through function signatures, which\n  // the SCIP index can't track as direct mentions.\n  const filesWithFunctions = new Set(\n    db.all<{ relative_path: string }>(\n      `SELECT DISTINCT d.relative_path\n       FROM global_symbols gs\n       JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id\n       JOIN documents d ON der.document_id = d.id\n       WHERE gs.symbol LIKE '%().'\n         ${db.pathExclusionsFor('d')}`,\n    ).map((r) => r.relative_path),\n  );\n  const trueStaleCount = staleResult.filter((s) => {\n    // 0-consumer types in files with functions are likely param/return types\n    if (s.consumers === 0 && filesWithFunctions.has(s.file)) return false;\n    return true;\n  }).length;\n\n  // Drift: now uses usage-based detection (unused imports, layer violations, pattern deviations)\n  // The drift command already filters structural roles internally.\n  const trueDriftCount = driftResult.results.length;\n\n  // Similar pairs: the similar command now uses TF-IDF weighted cosine\n  // similarity which automatically discounts infrastructure callees.\n  // The sharedCallees list only contains significant (above-median IDF) callees.\n  // We can trust the count directly.\n  const trueSimilarCount = similarResult.length;\n\n  // ── Build prioritized action list ────────────────────────\n\n  const actions: HealthAction[] = [];\n\n  if (trueDeadCount > 0) {\n    actions.push({\n      category: 'Dead code',\n      description: `${trueDeadCount} symbols with zero references anywhere — safe to delete`,\n      effort: 'low',\n      impact: 'high',\n      count: trueDeadCount,\n      locRecoverable: trueDeadLoc,\n    });\n  }\n\n  if (testResult.percent < 50) {\n    actions.push({\n      category: 'Test coverage',\n      description: `${testResult.percent}% of symbols referenced by tests (${testResult.uncovered} uncovered)`,\n      effort: 'high',\n      impact: 'high',\n      count: testResult.uncovered,\n      locRecoverable: 0,\n    });\n  }\n\n  if (trueIsolatedCount > 0) {\n    actions.push({\n      category: 'Isolated symbols',\n      description: `${trueIsolatedCount} symbols completely disconnected from the codebase graph`,\n      effort: 'low',\n      impact: 'medium',\n      count: trueIsolatedCount,\n      locRecoverable: isolatedResult\n        .filter((s) => !isEntryPoint(s.relativePath))\n        .reduce((sum, s) => sum + s.loc, 0),\n    });\n  }\n\n  if (cycleResult.length > 0) {\n    actions.push({\n      category: 'Circular dependencies',\n      description: `${cycleResult.length} cycle(s) — break with dependency inversion or module restructuring`,\n      effort: 'medium',\n      impact: 'high',\n      count: cycleResult.length,\n      locRecoverable: 0,\n    });\n  }\n\n  if (trueSimilarCount > 0) {\n    actions.push({\n      category: 'Similar functions',\n      description: `${trueSimilarCount} pairs with real logic overlap (beyond shared imports) — consolidation candidates`,\n      effort: 'medium',\n      impact: 'medium',\n      count: trueSimilarCount,\n      locRecoverable: 0,\n    });\n  }\n\n  if (extractResult.length > 0) {\n    actions.push({\n      category: 'Extraction candidates',\n      description: `${extractResult.length} large functions with isolated callee clusters — extract method opportunities`,\n      effort: 'medium',\n      impact: 'medium',\n      count: extractResult.length,\n      locRecoverable: 0,\n    });\n  }\n\n  if (wrapperResult.length > 0) {\n    actions.push({\n      category: 'Wrapper functions',\n      description: `${wrapperResult.length} single-consumer symbols that could be inlined`,\n      effort: 'low',\n      impact: 'low',\n      count: wrapperResult.length,\n      locRecoverable: wrapperResult.reduce((sum, r) => sum + r.loc, 0),\n    });\n  }\n\n  if (passthroughResult.length > 0) {\n    actions.push({\n      category: 'Passthrough functions',\n      description: `${passthroughResult.length} functions that just forward to one callee — unnecessary indirection`,\n      effort: 'low',\n      impact: 'low',\n      count: passthroughResult.length,\n      locRecoverable: passthroughResult.reduce((sum, r) => sum + r.loc, 0),\n    });\n  }\n\n  if (trueStaleCount > 0) {\n    // Count from the filtered set, not the raw result\n    const trueStaleSymbols = staleResult.filter((s) => {\n      if (s.consumers === 0 && filesWithFunctions.has(s.file)) return false;\n      return true;\n    });\n    const unused = trueStaleSymbols.filter((s) => s.consumers === 0).length;\n    const singleUse = trueStaleCount - unused;\n    const parts: string[] = [];\n    if (unused > 0) parts.push(`${unused} unused`);\n    if (singleUse > 0) parts.push(`${singleUse} single-consumer (not in types file)`);\n    actions.push({\n      category: 'Stale abstractions',\n      description: `${parts.join(', ')} — premature abstraction`,\n      effort: 'low',\n      impact: 'medium',\n      count: trueStaleCount,\n      locRecoverable: staleResult\n        .filter((s) => s.consumers === 0 || !s.file.includes('types'))\n        .reduce((sum, r) => sum + r.loc, 0),\n    });\n  }\n\n  if (trueDriftCount > 0) {\n    const parts: string[] = [];\n    if (driftResult.unusedImports > 0) parts.push(`${driftResult.unusedImports} unused imports`);\n    if (driftResult.layerViolations > 0) parts.push(`${driftResult.layerViolations} layer violations`);\n    if (driftResult.patternDeviations > 0) parts.push(`${driftResult.patternDeviations} unique deps`);\n    actions.push({\n      category: 'Structural drift',\n      description: parts.join(', '),\n      effort: driftResult.layerViolations > 0 ? 'medium' : 'low',\n      impact: driftResult.layerViolations > 0 ? 'medium' : 'low',\n      count: trueDriftCount,\n      locRecoverable: 0,\n    });\n  }\n\n  // Sort: high impact + low effort first\n  const impactWeight = { high: 3, medium: 2, low: 1 };\n  const effortWeight = { low: 3, medium: 2, high: 1 };\n  actions.sort((a, b) => {\n    const scoreA = impactWeight[a.impact] * effortWeight[a.effort];\n    const scoreB = impactWeight[b.impact] * effortWeight[b.effort];\n    return scoreB - scoreA;\n  });\n\n  // ── Compute health score (0-100) ─────────────────────────\n  //\n  // Uses filtered counts (false positives removed).\n  // Deductions scale with codebase size so a 10-file project\n  // and a 1000-file project aren't penalized the same way.\n  const fileCount = Math.max(s.documents, 1);\n  const symbolCount = Math.max(s.symbols, 1);\n\n  let score = 100;\n\n  // Dead code: deduct based on % of symbols that are dead, not raw count\n  const deadPercent = trueDeadCount / symbolCount;\n  score -= Math.min(20, Math.round(deadPercent * 200));\n\n  // Isolated: same percentage-based\n  const isolatedPercent = trueIsolatedCount / symbolCount;\n  score -= Math.min(10, Math.round(isolatedPercent * 200));\n\n  // Cycles: these are always bad, flat penalty\n  score -= Math.min(15, cycleResult.length * 5);\n\n  // Similar pairs: only count true logic overlap, not boilerplate\n  score -= Math.min(10, trueSimilarCount * 2);\n\n  // Extract candidates: mild penalty\n  score -= Math.min(5, extractResult.length * 2);\n\n  // Wrappers: mild\n  score -= Math.min(3, wrapperResult.length);\n\n  // Passthroughs: mild\n  score -= Math.min(3, passthroughResult.length);\n\n  // Stale abstractions: percentage-based with filtered count\n  const stalePercent = trueStaleCount / Math.max(symbolCount * 0.1, 1);\n  score -= Math.min(8, Math.round(stalePercent * 10));\n\n  // Drift: percentage of files that deviate\n  const driftPercent = trueDriftCount / fileCount;\n  score -= Math.min(5, Math.round(driftPercent * 50));\n\n  // Complexity: only penalize extreme outliers\n  const extremeComplexity = complexResult.filter((r) => r.score > 50).length;\n  score -= Math.min(5, extremeComplexity * 2);\n\n  // Test coverage: significant penalty for low coverage\n  // 0% = -15, 25% = -11, 50% = -7, 75% = -4, 100% = 0\n  const coverageDeduction = Math.round(15 * (1 - testResult.percent / 100));\n  score -= coverageDeduction;\n\n  score = Math.max(0, Math.min(100, score));\n\n  return {\n    score,\n    overview: {\n      documents: s.documents,\n      symbols: s.symbols,\n      indexSizeBytes: s.indexSizeBytes,\n    },\n    findings: {\n      deadSymbols: trueDeadCount,\n      deadLoc: trueDeadLoc,\n      isolatedSymbols: trueIsolatedCount,\n      isolatedLoc: isolatedResult\n        .filter((s) => !isEntryPoint(s.relativePath))\n        .reduce((sum, s) => sum + s.loc, 0),\n      cycles: cycleResult.length,\n      similarPairs: trueSimilarCount,\n      extractionCandidates: extractResult.length,\n      wrappers: wrapperResult.length,\n      passthroughs: passthroughResult.length,\n      staleTypes: trueStaleCount,\n      driftedFiles: trueDriftCount,\n      complexityHotspotCount: complexResult.length,\n      testCoveragePercent: testResult.percent,\n    },\n    actions,\n    topComplexity: complexResult.slice(0, 5).map((r) => ({\n      symbol: r.shortName,\n      score: r.score,\n    })),\n  };\n}\n"],"mappings":"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","names":["s"]}

package/dist/chunk-BEPIEVLR.js

@@ -0,0 +1,76 @@
+import {
+  shortenSymbol
+} from "./chunk-QOV2R2WT.js";
+
+// src/queries/imports.ts
+function imports(db, filePattern) {
+  const rows = db.all(
+    `SELECT DISTINCT gs.symbol, def_d.relative_path AS from_file
+    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 LIKE ?
+      AND m.role = 2
+    ORDER BY def_d.relative_path, gs.symbol`,
+    `%${filePattern}%`
+  );
+  return rows.map((r) => ({
+    symbol: r.symbol,
+    shortName: shortenSymbol(r.symbol),
+    fromFile: r.from_file ?? "(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}%`
+  );
+  return rows.filter((r) => !db.isIgnored(r.importer)).map((r) => ({
+    symbol: r.symbol,
+    shortName: shortenSymbol(r.symbol),
+    fromFile: r.importer
+  }));
+}
+function unusedImports(db, filePattern) {
+  const rows = db.all(
+    `SELECT gs.symbol, d.relative_path AS imported_in
+    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 LIKE ?
+      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 = 0
+          AND ref_c.document_id = d.id
+      )
+    ORDER BY d.relative_path, gs.symbol`,
+    `%${filePattern}%`
+  );
+  return rows.map((r) => ({
+    symbol: r.symbol,
+    shortName: shortenSymbol(r.symbol),
+    importedIn: r.imported_in
+  }));
+}
+
+export {
+  imports,
+  importedBy,
+  unusedImports
+};
+//# sourceMappingURL=chunk-BEPIEVLR.js.map

package/dist/chunk-BEPIEVLR.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/queries/imports.ts"],"sourcesContent":["import type { ScipDatabase } from '../db.js';\nimport type { ImportResult, UnusedImportResult } from '../types.js';\nimport { shortenSymbol } from '../symbol-parser.js';\n\n/**\n * What symbols does this file import?\n * Uses role=2 (import) from the SCIP mentions table.\n */\nexport function imports(db: ScipDatabase, filePattern: string): ImportResult[] {\n  const rows = db.all<{\n    symbol: string;\n    from_file: string;\n  }>(\n    `SELECT DISTINCT gs.symbol, def_d.relative_path AS from_file\n    FROM mentions m\n    JOIN chunks c ON m.chunk_id = c.id\n    JOIN documents imp_d ON c.document_id = imp_d.id\n    JOIN global_symbols gs ON m.symbol_id = gs.id\n    LEFT JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id\n    LEFT JOIN documents def_d ON der.document_id = def_d.id\n    WHERE imp_d.relative_path LIKE ?\n      AND m.role = 2\n    ORDER BY def_d.relative_path, gs.symbol`,\n    `%${filePattern}%`,\n  );\n\n  return rows.map((r) => ({\n    symbol: r.symbol,\n    shortName: shortenSymbol(r.symbol),\n    fromFile: r.from_file ?? '(external)',\n  }));\n}\n\n/**\n * Which files import this symbol?\n */\nexport function importedBy(db: ScipDatabase, symbolPattern: string): ImportResult[] {\n  const rows = db.all<{\n    symbol: string;\n    importer: string;\n  }>(\n    `SELECT DISTINCT gs.symbol, d.relative_path AS importer\n    FROM mentions m\n    JOIN chunks c ON m.chunk_id = c.id\n    JOIN documents d ON c.document_id = d.id\n    JOIN global_symbols gs ON m.symbol_id = gs.id\n    WHERE gs.symbol LIKE ?\n      AND m.role = 2\n    ORDER BY d.relative_path`,\n    `%${symbolPattern}%`,\n  );\n\n  return rows\n    .filter((r) => !db.isIgnored(r.importer))\n    .map((r) => ({\n      symbol: r.symbol,\n      shortName: shortenSymbol(r.symbol),\n      fromFile: r.importer,\n    }));\n}\n\n/**\n * Find imports in a file that are never referenced (role=0) in the same file.\n * These are likely unused imports.\n */\nexport function unusedImports(db: ScipDatabase, filePattern: string): UnusedImportResult[] {\n  const rows = db.all<{\n    symbol: string;\n    imported_in: string;\n  }>(\n    `SELECT gs.symbol, d.relative_path AS imported_in\n    FROM mentions m\n    JOIN chunks c ON m.chunk_id = c.id\n    JOIN documents d ON c.document_id = d.id\n    JOIN global_symbols gs ON m.symbol_id = gs.id\n    WHERE d.relative_path LIKE ?\n      AND m.role = 2\n      AND NOT EXISTS (\n        SELECT 1\n        FROM mentions ref_m\n        JOIN chunks ref_c ON ref_m.chunk_id = ref_c.id\n        WHERE ref_m.symbol_id = gs.id\n          AND ref_m.role = 0\n          AND ref_c.document_id = d.id\n      )\n    ORDER BY d.relative_path, gs.symbol`,\n    `%${filePattern}%`,\n  );\n\n  return rows.map((r) => ({\n    symbol: r.symbol,\n    shortName: shortenSymbol(r.symbol),\n    importedIn: r.imported_in,\n  }));\n}\n"],"mappings":";;;;;AAQO,SAAS,QAAQ,IAAkB,aAAqC;AAC7E,QAAM,OAAO,GAAG;AAAA,IAId;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAUA,IAAI,WAAW;AAAA,EACjB;AAEA,SAAO,KAAK,IAAI,CAAC,OAAO;AAAA,IACtB,QAAQ,EAAE;AAAA,IACV,WAAW,cAAc,EAAE,MAAM;AAAA,IACjC,UAAU,EAAE,aAAa;AAAA,EAC3B,EAAE;AACJ;AAKO,SAAS,WAAW,IAAkB,eAAuC;AAClF,QAAM,OAAO,GAAG;AAAA,IAId;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAQA,IAAI,aAAa;AAAA,EACnB;AAEA,SAAO,KACJ,OAAO,CAAC,MAAM,CAAC,GAAG,UAAU,EAAE,QAAQ,CAAC,EACvC,IAAI,CAAC,OAAO;AAAA,IACX,QAAQ,EAAE;AAAA,IACV,WAAW,cAAc,EAAE,MAAM;AAAA,IACjC,UAAU,EAAE;AAAA,EACd,EAAE;AACN;AAMO,SAAS,cAAc,IAAkB,aAA2C;AACzF,QAAM,OAAO,GAAG;AAAA,IAId;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAgBA,IAAI,WAAW;AAAA,EACjB;AAEA,SAAO,KAAK,IAAI,CAAC,OAAO;AAAA,IACtB,QAAQ,EAAE;AAAA,IACV,WAAW,cAAc,EAAE,MAAM;AAAA,IACjC,YAAY,EAAE;AAAA,EAChB,EAAE;AACJ;","names":[]}

package/dist/chunk-BFSCMC22.js

@@ -0,0 +1,42 @@
+import {
+  shortenSymbol
+} from "./chunk-QOV2R2WT.js";
+
+// src/queries/hotspots.ts
+function hotspots(db, opts = {}) {
+  const { limit = 30, scope } = opts;
+  const scopeFilter = scope ? `AND def_d.relative_path LIKE '%${scope}%'` : "";
+  const rows = db.all(
+    `SELECT
+      gs.symbol,
+      COUNT(*) AS ref_count,
+      COUNT(DISTINCT ref_d.id) AS file_count,
+      def_d.relative_path AS defined_in
+    FROM mentions m
+    JOIN chunks c ON m.chunk_id = c.id
+    JOIN documents ref_d ON c.document_id = ref_d.id
+    JOIN global_symbols gs ON m.symbol_id = gs.id
+    JOIN defn_enclosing_ranges der ON gs.id = der.symbol_id
+    JOIN documents def_d ON der.document_id = def_d.id
+    WHERE m.role = 0
+      ${db.pathExclusionsFor("def_d")}
+      ${db.symbolNoiseFor("gs")}
+      ${scopeFilter}
+    GROUP BY gs.id
+    ORDER BY ref_count DESC
+    LIMIT ?`,
+    limit
+  );
+  return 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
+  }));
+}
+
+export {
+  hotspots
+};
+//# sourceMappingURL=chunk-BFSCMC22.js.map