@optave/codegraph 3.11.0 → 3.11.2

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

@@ -83,6 +83,63 @@ function expandImplementors(
   }
 }
 
+/** Record a caller node at depth `d`, adding to frontier and levels. */
+function recordCaller(
+  caller: RelatedNodeRow,
+  parentId: number,
+  depth: number,
+  visited: Set<number>,
+  nextFrontier: number[],
+  levels: BfsLevels,
+  noTests: boolean,
+  onVisit?: BfsOnVisit,
+): void {
+  if (visited.has(caller.id) || (noTests && isTestFile(caller.file))) return;
+  visited.add(caller.id);
+  nextFrontier.push(caller.id);
+  if (!levels[depth]) levels[depth] = [];
+  levels[depth]!.push(toSymbolRef(caller));
+  if (onVisit) onVisit(caller, parentId, depth);
+}
+
+/** Process all callers of one frontier node, recording new nodes and expanding implementors. */
+function processFrontierNode(
+  repo: InstanceType<typeof Repository>,
+  fid: number,
+  depth: number,
+  visited: Set<number>,
+  nextFrontier: number[],
+  levels: BfsLevels,
+  noTests: boolean,
+  resolveImplementors: boolean,
+  onVisit?: BfsOnVisit,
+): void {
+  const callers = repo.findDistinctCallers(fid) as RelatedNodeRow[];
+  for (const c of callers) {
+    recordCaller(c, fid, depth, visited, nextFrontier, levels, noTests, onVisit);
+    if (resolveImplementors && INTERFACE_LIKE_KINDS.has(c.kind)) {
+      expandImplementors(repo, c.id, depth + 1, visited, nextFrontier, levels, noTests, onVisit);
+    }
+  }
+}
+
+/** Seed BFS with implementors of the start node when it is an interface/trait. */
+function seedInterfaceImplementors(
+  repo: InstanceType<typeof Repository>,
+  startId: number,
+  visited: Set<number>,
+  levels: BfsLevels,
+  noTests: boolean,
+  onVisit?: BfsOnVisit,
+): number[] {
+  const implNextFrontier: number[] = [];
+  const startNode = repo.findNodeById(startId) as NodeRow | undefined;
+  if (startNode && INTERFACE_LIKE_KINDS.has(startNode.kind)) {
+    expandImplementors(repo, startId, 1, visited, implNextFrontier, levels, noTests, onVisit);
+  }
+  return implNextFrontier;
+}
+
 export function bfsTransitiveCallers(
   dbOrRepo: BetterSqlite3Database | InstanceType<typeof Repository>,
   startId: number,
@@ -105,13 +162,9 @@ export function bfsTransitiveCallers(
   let frontier = [startId];
 
   // Seed: if start node is an interface/trait, include its implementors at depth 1
-  const implNextFrontier: number[] = [];
-  if (resolveImplementors) {
-    const startNode = repo.findNodeById(startId) as NodeRow | undefined;
-    if (startNode && INTERFACE_LIKE_KINDS.has(startNode.kind)) {
-      expandImplementors(repo, startId, 1, visited, implNextFrontier, levels, noTests, onVisit);
-    }
-  }
+  const implNextFrontier = resolveImplementors
+    ? seedInterfaceImplementors(repo, startId, visited, levels, noTests, onVisit)
+    : [];
 
   for (let d = 1; d <= maxDepth; d++) {
     if (d === 1 && implNextFrontier.length > 0) {
@@ -119,19 +172,17 @@ export function bfsTransitiveCallers(
     }
     const nextFrontier: number[] = [];
     for (const fid of frontier) {
-      const callers = repo.findDistinctCallers(fid) as RelatedNodeRow[];
-      for (const c of callers) {
-        if (!visited.has(c.id) && (!noTests || !isTestFile(c.file))) {
-          visited.add(c.id);
-          nextFrontier.push(c.id);
-          if (!levels[d]) levels[d] = [];
-          levels[d]!.push(toSymbolRef(c));
-          if (onVisit) onVisit(c, fid, d);
-        }
-        if (resolveImplementors && INTERFACE_LIKE_KINDS.has(c.kind)) {
-          expandImplementors(repo, c.id, d + 1, visited, nextFrontier, levels, noTests, onVisit);
-        }
-      }
+      processFrontierNode(
+        repo,
+        fid,
+        d,
+        visited,
+        nextFrontier,
+        levels,
+        noTests,
+        resolveImplementors,
+        onVisit,
+      );
     }
     frontier = nextFrontier;
     if (frontier.length === 0) break;
@@ -140,6 +191,53 @@ export function bfsTransitiveCallers(
   return { totalDependents: visited.size - 1, levels };
 }
 
+/** BFS over import dependents, returning visited node IDs and depth-per-id map. */
+function bfsImportDependents(
+  repo: InstanceType<typeof Repository>,
+  seedNodes: NodeRow[],
+  noTests: boolean,
+): { visited: Set<number>; levels: Map<number, number> } {
+  const visited = new Set<number>();
+  const queue: number[] = [];
+  const levels = new Map<number, number>();
+
+  for (const fn of seedNodes) {
+    visited.add(fn.id);
+    queue.push(fn.id);
+    levels.set(fn.id, 0);
+  }
+
+  while (queue.length > 0) {
+    const current = queue.shift()!;
+    const level = levels.get(current)!;
+    const dependents = repo.findImportDependents(current) as RelatedNodeRow[];
+    for (const dep of dependents) {
+      if (visited.has(dep.id)) continue;
+      if (noTests && isTestFile(dep.file)) continue;
+      visited.add(dep.id);
+      queue.push(dep.id);
+      levels.set(dep.id, level + 1);
+    }
+  }
+
+  return { visited, levels };
+}
+
+/** Group visited dependents by depth (excluding seed depth 0). */
+function groupDependentsByLevel(
+  repo: InstanceType<typeof Repository>,
+  levels: Map<number, number>,
+): Record<number, Array<{ file: string }>> {
+  const byLevel: Record<number, Array<{ file: string }>> = {};
+  for (const [id, level] of levels) {
+    if (level === 0) continue;
+    if (!byLevel[level]) byLevel[level] = [];
+    const node = repo.findNodeById(id) as NodeRow | undefined;
+    if (node) byLevel[level].push({ file: node.file });
+  }
+  return byLevel;
+}
+
 export function impactAnalysisData(
   file: string,
   customDbPath: string,
@@ -152,36 +250,8 @@ export function impactAnalysisData(
       return { file, sources: [], levels: {}, totalDependents: 0 };
     }
 
-    const visited = new Set<number>();
-    const queue: number[] = [];
-    const levels = new Map<number, number>();
-
-    for (const fn of fileNodes) {
-      visited.add(fn.id);
-      queue.push(fn.id);
-      levels.set(fn.id, 0);
-    }
-
-    while (queue.length > 0) {
-      const current = queue.shift()!;
-      const level = levels.get(current)!;
-      const dependents = repo.findImportDependents(current) as RelatedNodeRow[];
-      for (const dep of dependents) {
-        if (!visited.has(dep.id) && (!noTests || !isTestFile(dep.file))) {
-          visited.add(dep.id);
-          queue.push(dep.id);
-          levels.set(dep.id, level + 1);
-        }
-      }
-    }
-
-    const byLevel: Record<number, Array<{ file: string }>> = {};
-    for (const [id, level] of levels) {
-      if (level === 0) continue;
-      if (!byLevel[level]) byLevel[level] = [];
-      const node = repo.findNodeById(id) as NodeRow | undefined;
-      if (node) byLevel[level].push({ file: node.file });
-    }
+    const { visited, levels } = bfsImportDependents(repo, fileNodes, noTests);
+    const byLevel = groupDependentsByLevel(repo, levels);
 
     return {
       file,

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

@@ -4,7 +4,7 @@ import { loadConfig } from '../../infrastructure/config.js';
 import { debug } from '../../infrastructure/logger.js';
 import { isTestFile } from '../../infrastructure/test-filter.js';
 import { DEAD_ROLE_PREFIX } from '../../shared/kinds.js';
-import type { BetterSqlite3Database } from '../../types.js';
+import type { BetterSqlite3Database, NativeDatabase } from '../../types.js';
 import { findCycles } from '../graph/cycles.js';
 import { LANGUAGE_REGISTRY } from '../parser.js';
 
@@ -198,30 +198,13 @@ function computeQualityMetrics(
   ).c;
   const callConfidence = totalCallEdges > 0 ? highConfCallEdges / totalCallEdges : 0;
 
-  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 }));
+  const falsePositiveWarnings = buildFalsePositiveWarnings(queryFalsePositiveRows(db, fpThreshold));
 
   let fpEdgeCount = 0;
   for (const fp of falsePositiveWarnings) fpEdgeCount += fp.callerCount;
   const falsePositiveRatio = totalCallEdges > 0 ? fpEdgeCount / totalCallEdges : 0;
 
-  const score = Math.round(
-    callerCoverage * 40 + callConfidence * 40 + (1 - falsePositiveRatio) * 20,
-  );
+  const score = computeQualityScore(callerCoverage, callConfidence, falsePositiveRatio);
 
   return {
     score,
@@ -347,6 +330,169 @@ export function moduleMapData(customDbPath: string, limit = 20, opts: { noTests?
   }
 }
 
+type FalsePositiveRow = { name: string; file: string; line: number; caller_count: number };
+
+/** SQL query for false-positive caller counts above a threshold (shared by native and JS paths). */
+function queryFalsePositiveRows(
+  db: BetterSqlite3Database,
+  fpThreshold: number,
+): FalsePositiveRow[] {
+  return 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 FalsePositiveRow[];
+}
+
+/** Filter false-positive rows by the configured name set and shape them for the report. */
+function buildFalsePositiveWarnings(rows: FalsePositiveRow[]) {
+  return rows
+    .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 }));
+}
+
+/** Compute the composite quality score (0-100) from coverage, confidence, and FP ratio. */
+function computeQualityScore(
+  callerCoverage: number,
+  callConfidence: number,
+  falsePositiveRatio: number,
+): number {
+  return Math.round(callerCoverage * 40 + callConfidence * 40 + (1 - falsePositiveRatio) * 20);
+}
+
+/** Aggregate role counts and derive the `dead` total. */
+function aggregateRolesFromNative(roleCounts: Array<{ role: string; count: number }>) {
+  const roles: Record<string, number> & { dead?: number } = {};
+  let deadTotal = 0;
+  for (const r of roleCounts) {
+    roles[r.role] = r.count;
+    if (r.role.startsWith(DEAD_ROLE_PREFIX)) deadTotal += r.count;
+  }
+  if (deadTotal > 0) roles.dead = deadTotal;
+  return roles;
+}
+
+type NativeGraphStatsFn = NonNullable<NativeDatabase['getGraphStats']>;
+type NativeGraphStats = ReturnType<NativeGraphStatsFn>;
+
+/** Build the native fast-path stats result by combining native aggregations with JS-only sections. */
+function buildStatsFromNative(
+  db: BetterSqlite3Database,
+  nativeStats: NativeGraphStats,
+  config: any,
+  jsSections: {
+    files: ReturnType<typeof countFilesByLanguage>;
+    fileCycles: unknown[];
+    fnCycles: unknown[];
+  },
+) {
+  const s = nativeStats;
+  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 = aggregateRolesFromNative(s.roleCounts);
+
+  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 falsePositiveWarnings = buildFalsePositiveWarnings(queryFalsePositiveRows(db, fpThreshold));
+  let fpEdgeCount = 0;
+  for (const fp of falsePositiveWarnings) fpEdgeCount += fp.callerCount;
+  const falsePositiveRatio = s.quality.callEdges > 0 ? fpEdgeCount / s.quality.callEdges : 0;
+  const score = computeQualityScore(callerCoverage, callConfidence, falsePositiveRatio);
+
+  return {
+    nodes: { total: s.totalNodes, byKind: nodesByKind },
+    edges: { total: s.totalEdges, byKind: edgesByKind },
+    files: jsSections.files,
+    cycles: { fileLevel: jsSections.fileCycles.length, functionLevel: jsSections.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,
+  };
+}
+
+/** Build the JS-fallback stats result using SQL aggregations from the helpers above. */
+function buildStatsFromJs(
+  db: BetterSqlite3Database,
+  noTests: boolean,
+  config: any,
+  jsSections: {
+    files: ReturnType<typeof countFilesByLanguage>;
+    fileCycles: unknown[];
+    fnCycles: unknown[];
+  },
+) {
+  const testFilter = testFilterSQL('n.file', noTests);
+
+  const { total: totalNodes, byKind: nodesByKind } = countNodesByKind(db, noTests);
+  const { total: totalEdges, byKind: edgesByKind } = countEdgesByKind(db, noTests);
+
+  const hotspots = findHotspots(db, noTests, 5);
+  const embeddings = getEmbeddingsInfo(db);
+  const fpThreshold = config.analysis?.falsePositiveCallers ?? FALSE_POSITIVE_CALLER_THRESHOLD;
+  const quality = computeQualityMetrics(db, testFilter, fpThreshold);
+  const roles = countRoles(db, noTests);
+  const complexity = getComplexitySummary(db, testFilter);
+
+  return {
+    nodes: { total: totalNodes, byKind: nodesByKind },
+    edges: { total: totalEdges, byKind: edgesByKind },
+    files: jsSections.files,
+    cycles: { fileLevel: jsSections.fileCycles.length, functionLevel: jsSections.fnCycles.length },
+    hotspots,
+    embeddings,
+    quality,
+    roles,
+    complexity,
+  };
+}
+
 export function statsData(customDbPath: string, opts: { noTests?: boolean; config?: any } = {}) {
   const { db, nativeDb, close } = openReadonlyWithNative(customDbPath);
   try {
@@ -354,127 +500,16 @@ export function statsData(customDbPath: string, opts: { noTests?: boolean; confi
     const config = opts.config || loadConfig();
 
     // 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 { total: totalNodes, byKind: nodesByKind } = countNodesByKind(db, noTests);
-    const { total: totalEdges, byKind: edgesByKind } = countEdgesByKind(db, noTests);
-
-    const hotspots = findHotspots(db, noTests, 5);
-    const embeddings = getEmbeddingsInfo(db);
-    const fpThreshold = config.analysis?.falsePositiveCallers ?? FALSE_POSITIVE_CALLER_THRESHOLD;
-    const quality = computeQualityMetrics(db, testFilter, fpThreshold);
-    const roles = countRoles(db, noTests);
-    const complexity = getComplexitySummary(db, testFilter);
-
-    return {
-      nodes: { total: totalNodes, byKind: nodesByKind },
-      edges: { total: totalEdges, byKind: edgesByKind },
-      files,
-      cycles: { fileLevel: fileCycles.length, functionLevel: fnCycles.length },
-      hotspots,
-      embeddings,
-      quality,
-      roles,
-      complexity,
+    const jsSections = {
+      files: countFilesByLanguage(db, noTests),
+      fileCycles: findCycles(db, { fileLevel: true, noTests }),
+      fnCycles: findCycles(db, { fileLevel: false, noTests }),
     };
+
+    const nativeStats = nativeDb?.getGraphStats?.(noTests);
+    return nativeStats
+      ? buildStatsFromNative(db, nativeStats, config, jsSections)
+      : buildStatsFromJs(db, noTests, config, jsSections);
   } finally {
     close();
   }