@optave/codegraph 3.4.1 → 3.6.0

package/src/domain/analysis/dependencies.ts

@@ -5,7 +5,6 @@ import {
   findImportSources,
   findImportTargets,
   findNodesByFile,
-  openReadonlyOrFail,
 } from '../../db/index.js';
 import { cachedStmt } from '../../db/repository/cached-stmt.js';
 import { isTestFile } from '../../infrastructure/test-filter.js';
@@ -19,6 +18,7 @@ import type {
   RelatedNodeRow,
   StmtCache,
 } from '../../types.js';
+import { withReadonlyDb } from './query-helpers.js';
 import { findMatchingNodes } from './symbol-lookup.js';
 
 type UpstreamRow = { id: number; name: string; kind: string; file: string; line: number };
@@ -32,8 +32,7 @@ export function fileDepsData(
   customDbPath: string,
   opts: { noTests?: boolean; limit?: number; offset?: number } = {},
 ) {
-  const db = openReadonlyOrFail(customDbPath);
-  try {
+  return withReadonlyDb(customDbPath, (db) => {
     const noTests = opts.noTests || false;
     const fileNodes = findFileNodes(db, `%${file}%`) as NodeRow[];
     if (fileNodes.length === 0) {
@@ -59,9 +58,7 @@ export function fileDepsData(
 
     const base = { file, results };
     return paginateResult(base, 'results', { limit: opts.limit, offset: opts.offset });
-  } finally {
-    db.close();
-  }
+  });
 }
 
 /**
@@ -140,8 +137,7 @@ export function fnDepsData(
     offset?: number;
   } = {},
 ) {
-  const db = openReadonlyOrFail(customDbPath);
-  try {
+  return withReadonlyDb(customDbPath, (db) => {
     const depth = opts.depth || 3;
     const noTests = opts.noTests || false;
     const hc = new Map();
@@ -194,9 +190,7 @@ export function fnDepsData(
 
     const base = { name, results };
     return paginateResult(base, 'results', { limit: opts.limit, offset: opts.offset });
-  } finally {
-    db.close();
-  }
+  });
 }
 
 /**
@@ -384,8 +378,7 @@ export function pathData(
     kind?: string;
   } = {},
 ) {
-  const db = openReadonlyOrFail(customDbPath);
-  try {
+  return withReadonlyDb(customDbPath, (db) => {
     const noTests = opts.noTests || false;
     const maxDepth = opts.maxDepth || 10;
     const edgeKinds = opts.edgeKinds || ['calls'];
@@ -477,13 +470,67 @@ export function pathData(
       reverse,
       maxDepth,
     };
-  } finally {
-    db.close();
-  }
+  });
 }
 
 // ── File-level shortest path ────────────────────────────────────────────
 
+/** BFS over file adjacency graph to find shortest path. */
+function bfsFilePath(
+  neighborStmt: ReturnType<BetterSqlite3Database['prepare']>,
+  sourceFile: string,
+  targetFile: string,
+  edgeKinds: string[],
+  maxDepth: number,
+  noTests: boolean,
+): { found: boolean; path: string[]; alternateCount: number } {
+  const visited = new Set([sourceFile]);
+  const parentMap = new Map<string, string>();
+  let queue = [sourceFile];
+  let found = false;
+  let alternateCount = 0;
+
+  for (let depth = 1; depth <= maxDepth; depth++) {
+    const nextQueue: string[] = [];
+    for (const currentFile of queue) {
+      const neighbors = neighborStmt.all(currentFile, ...edgeKinds) as Array<{
+        neighbor_file: string;
+      }>;
+      for (const n of neighbors) {
+        if (noTests && isTestFile(n.neighbor_file)) continue;
+        if (n.neighbor_file === targetFile) {
+          if (!found) {
+            found = true;
+            parentMap.set(n.neighbor_file, currentFile);
+          }
+          alternateCount++;
+          continue;
+        }
+        if (!visited.has(n.neighbor_file)) {
+          visited.add(n.neighbor_file);
+          parentMap.set(n.neighbor_file, currentFile);
+          nextQueue.push(n.neighbor_file);
+        }
+      }
+    }
+    if (found) break;
+    queue = nextQueue;
+    if (queue.length === 0) break;
+  }
+
+  if (!found) return { found: false, path: [], alternateCount: 0 };
+
+  // Reconstruct path
+  const filePath: string[] = [targetFile];
+  let cur = targetFile;
+  while (cur !== sourceFile) {
+    cur = parentMap.get(cur)!;
+    filePath.push(cur);
+  }
+  filePath.reverse();
+  return { found: true, path: filePath, alternateCount: Math.max(0, alternateCount - 1) };
+}
+
 /**
  * BFS at the file level: find shortest import/edge path between two files.
  * Adjacency: file A → file B if any symbol in A has an edge to any symbol in B.
@@ -499,8 +546,7 @@ export function filePathData(
     reverse?: boolean;
   } = {},
 ) {
-  const db = openReadonlyOrFail(customDbPath);
-  try {
+  return withReadonlyDb(customDbPath, (db) => {
     const noTests = opts.noTests || false;
     const maxDepth = opts.maxDepth || 10;
     const edgeKinds = opts.edgeKinds || ['imports', 'imports-type'];
@@ -569,42 +615,17 @@ export function filePathData(
          WHERE n_src.file = ? AND e.kind IN (${kindPlaceholders}) AND n_tgt.file != n_src.file`;
     const neighborStmt = db.prepare(neighborQuery);
 
-    // BFS
-    const visited = new Set([sourceFile]);
-    const parentMap = new Map<string, string>();
-    let queue = [sourceFile];
-    let found = false;
-    let alternateCount = 0;
-
-    for (let depth = 1; depth <= maxDepth; depth++) {
-      const nextQueue: string[] = [];
-      for (const currentFile of queue) {
-        const neighbors = neighborStmt.all(currentFile, ...edgeKinds) as Array<{
-          neighbor_file: string;
-        }>;
-        for (const n of neighbors) {
-          if (noTests && isTestFile(n.neighbor_file)) continue;
-          if (n.neighbor_file === targetFile) {
-            if (!found) {
-              found = true;
-              parentMap.set(n.neighbor_file, currentFile);
-            }
-            alternateCount++;
-            continue;
-          }
-          if (!visited.has(n.neighbor_file)) {
-            visited.add(n.neighbor_file);
-            parentMap.set(n.neighbor_file, currentFile);
-            nextQueue.push(n.neighbor_file);
-          }
-        }
-      }
-      if (found) break;
-      queue = nextQueue;
-      if (queue.length === 0) break;
-    }
+    // BFS to find shortest file path
+    const bfsResult = bfsFilePath(
+      neighborStmt,
+      sourceFile,
+      targetFile,
+      edgeKinds,
+      maxDepth,
+      noTests,
+    );
 
-    if (!found) {
+    if (!bfsResult.found) {
       return {
         from,
         to,
@@ -620,29 +641,18 @@ export function filePathData(
       };
     }
 
-    // Reconstruct path
-    const filePath: string[] = [targetFile];
-    let cur = targetFile;
-    while (cur !== sourceFile) {
-      cur = parentMap.get(cur)!;
-      filePath.push(cur);
-    }
-    filePath.reverse();
-
     return {
       from,
       to,
       fromCandidates,
       toCandidates,
       found: true,
-      hops: filePath.length - 1,
-      path: filePath,
-      alternateCount: Math.max(0, alternateCount - 1),
+      hops: bfsResult.path.length - 1,
+      path: bfsResult.path,
+      alternateCount: bfsResult.alternateCount,
       edgeKinds,
       reverse,
       maxDepth,
     };
-  } finally {
-    db.close();
-  }
+  });
 }

package/src/domain/analysis/exports.ts

@@ -4,10 +4,8 @@ import {
   findDbPath,
   findFileNodes,
   findNodesByFile,
-  openReadonlyOrFail,
 } from '../../db/index.js';
 import { cachedStmt } from '../../db/repository/cached-stmt.js';
-import { loadConfig } from '../../infrastructure/config.js';
 import { debug } from '../../infrastructure/logger.js';
 import { isTestFile } from '../../infrastructure/test-filter.js';
 import {
@@ -17,6 +15,7 @@ import {
 } from '../../shared/file-utils.js';
 import { paginateResult } from '../../shared/paginate.js';
 import type { BetterSqlite3Database, NodeRow, StmtCache } from '../../types.js';
+import { resolveAnalysisOpts, withReadonlyDb } from './query-helpers.js';
 
 /** Cache the schema probe for the `exported` column per db handle. */
 const _hasExportedColCache: WeakMap<BetterSqlite3Database, boolean> = new WeakMap();
@@ -37,12 +36,8 @@ export function exportsData(
     config?: any;
   } = {},
 ) {
-  const db = openReadonlyOrFail(customDbPath);
-  try {
-    const noTests = opts.noTests || false;
-
-    const config = opts.config || loadConfig();
-    const displayOpts = config.display || {};
+  return withReadonlyDb(customDbPath, (db) => {
+    const { noTests, displayOpts } = resolveAnalysisOpts(opts);
 
     const dbFilePath = findDbPath(customDbPath);
     const repoRoot = path.resolve(path.dirname(dbFilePath), '..');
@@ -101,9 +96,39 @@ export function exportsData(
       }
     }
     return paginated;
-  } finally {
-    db.close();
+  });
+}
+
+/** Collect symbols re-exported through barrel files. */
+function collectReexportedSymbols(
+  db: BetterSqlite3Database,
+  fileNodeId: number,
+  reexportsToStmt: ReturnType<BetterSqlite3Database['prepare']>,
+  exportedNodesStmt: ReturnType<BetterSqlite3Database['prepare']> | null,
+  hasExportedCol: boolean,
+  getFileLines: (file: string) => string[] | null,
+  buildSymbolResult: (s: NodeRow, fileLines: string[] | null) => any,
+) {
+  const reexportTargets = reexportsToStmt.all(fileNodeId) as Array<{ file: string }>;
+  const reexportedSymbols: Array<ReturnType<typeof buildSymbolResult> & { originFile: string }> =
+    [];
+  for (const reexTarget of reexportTargets) {
+    let targetExported: NodeRow[];
+    if (hasExportedCol) {
+      targetExported = exportedNodesStmt!.all(reexTarget.file) as NodeRow[];
+    } else {
+      const targetSymbols = findNodesByFile(db, reexTarget.file) as NodeRow[];
+      const exportedIds = findCrossFileCallTargets(db, reexTarget.file) as Set<number>;
+      targetExported = targetSymbols.filter((s) => exportedIds.has(s.id));
+    }
+    for (const s of targetExported) {
+      reexportedSymbols.push({
+        ...buildSymbolResult(s, getFileLines(reexTarget.file)),
+        originFile: reexTarget.file,
+      });
+    }
   }
+  return reexportedSymbols;
 }
 
 function exportsFileImpl(
@@ -197,34 +222,20 @@ function exportsFileImpl(
 
     const totalUnused = results.filter((r) => r.consumerCount === 0).length;
 
-    // Files that re-export this file (barrel -> this file)
     const reexports = (reexportsFromStmt.all(fn.id) as Array<{ file: string }>).map((r) => ({
       file: r.file,
     }));
 
-    // For barrel files: gather symbols re-exported from target modules
-    const reexportTargets = reexportsToStmt.all(fn.id) as Array<{ file: string }>;
-
-    const reexportedSymbols: Array<ReturnType<typeof buildSymbolResult> & { originFile: string }> =
-      [];
-    for (const reexTarget of reexportTargets) {
-      let targetExported: NodeRow[];
-      if (hasExportedCol) {
-        targetExported = exportedNodesStmt!.all(reexTarget.file) as NodeRow[];
-      } else {
-        // Fallback: same heuristic as direct exports — symbols called from other files
-        const targetSymbols = findNodesByFile(db, reexTarget.file) as NodeRow[];
-        const exportedIds = findCrossFileCallTargets(db, reexTarget.file) as Set<number>;
-        targetExported = targetSymbols.filter((s) => exportedIds.has(s.id));
-      }
-      for (const s of targetExported) {
-        const fileLines = getFileLines(reexTarget.file);
-        reexportedSymbols.push({
-          ...buildSymbolResult(s, fileLines),
-          originFile: reexTarget.file,
-        });
-      }
-    }
+    // Gather symbols re-exported from target modules (barrel file support)
+    const reexportedSymbols = collectReexportedSymbols(
+      db,
+      fn.id,
+      reexportsToStmt,
+      exportedNodesStmt,
+      hasExportedCol,
+      getFileLines,
+      buildSymbolResult,
+    );
 
     let filteredResults = results;
     let filteredReexported = reexportedSymbols;

package/src/domain/analysis/fn-impact.ts

@@ -4,13 +4,12 @@ import {
   findImplementors,
   findImportDependents,
   findNodeById,
-  openReadonlyOrFail,
 } from '../../db/index.js';
-import { loadConfig } from '../../infrastructure/config.js';
 import { isTestFile } from '../../infrastructure/test-filter.js';
 import { normalizeSymbol } from '../../shared/normalize.js';
 import { paginateResult } from '../../shared/paginate.js';
 import type { BetterSqlite3Database, NodeRow, RelatedNodeRow } from '../../types.js';
+import { resolveAnalysisOpts, withReadonlyDb } from './query-helpers.js';
 import { findMatchingNodes } from './symbol-lookup.js';
 
 // --- Shared BFS: transitive callers ---
@@ -36,6 +35,62 @@ function hasImplementsEdges(db: BetterSqlite3Database): boolean {
  * during traversal), its concrete implementors are also added to the frontier
  * so that changes to an interface signature propagate to all implementors.
  */
+type BfsLevel = Array<{
+  name: string;
+  kind: string;
+  file: string;
+  line: number;
+  viaImplements?: boolean;
+}>;
+type BfsLevels = Record<number, BfsLevel>;
+type BfsOnVisit = (
+  caller: RelatedNodeRow & { viaImplements?: boolean },
+  parentId: number,
+  depth: number,
+) => void;
+
+/** Record an implementor node at the given depth, adding to frontier and levels. */
+function recordImplementor(
+  impl: RelatedNodeRow,
+  parentId: number,
+  depth: number,
+  visited: Set<number>,
+  frontier: number[],
+  levels: BfsLevels,
+  noTests: boolean,
+  onVisit?: BfsOnVisit,
+): void {
+  if (visited.has(impl.id) || (noTests && isTestFile(impl.file))) return;
+  visited.add(impl.id);
+  frontier.push(impl.id);
+  if (!levels[depth]) levels[depth] = [];
+  levels[depth].push({
+    name: impl.name,
+    kind: impl.kind,
+    file: impl.file,
+    line: impl.line,
+    viaImplements: true,
+  });
+  if (onVisit) onVisit({ ...impl, viaImplements: true }, parentId, depth);
+}
+
+/** Expand implementors for an interface/trait node into the BFS frontier. */
+function expandImplementors(
+  db: BetterSqlite3Database,
+  nodeId: number,
+  depth: number,
+  visited: Set<number>,
+  frontier: number[],
+  levels: BfsLevels,
+  noTests: boolean,
+  onVisit?: BfsOnVisit,
+): void {
+  const impls = findImplementors(db, nodeId) as RelatedNodeRow[];
+  for (const impl of impls) {
+    recordImplementor(impl, nodeId, depth, visited, frontier, levels, noTests, onVisit);
+  }
+}
+
 export function bfsTransitiveCallers(
   db: BetterSqlite3Database,
   startId: number,
@@ -48,50 +103,24 @@ export function bfsTransitiveCallers(
     noTests?: boolean;
     maxDepth?: number;
     includeImplementors?: boolean;
-    onVisit?: (
-      caller: RelatedNodeRow & { viaImplements?: boolean },
-      parentId: number,
-      depth: number,
-    ) => void;
+    onVisit?: BfsOnVisit;
   } = {},
 ) {
-  // Skip all implementor lookups when the graph has no implements edges
   const resolveImplementors = includeImplementors && hasImplementsEdges(db);
-
   const visited = new Set([startId]);
-  const levels: Record<
-    number,
-    Array<{ name: string; kind: string; file: string; line: number; viaImplements?: boolean }>
-  > = {};
+  const levels: BfsLevels = {};
   let frontier = [startId];
 
-  // Seed: if start node is an interface/trait, include its implementors at depth 1.
-  // Implementors go into a separate list so their callers appear at depth 2, not depth 1.
+  // Seed: if start node is an interface/trait, include its implementors at depth 1
   const implNextFrontier: number[] = [];
   if (resolveImplementors) {
     const startNode = findNodeById(db, startId) as NodeRow | undefined;
     if (startNode && INTERFACE_LIKE_KINDS.has(startNode.kind)) {
-      const impls = findImplementors(db, startId) as RelatedNodeRow[];
-      for (const impl of impls) {
-        if (!visited.has(impl.id) && (!noTests || !isTestFile(impl.file))) {
-          visited.add(impl.id);
-          implNextFrontier.push(impl.id);
-          if (!levels[1]) levels[1] = [];
-          levels[1].push({
-            name: impl.name,
-            kind: impl.kind,
-            file: impl.file,
-            line: impl.line,
-            viaImplements: true,
-          });
-          if (onVisit) onVisit({ ...impl, viaImplements: true }, startId, 1);
-        }
-      }
+      expandImplementors(db, startId, 1, visited, implNextFrontier, levels, noTests, onVisit);
     }
   }
 
   for (let d = 1; d <= maxDepth; d++) {
-    // On the first wave, merge seeded implementors so their callers appear at d=2
     if (d === 1 && implNextFrontier.length > 0) {
       frontier = [...frontier, ...implNextFrontier];
     }
@@ -106,27 +135,8 @@ export function bfsTransitiveCallers(
           levels[d]!.push({ name: c.name, kind: c.kind, file: c.file, line: c.line });
           if (onVisit) onVisit(c, fid, d);
         }
-
-        // If a caller is an interface/trait, also pull in its implementors
-        // Implementors are one extra hop away, so record at d+1
         if (resolveImplementors && INTERFACE_LIKE_KINDS.has(c.kind)) {
-          const impls = findImplementors(db, c.id) as RelatedNodeRow[];
-          for (const impl of impls) {
-            if (!visited.has(impl.id) && (!noTests || !isTestFile(impl.file))) {
-              visited.add(impl.id);
-              nextFrontier.push(impl.id);
-              const implDepth = d + 1;
-              if (!levels[implDepth]) levels[implDepth] = [];
-              levels[implDepth].push({
-                name: impl.name,
-                kind: impl.kind,
-                file: impl.file,
-                line: impl.line,
-                viaImplements: true,
-              });
-              if (onVisit) onVisit({ ...impl, viaImplements: true }, c.id, implDepth);
-            }
-          }
+          expandImplementors(db, c.id, d + 1, visited, nextFrontier, levels, noTests, onVisit);
         }
       }
     }
@@ -142,8 +152,7 @@ export function impactAnalysisData(
   customDbPath: string,
   opts: { noTests?: boolean } = {},
 ) {
-  const db = openReadonlyOrFail(customDbPath);
-  try {
+  return withReadonlyDb(customDbPath, (db) => {
     const noTests = opts.noTests || false;
     const fileNodes = findFileNodes(db, `%${file}%`) as NodeRow[];
     if (fileNodes.length === 0) {
@@ -187,9 +196,7 @@ export function impactAnalysisData(
       levels: byLevel,
       totalDependents: visited.size - fileNodes.length,
     };
-  } finally {
-    db.close();
-  }
+  });
 }
 
 export function fnImpactData(
@@ -206,11 +213,9 @@ export function fnImpactData(
     config?: any;
   } = {},
 ) {
-  const db = openReadonlyOrFail(customDbPath);
-  try {
-    const config = opts.config || loadConfig();
+  return withReadonlyDb(customDbPath, (db) => {
+    const { noTests, config } = resolveAnalysisOpts(opts);
     const maxDepth = opts.depth || config.analysis?.fnImpactDepth || 5;
-    const noTests = opts.noTests || false;
     const hc = new Map();
 
     const nodes = findMatchingNodes(db, name, { noTests, file: opts.file, kind: opts.kind });
@@ -235,7 +240,5 @@ export function fnImpactData(
 
     const base = { name, results };
     return paginateResult(base, 'results', { limit: opts.limit, offset: opts.offset });
-  } finally {
-    db.close();
-  }
+  });
 }

package/src/domain/analysis/module-map.ts

@@ -1,5 +1,5 @@
 import path from 'node:path';
-import { openReadonlyOrFail, testFilterSQL } from '../../db/index.js';
+import { openReadonlyOrFail, openReadonlyWithNative, testFilterSQL } from '../../db/index.js';
 import { cachedStmt } from '../../db/repository/cached-stmt.js';
 import { loadConfig } from '../../infrastructure/config.js';
 import { debug } from '../../infrastructure/logger.js';
@@ -381,20 +381,115 @@ export function moduleMapData(customDbPath: string, limit = 20, opts: { noTests?
 }
 
 export function statsData(customDbPath: string, opts: { noTests?: boolean; config?: any } = {}) {
-  const db = openReadonlyOrFail(customDbPath);
+  const { db, nativeDb, close } = openReadonlyWithNative(customDbPath);
   try {
     const noTests = opts.noTests || false;
     const config = opts.config || loadConfig();
-    const testFilter = testFilterSQL('n.file', noTests);
 
+    // These always need JS (non-SQL logic)
+    const files = countFilesByLanguage(db, noTests);
+    const fileCycles = findCycles(db, { fileLevel: true, noTests });
+    const fnCycles = findCycles(db, { fileLevel: false, noTests });
+
+    // ── Native fast path: batch all SQL aggregations in one napi call ──
+    if (nativeDb?.getGraphStats) {
+      const s = nativeDb.getGraphStats(noTests);
+      const nodesByKind: Record<string, number> = {};
+      for (const k of s.nodesByKind) nodesByKind[k.kind] = k.count;
+      const edgesByKind: Record<string, number> = {};
+      for (const k of s.edgesByKind) edgesByKind[k.kind] = k.count;
+      const roles: Record<string, number> & { dead?: number } = {};
+      let deadTotal = 0;
+      for (const r of s.roleCounts) {
+        roles[r.role] = r.count;
+        if (r.role.startsWith(DEAD_ROLE_PREFIX)) deadTotal += r.count;
+      }
+      if (deadTotal > 0) roles.dead = deadTotal;
+
+      const callerCoverage =
+        s.quality.callableTotal > 0 ? s.quality.callableWithCallers / s.quality.callableTotal : 0;
+      const callConfidence =
+        s.quality.callEdges > 0 ? s.quality.highConfCallEdges / s.quality.callEdges : 0;
+
+      // False-positive analysis still uses JS (needs FALSE_POSITIVE_NAMES set)
+      const fpThreshold = config.analysis?.falsePositiveCallers ?? FALSE_POSITIVE_CALLER_THRESHOLD;
+      const fpRows = db
+        .prepare(`
+          SELECT n.name, n.file, n.line, COUNT(e.source_id) as caller_count
+          FROM nodes n
+          LEFT JOIN edges e ON n.id = e.target_id AND e.kind = 'calls'
+          WHERE n.kind IN ('function', 'method')
+          GROUP BY n.id
+          HAVING caller_count > ?
+          ORDER BY caller_count DESC
+        `)
+        .all(fpThreshold) as Array<{
+        name: string;
+        file: string;
+        line: number;
+        caller_count: number;
+      }>;
+      const falsePositiveWarnings = fpRows
+        .filter((r) =>
+          FALSE_POSITIVE_NAMES.has(r.name.includes('.') ? r.name.split('.').pop()! : r.name),
+        )
+        .map((r) => ({ name: r.name, file: r.file, line: r.line, callerCount: r.caller_count }));
+      let fpEdgeCount = 0;
+      for (const fp of falsePositiveWarnings) fpEdgeCount += fp.callerCount;
+      const falsePositiveRatio = s.quality.callEdges > 0 ? fpEdgeCount / s.quality.callEdges : 0;
+      const score = Math.round(
+        callerCoverage * 40 + callConfidence * 40 + (1 - falsePositiveRatio) * 20,
+      );
+
+      return {
+        nodes: { total: s.totalNodes, byKind: nodesByKind },
+        edges: { total: s.totalEdges, byKind: edgesByKind },
+        files,
+        cycles: { fileLevel: fileCycles.length, functionLevel: fnCycles.length },
+        hotspots: s.hotspots.map((h) => ({ file: h.file, fanIn: h.fanIn, fanOut: h.fanOut })),
+        embeddings: s.embeddings
+          ? {
+              count: s.embeddings.count,
+              model: s.embeddings.model,
+              dim: s.embeddings.dim,
+              builtAt: s.embeddings.builtAt,
+            }
+          : null,
+        quality: {
+          score,
+          callerCoverage: {
+            ratio: callerCoverage,
+            covered: s.quality.callableWithCallers,
+            total: s.quality.callableTotal,
+          },
+          callConfidence: {
+            ratio: callConfidence,
+            highConf: s.quality.highConfCallEdges,
+            total: s.quality.callEdges,
+          },
+          falsePositiveWarnings,
+        },
+        roles,
+        complexity: s.complexity
+          ? {
+              analyzed: s.complexity.analyzed,
+              avgCognitive: s.complexity.avgCognitive,
+              avgCyclomatic: s.complexity.avgCyclomatic,
+              maxCognitive: s.complexity.maxCognitive,
+              maxCyclomatic: s.complexity.maxCyclomatic,
+              avgMI: s.complexity.avgMi,
+              minMI: s.complexity.minMi,
+            }
+          : null,
+      };
+    }
+
+    // ── JS fallback ───────────────────────────────────────────────────
+    const testFilter = testFilterSQL('n.file', noTests);
     const testFileIds = noTests ? buildTestFileIds(db) : null;
 
     const { total: totalNodes, byKind: nodesByKind } = countNodesByKind(db, testFileIds);
     const { total: totalEdges, byKind: edgesByKind } = countEdgesByKind(db, testFileIds);
-    const files = countFilesByLanguage(db, noTests);
-
-    const fileCycles = findCycles(db, { fileLevel: true, noTests });
-    const fnCycles = findCycles(db, { fileLevel: false, noTests });
 
     const hotspots = findHotspots(db, noTests, 5);
     const embeddings = getEmbeddingsInfo(db);
@@ -415,6 +510,6 @@ export function statsData(customDbPath: string, opts: { noTests?: boolean; confi
       complexity,
     };
   } finally {
-    db.close();
+    close();
   }
 }