@optave/codegraph 3.4.1 → 3.6.0

package/src/features/cfg.ts

@@ -275,16 +275,161 @@ 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);
 
+  // ── Native bulk-insert fast path ──────────────────────────────────────
+  const nativeDb = engineOpts?.nativeDb;
+  if (allNative && nativeDb?.bulkInsertCfg) {
+    const entries: Array<Record<string, unknown>> = [];
+
+    for (const [relPath, symbols] of fileSymbols) {
+      const ext = path.extname(relPath).toLowerCase();
+      if (!CFG_EXTENSIONS.has(ext)) continue;
+
+      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;
+
+        const cfg = def.cfg as unknown as { blocks: CfgBuildBlock[]; edges: CfgBuildEdge[] };
+        entries.push({
+          nodeId,
+          blocks: cfg.blocks.map((b) => ({
+            index: b.index,
+            blockType: b.type,
+            startLine: b.startLine ?? null,
+            endLine: b.endLine ?? null,
+            label: b.label ?? null,
+          })),
+          edges: cfg.edges.map((e) => ({
+            sourceIndex: e.sourceIndex,
+            targetIndex: e.targetIndex,
+            kind: e.kind,
+          })),
+        });
+      }
+    }
+
+    if (entries.length > 0) {
+      let inserted: number;
+      try {
+        engineOpts?.suspendJsDb?.();
+        inserted = nativeDb.bulkInsertCfg(entries);
+      } finally {
+        engineOpts?.resumeJsDb?.();
+      }
+      info(`CFG (native bulk): ${inserted} blocks across ${entries.length} functions`);
+    }
+    return;
+  }
+
   const extToLang = buildExtToLangMap();
   let parsers: unknown = null;
   let getParserFn: unknown = null;
@@ -308,74 +453,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,
     };