@optave/codegraph 3.5.0 → 3.7.0

package/src/features/branch-compare.ts

@@ -5,8 +5,10 @@ import path from 'node:path';
 import { getDatabase } from '../db/better-sqlite3.js';
 import { buildGraph } from '../domain/graph/builder.js';
 import { kindIcon } from '../domain/queries.js';
+import { debug } from '../infrastructure/logger.js';
+import { getNative, isNativeAvailable } from '../infrastructure/native.js';
 import { isTestFile } from '../infrastructure/test-filter.js';
-import type { EngineMode } from '../types.js';
+import type { EngineMode, NativeDatabase } from '../types.js';
 
 // ─── Git Helpers ────────────────────────────────────────────────────────
 
@@ -107,6 +109,18 @@ function loadSymbolsFromDb(
 ): Map<string, SymbolInfo> {
   const Database = getDatabase();
   const db = new Database(dbPath, { readonly: true });
+
+  // Try opening a NativeDatabase for batched fan metrics
+  let nativeDb: NativeDatabase | undefined;
+  if (isNativeAvailable()) {
+    try {
+      const native = getNative();
+      nativeDb = native.NativeDatabase.openReadonly(dbPath);
+    } catch (e) {
+      debug(`loadSymbolsFromDb: native path failed: ${(e as Error).message}`);
+    }
+  }
+
   try {
     const symbols = new Map<string, SymbolInfo>();
 
@@ -132,6 +146,34 @@ function loadSymbolsFromDb(
       end_line: number | null;
     }>;
 
+    // Filter first, then batch fan metrics for all surviving rows
+    const filtered = noTests ? rows.filter((r) => !isTestFile(r.file)) : rows;
+
+    // ── Native fast path: batch all fan-in/fan-out in one napi call ──
+    if (nativeDb?.batchFanMetrics && filtered.length > 0) {
+      const nodeIds = filtered.map((r) => r.id);
+      const metrics = nativeDb.batchFanMetrics(nodeIds);
+      const metricsMap = new Map(metrics.map((m) => [m.nodeId, m]));
+
+      for (const row of filtered) {
+        const lineCount = row.end_line ? row.end_line - row.line + 1 : 0;
+        const m = metricsMap.get(row.id);
+        const key = makeSymbolKey(row.kind, row.file, row.name);
+        symbols.set(key, {
+          id: row.id,
+          name: row.name,
+          kind: row.kind,
+          file: row.file,
+          line: row.line,
+          lineCount,
+          fanIn: m?.fanIn ?? 0,
+          fanOut: m?.fanOut ?? 0,
+        });
+      }
+      return symbols;
+    }
+
+    // ── JS fallback ───────────────────────────────────────────────────
     const fanInStmt = db.prepare(
       `SELECT COUNT(*) AS cnt FROM edges WHERE target_id = ? AND kind = 'calls'`,
     );
@@ -139,9 +181,7 @@ function loadSymbolsFromDb(
       `SELECT COUNT(*) AS cnt FROM edges WHERE source_id = ? AND kind = 'calls'`,
     );
 
-    for (const row of rows) {
-      if (noTests && isTestFile(row.file)) continue;
-
+    for (const row of filtered) {
       const lineCount = row.end_line ? row.end_line - row.line + 1 : 0;
       const fanIn = (fanInStmt.get(row.id) as { cnt: number }).cnt;
       const fanOut = (fanOutStmt.get(row.id) as { cnt: number }).cnt;
@@ -162,6 +202,13 @@ function loadSymbolsFromDb(
     return symbols;
   } finally {
     db.close();
+    if (nativeDb) {
+      try {
+        nativeDb.close();
+      } catch {
+        /* already closed */
+      }
+    }
   }
 }
 

package/src/features/cfg.ts

@@ -275,16 +275,116 @@ function allCfgNative(fileSymbols: Map<string, FileSymbols>): boolean {
   return hasCfgFile;
 }
 
+/** Persist native CFG data for a single file (fast path — no tree/visitor needed). */
+function persistNativeFileCfg(
+  db: BetterSqlite3Database,
+  symbols: FileSymbols,
+  relPath: string,
+  insertBlock: ReturnType<BetterSqlite3Database['prepare']>,
+  insertEdge: ReturnType<BetterSqlite3Database['prepare']>,
+): number {
+  let count = 0;
+  for (const def of symbols.definitions) {
+    if (def.kind !== 'function' && def.kind !== 'method') continue;
+    if (!def.line) continue;
+
+    const nodeId = getFunctionNodeId(db, def.name, relPath, def.line);
+    if (!nodeId) continue;
+
+    deleteCfgForNode(db, nodeId);
+    if (!def.cfg?.blocks?.length) continue;
+
+    persistCfg(
+      def.cfg as unknown as { blocks: CfgBuildBlock[]; edges: CfgBuildEdge[] },
+      nodeId,
+      insertBlock,
+      insertEdge,
+    );
+    count++;
+  }
+  return count;
+}
+
+/** Resolve CFG for a definition from native data or visitor results. */
+function resolveCfgForDef(
+  def: Definition,
+  visitorCfgByLine: Map<number, VisitorCfgResult[]> | null,
+): { blocks: CfgBuildBlock[]; edges: CfgBuildEdge[] } | null {
+  if (def.cfg?.blocks?.length) {
+    return def.cfg as unknown as { blocks: CfgBuildBlock[]; edges: CfgBuildEdge[] };
+  }
+  if (!visitorCfgByLine) return null;
+  const candidates = visitorCfgByLine.get(def.line);
+  if (!candidates) return null;
+  const r =
+    candidates.length === 1
+      ? candidates[0]
+      : (candidates.find((c) => {
+          const n = c.funcNode.childForFieldName?.('name');
+          return n && n.text === def.name;
+        }) ?? candidates[0]);
+  return r ? { blocks: r.blocks, edges: r.edges } : null;
+}
+
+/** Persist CFG data for a single file using visitor/native hybrid path. */
+function persistVisitorFileCfg(
+  db: BetterSqlite3Database,
+  symbols: FileSymbols,
+  relPath: string,
+  rootDir: string,
+  extToLang: Map<string, string>,
+  parsers: unknown,
+  getParserFn: unknown,
+  insertBlock: ReturnType<BetterSqlite3Database['prepare']>,
+  insertEdge: ReturnType<BetterSqlite3Database['prepare']>,
+): number {
+  const treeLang = getTreeAndLang(symbols, relPath, rootDir, extToLang, parsers, getParserFn);
+  if (!treeLang) return 0;
+  const { tree, langId } = treeLang;
+
+  const cfgRules = CFG_RULES.get(langId);
+  if (!cfgRules) return 0;
+
+  const visitorCfgByLine = buildVisitorCfgMap(tree, cfgRules, symbols, langId);
+  let count = 0;
+
+  for (const def of symbols.definitions) {
+    if (def.kind !== 'function' && def.kind !== 'method') continue;
+    if (!def.line) continue;
+
+    const nodeId = getFunctionNodeId(db, def.name, relPath, def.line);
+    if (!nodeId) continue;
+
+    const cfg = resolveCfgForDef(def, visitorCfgByLine);
+    deleteCfgForNode(db, nodeId);
+    if (!cfg || cfg.blocks.length === 0) continue;
+
+    persistCfg(cfg, nodeId, insertBlock, insertEdge);
+    count++;
+  }
+  return count;
+}
+
 export async function buildCFGData(
   db: BetterSqlite3Database,
   fileSymbols: Map<string, FileSymbols>,
   rootDir: string,
-  _engineOpts?: unknown,
+  _engineOpts?: {
+    nativeDb?: { bulkInsertCfg?(entries: Array<Record<string, unknown>>): number };
+    suspendJsDb?: () => void;
+    resumeJsDb?: () => void;
+  },
 ): Promise<void> {
   // Fast path: when all function/method defs already have native CFG data,
   // skip WASM parser init, tree parsing, and JS visitor entirely — just persist.
   const allNative = allCfgNative(fileSymbols);
 
+  // NOTE: nativeDb.bulkInsertCfg is intentionally NOT used here.
+  // The CFG path requires delete-before-insert (deleteCfgForNode) which creates
+  // a dual-connection WAL conflict when deletes go through JS (better-sqlite3)
+  // and inserts go through native (rusqlite). The JS-only persistNativeFileCfg
+  // path below handles both on a single connection safely.
+
   const extToLang = buildExtToLangMap();
   let parsers: unknown = null;
   let getParserFn: unknown = null;
@@ -308,74 +408,22 @@ export async function buildCFGData(
       const ext = path.extname(relPath).toLowerCase();
       if (!CFG_EXTENSIONS.has(ext)) continue;
 
-      // Native fast path: skip tree/visitor setup when all CFG is pre-computed.
-      // Only apply to files without _tree — files with _tree were WASM-parsed
-      // and need the slow path (visitor) to compute CFG.
       if (allNative && !symbols._tree) {
-        for (const def of symbols.definitions) {
-          if (def.kind !== 'function' && def.kind !== 'method') continue;
-          if (!def.line) continue;
-
-          const nodeId = getFunctionNodeId(db, def.name, relPath, def.line);
-          if (!nodeId) continue;
-
-          // Always delete stale CFG rows (handles body-removed case)
-          deleteCfgForNode(db, nodeId);
-          if (!def.cfg?.blocks?.length) continue;
-
-          persistCfg(
-            def.cfg as unknown as { blocks: CfgBuildBlock[]; edges: CfgBuildEdge[] },
-            nodeId,
-            insertBlock,
-            insertEdge,
-          );
-          analyzed++;
-        }
+        analyzed += persistNativeFileCfg(db, symbols, relPath, insertBlock, insertEdge);
         continue;
       }
 
-      // When allNative=true, parsers/getParserFn are null. This is safe because
-      // _tree files use symbols._tree directly in getTreeAndLang (the parser
-      // code path is never reached). Non-_tree files are handled by the fast path above.
-      const treeLang = getTreeAndLang(symbols, relPath, rootDir, extToLang, parsers, getParserFn);
-      if (!treeLang) continue;
-      const { tree, langId } = treeLang;
-
-      const cfgRules = CFG_RULES.get(langId);
-      if (!cfgRules) continue;
-
-      const visitorCfgByLine = buildVisitorCfgMap(tree, cfgRules, symbols, langId);
-
-      for (const def of symbols.definitions) {
-        if (def.kind !== 'function' && def.kind !== 'method') continue;
-        if (!def.line) continue;
-
-        const nodeId = getFunctionNodeId(db, def.name, relPath, def.line);
-        if (!nodeId) continue;
-
-        let cfg: { blocks: CfgBuildBlock[]; edges: CfgBuildEdge[] } | null = null;
-        if (def.cfg?.blocks?.length) {
-          cfg = def.cfg as unknown as { blocks: CfgBuildBlock[]; edges: CfgBuildEdge[] };
-        } else if (visitorCfgByLine) {
-          const candidates = visitorCfgByLine.get(def.line);
-          const r = !candidates
-            ? undefined
-            : candidates.length === 1
-              ? candidates[0]
-              : (candidates.find((c) => {
-                  const n = c.funcNode.childForFieldName?.('name');
-                  return n && n.text === def.name;
-                }) ?? candidates[0]);
-          if (r) cfg = { blocks: r.blocks, edges: r.edges };
-        }
-
-        // Always purge stale rows (handles body-removed case)
-        deleteCfgForNode(db, nodeId);
-        if (!cfg || cfg.blocks.length === 0) continue;
-
-        persistCfg(cfg, nodeId, insertBlock, insertEdge);
-        analyzed++;
-      }
+      analyzed += persistVisitorFileCfg(
+        db,
+        symbols,
+        relPath,
+        rootDir,
+        extToLang,
+        parsers,
+        getParserFn,
+        insertBlock,
+        insertEdge,
+      );
     }
   });
 

package/src/features/check.ts

@@ -291,6 +291,85 @@ interface CheckOpts {
   config?: CodegraphConfig;
 }
 
+/** Walk up from repoRoot to find the nearest .git directory. */
+function findGitRoot(repoRoot: string): string | null {
+  let dir = repoRoot;
+  while (dir) {
+    if (fs.existsSync(path.join(dir, '.git'))) return dir;
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
+/** Run git diff and return the raw output string. */
+function getGitDiff(repoRoot: string, opts: { staged?: boolean; ref?: string }): string {
+  const args = opts.staged
+    ? ['diff', '--cached', '--unified=0', '--no-color']
+    : ['diff', opts.ref || 'HEAD', '--unified=0', '--no-color'];
+  return execFileSync('git', args, {
+    cwd: repoRoot,
+    encoding: 'utf-8',
+    maxBuffer: 10 * 1024 * 1024,
+    stdio: ['pipe', 'pipe', 'pipe'],
+  });
+}
+
+/** Resolve which check predicates are enabled from opts + config. */
+function resolveCheckFlags(opts: CheckOpts, config: CodegraphConfig) {
+  const checkConfig = config.check || ({} as CodegraphConfig['check']);
+  return {
+    enableCycles: opts.cycles ?? checkConfig.cycles ?? true,
+    enableSignatures: opts.signatures ?? checkConfig.signatures ?? true,
+    enableBoundaries: opts.boundaries ?? checkConfig.boundaries ?? true,
+    blastRadiusThreshold: opts.blastRadius ?? checkConfig.blastRadius ?? null,
+  };
+}
+
+/** Run all enabled check predicates and return the results. */
+function runPredicates(
+  db: BetterSqlite3Database,
+  diff: ParsedDiff,
+  flags: ReturnType<typeof resolveCheckFlags>,
+  repoRoot: string,
+  noTests: boolean,
+  maxDepth: number,
+): PredicateResult[] {
+  const changedFiles = new Set(diff.changedRanges.keys());
+  const predicates: PredicateResult[] = [];
+
+  if (flags.enableCycles) {
+    predicates.push({ name: 'cycles', ...checkNoNewCycles(db, changedFiles, noTests) });
+  }
+  if (flags.blastRadiusThreshold != null) {
+    predicates.push({
+      name: 'blast-radius',
+      ...checkMaxBlastRadius(db, diff.changedRanges, flags.blastRadiusThreshold, noTests, maxDepth),
+    });
+  }
+  if (flags.enableSignatures) {
+    predicates.push({
+      name: 'signatures',
+      ...checkNoSignatureChanges(db, diff.oldRanges, noTests),
+    });
+  }
+  if (flags.enableBoundaries) {
+    predicates.push({
+      name: 'boundaries',
+      ...checkNoBoundaryViolations(db, changedFiles, repoRoot, noTests),
+    });
+  }
+
+  return predicates;
+}
+
+const EMPTY_CHECK: CheckResult = {
+  predicates: [],
+  summary: { total: 0, passed: 0, failed: 0, changedFiles: 0, newFiles: 0 },
+  passed: true,
+};
+
 export function checkData(customDbPath: string | undefined, opts: CheckOpts = {}): CheckResult {
   const db = openReadonlyOrFail(customDbPath);
 
@@ -301,89 +380,26 @@ export function checkData(customDbPath: string | undefined, opts: CheckOpts = {}
     const maxDepth = opts.depth || 3;
 
     const config = opts.config || loadConfig(repoRoot);
-    const checkConfig = config.check || ({} as CodegraphConfig['check']);
-
-    const enableCycles = opts.cycles ?? checkConfig.cycles ?? true;
-    const enableSignatures = opts.signatures ?? checkConfig.signatures ?? true;
-    const enableBoundaries = opts.boundaries ?? checkConfig.boundaries ?? true;
-    const blastRadiusThreshold = opts.blastRadius ?? checkConfig.blastRadius ?? null;
-
-    let checkDir = repoRoot;
-    let isGitRepo = false;
-    while (checkDir) {
-      if (fs.existsSync(path.join(checkDir, '.git'))) {
-        isGitRepo = true;
-        break;
-      }
-      const parent = path.dirname(checkDir);
-      if (parent === checkDir) break;
-      checkDir = parent;
-    }
-    if (!isGitRepo) {
+    const flags = resolveCheckFlags(opts, config);
+
+    const gitRoot = findGitRoot(repoRoot);
+    if (!gitRoot) {
       return { error: `Not a git repository: ${repoRoot}` };
     }
 
     let diffOutput: string;
     try {
-      const args = opts.staged
-        ? ['diff', '--cached', '--unified=0', '--no-color']
-        : ['diff', opts.ref || 'HEAD', '--unified=0', '--no-color'];
-      diffOutput = execFileSync('git', args, {
-        cwd: repoRoot,
-        encoding: 'utf-8',
-        maxBuffer: 10 * 1024 * 1024,
-        stdio: ['pipe', 'pipe', 'pipe'],
-      });
+      diffOutput = getGitDiff(repoRoot, opts);
     } catch (e) {
       return { error: `Failed to run git diff: ${(e as Error).message}` };
     }
 
-    if (!diffOutput.trim()) {
-      return {
-        predicates: [],
-        summary: { total: 0, passed: 0, failed: 0, changedFiles: 0, newFiles: 0 },
-        passed: true,
-      };
-    }
-
-    const { changedRanges, oldRanges, newFiles } = parseDiffOutput(diffOutput);
-    if (changedRanges.size === 0) {
-      return {
-        predicates: [],
-        summary: { total: 0, passed: 0, failed: 0, changedFiles: 0, newFiles: 0 },
-        passed: true,
-      };
-    }
-
-    const changedFiles = new Set(changedRanges.keys());
+    if (!diffOutput.trim()) return EMPTY_CHECK;
 
-    const predicates: PredicateResult[] = [];
+    const diff = parseDiffOutput(diffOutput);
+    if (diff.changedRanges.size === 0) return EMPTY_CHECK;
 
-    if (enableCycles) {
-      const result = checkNoNewCycles(db, changedFiles, noTests);
-      predicates.push({ name: 'cycles', ...result });
-    }
-
-    if (blastRadiusThreshold != null) {
-      const result = checkMaxBlastRadius(
-        db,
-        changedRanges,
-        blastRadiusThreshold,
-        noTests,
-        maxDepth,
-      );
-      predicates.push({ name: 'blast-radius', ...result });
-    }
-
-    if (enableSignatures) {
-      const result = checkNoSignatureChanges(db, oldRanges, noTests);
-      predicates.push({ name: 'signatures', ...result });
-    }
-
-    if (enableBoundaries) {
-      const result = checkNoBoundaryViolations(db, changedFiles, repoRoot, noTests);
-      predicates.push({ name: 'boundaries', ...result });
-    }
+    const predicates = runPredicates(db, diff, flags, repoRoot, noTests, maxDepth);
 
     const passedCount = predicates.filter((p) => p.passed).length;
     const failedCount = predicates.length - passedCount;
@@ -394,8 +410,8 @@ export function checkData(customDbPath: string | undefined, opts: CheckOpts = {}
         total: predicates.length,
         passed: passedCount,
         failed: failedCount,
-        changedFiles: changedFiles.size,
-        newFiles: newFiles.size,
+        changedFiles: diff.changedRanges.size,
+        newFiles: diff.newFiles.size,
       },
       passed: failedCount === 0,
     };