@optave/codegraph 3.5.0 → 3.6.0

package/src/features/graph-enrichment.ts

@@ -83,50 +83,18 @@ interface FunctionEdgeRow {
   edge_kind: string;
 }
 
-function prepareFunctionLevelData(
-  db: BetterSqlite3Database,
-  noTests: boolean,
-  minConf: number,
-  cfg: PlotConfig,
-): GraphData {
-  let edges = db
-    .prepare<FunctionEdgeRow>(
-      `
-      SELECT n1.id AS source_id, n1.name AS source_name, n1.kind AS source_kind,
-             n1.file AS source_file, n1.line AS source_line, n1.role AS source_role,
-             n2.id AS target_id, n2.name AS target_name, n2.kind AS target_kind,
-             n2.file AS target_file, n2.line AS target_line, n2.role AS target_role,
-             e.kind AS edge_kind
-      FROM edges e
-      JOIN nodes n1 ON e.source_id = n1.id
-      JOIN nodes n2 ON e.target_id = n2.id
-      WHERE n1.kind IN ('function', 'method', 'class', 'interface', 'type', 'struct', 'enum', 'trait', 'record', 'module', 'constant')
-        AND n2.kind IN ('function', 'method', 'class', 'interface', 'type', 'struct', 'enum', 'trait', 'record', 'module', 'constant')
-        AND e.kind = 'calls'
-        AND e.confidence >= ?
-    `,
-    )
-    .all(minConf);
-  if (noTests)
-    edges = edges.filter((e) => !isTestFile(e.source_file) && !isTestFile(e.target_file));
-
-  if (cfg.filter?.kinds) {
-    const kinds = new Set(cfg.filter.kinds);
-    edges = edges.filter((e) => kinds.has(e.source_kind) && kinds.has(e.target_kind));
-  }
-  if (cfg.filter?.files) {
-    const patterns = cfg.filter.files;
-    edges = edges.filter(
-      (e) =>
-        patterns.some((p) => e.source_file.includes(p)) &&
-        patterns.some((p) => e.target_file.includes(p)),
-    );
-  }
+type NodeInfo = {
+  id: number;
+  name: string;
+  kind: string;
+  file: string;
+  line: number;
+  role: string | null;
+};
 
-  const nodeMap = new Map<
-    number,
-    { id: number; name: string; kind: string; file: string; line: number; role: string | null }
-  >();
+/** Build node map from edge rows, collecting unique source/target nodes. */
+function buildNodeMapFromEdges(edges: FunctionEdgeRow[]): Map<number, NodeInfo> {
+  const nodeMap = new Map<number, NodeInfo>();
   for (const e of edges) {
     if (!nodeMap.has(e.source_id)) {
       nodeMap.set(e.source_id, {
@@ -149,17 +117,13 @@ function prepareFunctionLevelData(
       });
     }
   }
+  return nodeMap;
+}
 
-  if (cfg.filter?.roles) {
-    const roles = new Set(cfg.filter.roles);
-    for (const [id, n] of nodeMap) {
-      if (n.role === null || !roles.has(n.role)) nodeMap.delete(id);
-    }
-    const nodeIds = new Set(nodeMap.keys());
-    edges = edges.filter((e) => nodeIds.has(e.source_id) && nodeIds.has(e.target_id));
-  }
-
-  // Complexity data
+/** Load complexity data from function_complexity table. */
+function loadComplexityMap(
+  db: BetterSqlite3Database,
+): Map<number, { cognitive: number; cyclomatic: number; maintainabilityIndex: number }> {
   const complexityMap = new Map<
     number,
     { cognitive: number; cyclomatic: number; maintainabilityIndex: number }
@@ -186,19 +150,17 @@ function prepareFunctionLevelData(
   } catch {
     // table may not exist in old DBs
   }
+  return complexityMap;
+}
 
-  // Fan-in / fan-out via graph subsystem
-  const fnGraph = new CodeGraph();
-  for (const [id] of nodeMap) fnGraph.addNode(String(id));
-  for (const e of edges) {
-    const src = String(e.source_id);
-    const tgt = String(e.target_id);
-    if (src !== tgt && !fnGraph.hasEdge(src, tgt)) fnGraph.addEdge(src, tgt);
-  }
-
-  // Use DB-level fan-in/fan-out (counts ALL call edges, not just visible)
+/** Load fan-in and fan-out maps from edges table. */
+function loadFanMaps(db: BetterSqlite3Database): {
+  fanInMap: Map<number, number>;
+  fanOutMap: Map<number, number>;
+} {
   const fanInMap = new Map<number, number>();
   const fanOutMap = new Map<number, number>();
+
   const fanInRows = db
     .prepare<{ node_id: number; fan_in: number }>(
       "SELECT target_id AS node_id, COUNT(*) AS fan_in FROM edges WHERE kind = 'calls' GROUP BY target_id",
@@ -213,6 +175,138 @@ function prepareFunctionLevelData(
     .all();
   for (const r of fanOutRows) fanOutMap.set(r.node_id, r.fan_out);
 
+  return { fanInMap, fanOutMap };
+}
+
+/** Build an enriched VisNode from raw node info and computed maps. */
+function buildEnrichedVisNode(
+  n: NodeInfo,
+  complexityMap: Map<
+    number,
+    { cognitive: number; cyclomatic: number; maintainabilityIndex: number }
+  >,
+  fanInMap: Map<number, number>,
+  fanOutMap: Map<number, number>,
+  communityMap: Map<number, number>,
+  cfg: PlotConfig,
+): VisNode {
+  const cx = complexityMap.get(n.id) || null;
+  const fanIn = fanInMap.get(n.id) || 0;
+  const fanOut = fanOutMap.get(n.id) || 0;
+  const community = communityMap.get(n.id) ?? null;
+  const directory = path.dirname(n.file);
+  const risk: string[] = [];
+  if (n.role?.startsWith('dead')) risk.push('dead-code');
+  if (fanIn >= (cfg.riskThresholds?.highBlastRadius ?? 10)) risk.push('high-blast-radius');
+  if (cx && cx.maintainabilityIndex < (cfg.riskThresholds?.lowMI ?? 40)) risk.push('low-mi');
+
+  const color: string =
+    cfg.colorBy === 'role' && n.role
+      ? cfg.roleColors?.[n.role] ||
+        (DEFAULT_ROLE_COLORS as Record<string, string>)[n.role] ||
+        '#ccc'
+      : cfg.colorBy === 'community' && community !== null
+        ? COMMUNITY_COLORS[community % COMMUNITY_COLORS.length] || '#ccc'
+        : cfg.nodeColors?.[n.kind] ||
+          (DEFAULT_NODE_COLORS as Record<string, string>)[n.kind] ||
+          '#ccc';
+
+  return {
+    id: n.id,
+    label: n.name,
+    title: `${n.file}:${n.line} (${n.kind}${n.role ? `, ${n.role}` : ''})`,
+    color,
+    kind: n.kind,
+    role: n.role || '',
+    file: n.file,
+    line: n.line,
+    community,
+    cognitive: cx?.cognitive ?? null,
+    cyclomatic: cx?.cyclomatic ?? null,
+    maintainabilityIndex: cx?.maintainabilityIndex ?? null,
+    fanIn,
+    fanOut,
+    directory,
+    risk,
+  };
+}
+
+/** Select seed node IDs based on configured strategy. */
+function selectSeedNodes(visNodes: VisNode[], cfg: PlotConfig): (number | string)[] {
+  if (cfg.seedStrategy === 'top-fanin') {
+    const sorted = [...visNodes].sort((a, b) => b.fanIn - a.fanIn);
+    return sorted.slice(0, cfg.seedCount || 30).map((n) => n.id);
+  }
+  if (cfg.seedStrategy === 'entry') {
+    return visNodes.filter((n) => n.role === 'entry').map((n) => n.id);
+  }
+  return visNodes.map((n) => n.id);
+}
+
+function prepareFunctionLevelData(
+  db: BetterSqlite3Database,
+  noTests: boolean,
+  minConf: number,
+  cfg: PlotConfig,
+): GraphData {
+  let edges = db
+    .prepare<FunctionEdgeRow>(
+      `
+      SELECT n1.id AS source_id, n1.name AS source_name, n1.kind AS source_kind,
+             n1.file AS source_file, n1.line AS source_line, n1.role AS source_role,
+             n2.id AS target_id, n2.name AS target_name, n2.kind AS target_kind,
+             n2.file AS target_file, n2.line AS target_line, n2.role AS target_role,
+             e.kind AS edge_kind
+      FROM edges e
+      JOIN nodes n1 ON e.source_id = n1.id
+      JOIN nodes n2 ON e.target_id = n2.id
+      WHERE n1.kind IN ('function', 'method', 'class', 'interface', 'type', 'struct', 'enum', 'trait', 'record', 'module', 'constant')
+        AND n2.kind IN ('function', 'method', 'class', 'interface', 'type', 'struct', 'enum', 'trait', 'record', 'module', 'constant')
+        AND e.kind = 'calls'
+        AND e.confidence >= ?
+    `,
+    )
+    .all(minConf);
+  if (noTests)
+    edges = edges.filter((e) => !isTestFile(e.source_file) && !isTestFile(e.target_file));
+
+  if (cfg.filter?.kinds) {
+    const kinds = new Set(cfg.filter.kinds);
+    edges = edges.filter((e) => kinds.has(e.source_kind) && kinds.has(e.target_kind));
+  }
+  if (cfg.filter?.files) {
+    const patterns = cfg.filter.files;
+    edges = edges.filter(
+      (e) =>
+        patterns.some((p) => e.source_file.includes(p)) &&
+        patterns.some((p) => e.target_file.includes(p)),
+    );
+  }
+
+  const nodeMap = buildNodeMapFromEdges(edges);
+
+  if (cfg.filter?.roles) {
+    const roles = new Set(cfg.filter.roles);
+    for (const [id, n] of nodeMap) {
+      if (n.role === null || !roles.has(n.role)) nodeMap.delete(id);
+    }
+    const nodeIds = new Set(nodeMap.keys());
+    edges = edges.filter((e) => nodeIds.has(e.source_id) && nodeIds.has(e.target_id));
+  }
+
+  const complexityMap = loadComplexityMap(db);
+
+  // Build CodeGraph for Louvain community detection
+  const fnGraph = new CodeGraph();
+  for (const [id] of nodeMap) fnGraph.addNode(String(id));
+  for (const e of edges) {
+    const src = String(e.source_id);
+    const tgt = String(e.target_id);
+    if (src !== tgt && !fnGraph.hasEdge(src, tgt)) fnGraph.addEdge(src, tgt);
+  }
+
+  const { fanInMap, fanOutMap } = loadFanMaps(db);
+
   // Communities (Louvain) via graph subsystem
   const communityMap = new Map<number, number>();
   if (nodeMap.size > 0) {
@@ -224,48 +318,9 @@ function prepareFunctionLevelData(
     }
   }
 
-  // Build enriched nodes
-  const visNodes: VisNode[] = [...nodeMap.values()].map((n) => {
-    const cx = complexityMap.get(n.id) || null;
-    const fanIn = fanInMap.get(n.id) || 0;
-    const fanOut = fanOutMap.get(n.id) || 0;
-    const community = communityMap.get(n.id) ?? null;
-    const directory = path.dirname(n.file);
-    const risk: string[] = [];
-    if (n.role?.startsWith('dead')) risk.push('dead-code');
-    if (fanIn >= (cfg.riskThresholds?.highBlastRadius ?? 10)) risk.push('high-blast-radius');
-    if (cx && cx.maintainabilityIndex < (cfg.riskThresholds?.lowMI ?? 40)) risk.push('low-mi');
-
-    const color: string =
-      cfg.colorBy === 'role' && n.role
-        ? cfg.roleColors?.[n.role] ||
-          (DEFAULT_ROLE_COLORS as Record<string, string>)[n.role] ||
-          '#ccc'
-        : cfg.colorBy === 'community' && community !== null
-          ? COMMUNITY_COLORS[community % COMMUNITY_COLORS.length] || '#ccc'
-          : cfg.nodeColors?.[n.kind] ||
-            (DEFAULT_NODE_COLORS as Record<string, string>)[n.kind] ||
-            '#ccc';
-
-    return {
-      id: n.id,
-      label: n.name,
-      title: `${n.file}:${n.line} (${n.kind}${n.role ? `, ${n.role}` : ''})`,
-      color,
-      kind: n.kind,
-      role: n.role || '',
-      file: n.file,
-      line: n.line,
-      community,
-      cognitive: cx?.cognitive ?? null,
-      cyclomatic: cx?.cyclomatic ?? null,
-      maintainabilityIndex: cx?.maintainabilityIndex ?? null,
-      fanIn,
-      fanOut,
-      directory,
-      risk,
-    };
-  });
+  const visNodes: VisNode[] = [...nodeMap.values()].map((n) =>
+    buildEnrichedVisNode(n, complexityMap, fanInMap, fanOutMap, communityMap, cfg),
+  );
 
   const visEdges: VisEdge[] = edges.map((e, i) => ({
     id: `e${i}`,
@@ -273,18 +328,7 @@ function prepareFunctionLevelData(
     to: e.target_id,
   }));
 
-  // Seed strategy
-  let seedNodeIds: (number | string)[];
-  if (cfg.seedStrategy === 'top-fanin') {
-    const sorted = [...visNodes].sort((a, b) => b.fanIn - a.fanIn);
-    seedNodeIds = sorted.slice(0, cfg.seedCount || 30).map((n) => n.id);
-  } else if (cfg.seedStrategy === 'entry') {
-    seedNodeIds = visNodes.filter((n) => n.role === 'entry').map((n) => n.id);
-  } else {
-    seedNodeIds = visNodes.map((n) => n.id);
-  }
-
-  return { nodes: visNodes, edges: visEdges, seedNodeIds };
+  return { nodes: visNodes, edges: visEdges, seedNodeIds: selectSeedNodes(visNodes, cfg) };
 }
 
 interface FileLevelEdge {

package/src/features/sequence.ts

@@ -1,10 +1,11 @@
+import Database from 'better-sqlite3';
 import { openRepo, type Repository } from '../db/index.js';
 import { SqliteRepository } from '../db/repository/sqlite-repository.js';
 import { findMatchingNodes } from '../domain/queries.js';
 import { loadConfig } from '../infrastructure/config.js';
 import { isTestFile } from '../infrastructure/test-filter.js';
 import { paginateResult } from '../shared/paginate.js';
-import type { CodegraphConfig, NodeRowWithFanIn } from '../types.js';
+import type { BetterSqlite3Database, CodegraphConfig, NodeRowWithFanIn } from '../types.js';
 import { FRAMEWORK_ENTRY_PREFIXES } from './structure.js';
 
 // ─── Alias generation ────────────────────────────────────────────────
@@ -150,12 +151,34 @@ function annotateDataflow(
   repo: Repository,
   messages: SequenceMessage[],
   idToNode: Map<number, { id: number; name: string; file: string; kind: string; line: number }>,
+  dbPath?: string,
 ): void {
   const hasTable = repo.hasDataflowTable();
+  if (!hasTable) return;
+
+  let db: BetterSqlite3Database;
+  let ownDb = false;
+  if (repo instanceof SqliteRepository) {
+    db = repo.db;
+  } else if (dbPath) {
+    db = new Database(dbPath, { readonly: true }) as unknown as BetterSqlite3Database;
+    ownDb = true;
+  } else {
+    return;
+  }
 
-  if (!hasTable || !(repo instanceof SqliteRepository)) return;
+  try {
+    _annotateDataflowImpl(db, messages, idToNode);
+  } finally {
+    if (ownDb) db.close();
+  }
+}
 
-  const db = repo.db;
+function _annotateDataflowImpl(
+  db: BetterSqlite3Database,
+  messages: SequenceMessage[],
+  idToNode: Map<number, { id: number; name: string; file: string; kind: string; line: number }>,
+): void {
   const nodeByNameFile = new Map<string, { id: number; name: string; file: string }>();
   for (const n of idToNode.values()) {
     nodeByNameFile.set(`${n.name}|${n.file}`, n);
@@ -308,7 +331,7 @@ export function sequenceData(
     );
 
     if (opts.dataflow && messages.length > 0) {
-      annotateDataflow(repo, messages, idToNode);
+      annotateDataflow(repo, messages, idToNode, dbPath);
     }
 
     messages.sort((a, b) => {

package/src/features/structure-query.ts

@@ -7,7 +7,7 @@
  * role classification).
  */
 
-import { openReadonlyOrFail, testFilterSQL } from '../db/index.js';
+import { openReadonlyOrFail, openReadonlyWithNative, testFilterSQL } from '../db/index.js';
 import { loadConfig } from '../infrastructure/config.js';
 import { isTestFile } from '../infrastructure/test-filter.js';
 import { normalizePath } from '../shared/constants.js';
@@ -221,7 +221,7 @@ export function hotspotsData(
   limit: number;
   hotspots: unknown[];
 } {
-  const db = openReadonlyOrFail(customDbPath);
+  const { db, nativeDb, close } = openReadonlyWithNative(customDbPath);
   try {
     const metric = opts.metric || 'fan-in';
     const level = opts.level || 'file';
@@ -230,6 +230,46 @@ export function hotspotsData(
 
     const kind = level === 'directory' ? 'directory' : 'file';
 
+    const mapRow = (r: {
+      name: string;
+      kind: string;
+      lineCount: number | null;
+      symbolCount: number | null;
+      importCount: number | null;
+      exportCount: number | null;
+      fanIn: number | null;
+      fanOut: number | null;
+      cohesion: number | null;
+      fileCount: number | null;
+    }) => ({
+      name: r.name,
+      kind: r.kind,
+      lineCount: r.lineCount,
+      symbolCount: r.symbolCount,
+      importCount: r.importCount,
+      exportCount: r.exportCount,
+      fanIn: r.fanIn,
+      fanOut: r.fanOut,
+      cohesion: r.cohesion,
+      fileCount: r.fileCount,
+      density:
+        (r.fileCount ?? 0) > 0
+          ? (r.symbolCount || 0) / (r.fileCount ?? 1)
+          : (r.lineCount ?? 0) > 0
+            ? (r.symbolCount || 0) / (r.lineCount ?? 1)
+            : 0,
+      coupling: (r.fanIn || 0) + (r.fanOut || 0),
+    });
+
+    // ── Native fast path: single query instead of 4 eagerly prepared ──
+    if (nativeDb?.getHotspots) {
+      const rows = nativeDb.getHotspots(kind, metric, noTests, limit);
+      const hotspots = rows.map(mapRow);
+      const base = { metric, level, limit, hotspots };
+      return paginateResult(base, 'hotspots', { limit: opts.limit, offset: opts.offset });
+    }
+
+    // ── JS fallback ───────────────────────────────────────────────────
     const testFilter = testFilterSQL('n.name', noTests && kind === 'file');
 
     const HOTSPOT_QUERIES: Record<string, { all(...params: unknown[]): HotspotRow[] }> = {
@@ -256,7 +296,6 @@ export function hotspotsData(
     };
 
     const stmt = HOTSPOT_QUERIES[metric] ?? HOTSPOT_QUERIES['fan-in'];
-    // stmt is always defined: metric is a valid key or the fallback is a concrete property
     const rows = stmt!.all(kind, limit);
 
     const hotspots = rows.map((r) => ({
@@ -282,7 +321,7 @@ export function hotspotsData(
     const base = { metric, level, limit, hotspots };
     return paginateResult(base, 'hotspots', { limit: opts.limit, offset: opts.offset });
   } finally {
-    db.close();
+    close();
   }
 }
 

package/src/features/structure.ts

@@ -199,14 +199,11 @@ function computeFileMetrics(
   })();
 }
 
-function computeDirectoryMetrics(
-  db: BetterSqlite3Database,
-  upsertMetric: SqliteStatement,
-  getNodeIdStmt: NodeIdStmt,
-  fileSymbols: Map<string, FileSymbolData>,
+/** Map each directory to the files it transitively contains. */
+function buildDirFilesMap(
   allDirs: Set<string>,
-  importEdges: ImportEdge[],
-): void {
+  fileSymbols: Map<string, FileSymbolData>,
+): Map<string, string[]> {
   const dirFiles = new Map<string, string[]>();
   for (const dir of allDirs) {
     dirFiles.set(dir, []);
@@ -220,7 +217,11 @@ function computeDirectoryMetrics(
       d = normalizePath(path.dirname(d));
     }
   }
+  return dirFiles;
+}
 
+/** Build reverse map: file -> set of ancestor directories. */
+function buildFileToAncestorDirs(dirFiles: Map<string, string[]>): Map<string, Set<string>> {
   const fileToAncestorDirs = new Map<string, Set<string>>();
   for (const [dir, files] of dirFiles) {
     for (const f of files) {
@@ -228,7 +229,15 @@ function computeDirectoryMetrics(
       fileToAncestorDirs.get(f)?.add(dir);
     }
   }
+  return fileToAncestorDirs;
+}
 
+/** Count intra-directory, fan-in, and fan-out edges per directory. */
+function countDirectoryEdges(
+  allDirs: Set<string>,
+  importEdges: ImportEdge[],
+  fileToAncestorDirs: Map<string, Set<string>>,
+): Map<string, { intra: number; fanIn: number; fanOut: number }> {
   const dirEdgeCounts = new Map<string, { intra: number; fanIn: number; fanOut: number }>();
   for (const dir of allDirs) {
     dirEdgeCounts.set(dir, { intra: 0, fanIn: 0, fanOut: 0 });
@@ -258,6 +267,39 @@ function computeDirectoryMetrics(
       }
     }
   }
+  return dirEdgeCounts;
+}
+
+/** Count unique symbols in a list of files. */
+function countSymbolsInFiles(files: string[], fileSymbols: Map<string, FileSymbolData>): number {
+  let symbolCount = 0;
+  for (const f of files) {
+    const sym = fileSymbols.get(f);
+    if (sym) {
+      const seen = new Set<string>();
+      for (const d of sym.definitions) {
+        const key = `${d.name}|${d.kind}|${d.line}`;
+        if (!seen.has(key)) {
+          seen.add(key);
+          symbolCount++;
+        }
+      }
+    }
+  }
+  return symbolCount;
+}
+
+function computeDirectoryMetrics(
+  db: BetterSqlite3Database,
+  upsertMetric: SqliteStatement,
+  getNodeIdStmt: NodeIdStmt,
+  fileSymbols: Map<string, FileSymbolData>,
+  allDirs: Set<string>,
+  importEdges: ImportEdge[],
+): void {
+  const dirFiles = buildDirFilesMap(allDirs, fileSymbols);
+  const fileToAncestorDirs = buildFileToAncestorDirs(dirFiles);
+  const dirEdgeCounts = countDirectoryEdges(allDirs, importEdges, fileToAncestorDirs);
 
   db.transaction(() => {
     for (const [dir, files] of dirFiles) {
@@ -265,21 +307,7 @@ function computeDirectoryMetrics(
       if (!dirRow) continue;
 
       const fileCount = files.length;
-      let symbolCount = 0;
-
-      for (const f of files) {
-        const sym = fileSymbols.get(f);
-        if (sym) {
-          const seen = new Set<string>();
-          for (const d of sym.definitions) {
-            const key = `${d.name}|${d.kind}|${d.line}`;
-            if (!seen.has(key)) {
-              seen.add(key);
-              symbolCount++;
-            }
-          }
-        }
-      }
+      const symbolCount = countSymbolsInFiles(files, fileSymbols);
 
       const counts = dirEdgeCounts.get(dir) || { intra: 0, fanIn: 0, fanOut: 0 };
       const totalEdges = counts.intra + counts.fanIn + counts.fanOut;