@optave/codegraph 3.10.0 → 3.11.1

package/src/features/boundaries.ts

@@ -235,30 +235,23 @@ interface EvaluateBoundariesOpts {
   noTests?: boolean;
 }
 
-export function evaluateBoundaries(
-  db: BetterSqlite3Database,
-  boundaryConfig: BoundaryConfig | undefined,
-  opts: EvaluateBoundariesOpts = {},
-): { violations: BoundaryViolation[]; violationCount: number } {
-  if (!boundaryConfig) return { violations: [], violationCount: 0 };
-
-  const { valid, errors } = validateBoundaryConfig(boundaryConfig);
-  if (!valid) {
-    throw new BoundaryError(`Invalid boundary configuration: ${errors.join('; ')}`);
-  }
-
-  const modules = resolveModules(boundaryConfig);
-  if (modules.size === 0) return { violations: [], violationCount: 0 };
-
-  let allRules: BoundaryRule[] = [];
-  if (boundaryConfig.preset) {
-    allRules = generatePresetRules(modules, boundaryConfig.preset);
-  }
+function collectAllRules(
+  boundaryConfig: BoundaryConfig,
+  modules: Map<string, ResolvedModule>,
+): BoundaryRule[] {
+  const rules: BoundaryRule[] = boundaryConfig.preset
+    ? generatePresetRules(modules, boundaryConfig.preset)
+    : [];
   if (boundaryConfig.rules && Array.isArray(boundaryConfig.rules)) {
-    allRules = allRules.concat(boundaryConfig.rules);
+    return rules.concat(boundaryConfig.rules);
   }
-  if (allRules.length === 0) return { violations: [], violationCount: 0 };
+  return rules;
+}
 
+function loadImportEdges(
+  db: BetterSqlite3Database,
+  opts: EvaluateBoundariesOpts,
+): Array<{ source: string; target: string }> {
   let edges: Array<{ source: string; target: string }>;
   try {
     edges = db
@@ -281,38 +274,63 @@ export function evaluateBoundaries(
     const scope = new Set(opts.scopeFiles);
     edges = edges.filter((e) => scope.has(e.source));
   }
+  return edges;
+}
 
-  const violations: BoundaryViolation[] = [];
+function ruleViolated(rule: BoundaryRule, toModule: string): boolean {
+  if (rule.notTo?.includes(toModule)) return true;
+  if (rule.onlyTo && !rule.onlyTo.includes(toModule)) return true;
+  return false;
+}
 
-  for (const edge of edges) {
-    const fromModule = classifyFile(edge.source, modules);
-    const toModule = classifyFile(edge.target, modules);
+function emitEdgeViolations(
+  edge: { source: string; target: string },
+  fromModule: string,
+  toModule: string,
+  allRules: BoundaryRule[],
+  violations: BoundaryViolation[],
+): void {
+  for (const rule of allRules) {
+    if (rule.from !== fromModule) continue;
+    if (!ruleViolated(rule, toModule)) continue;
+    violations.push({
+      rule: 'boundaries',
+      name: `${fromModule} -> ${toModule}`,
+      file: edge.source,
+      targetFile: edge.target,
+      message: rule.message || `${fromModule} must not depend on ${toModule}`,
+      value: 1,
+      threshold: 0,
+    });
+  }
+}
 
-    if (!fromModule || !toModule) continue;
+export function evaluateBoundaries(
+  db: BetterSqlite3Database,
+  boundaryConfig: BoundaryConfig | undefined,
+  opts: EvaluateBoundariesOpts = {},
+): { violations: BoundaryViolation[]; violationCount: number } {
+  if (!boundaryConfig) return { violations: [], violationCount: 0 };
 
-    for (const rule of allRules) {
-      if (rule.from !== fromModule) continue;
+  const { valid, errors } = validateBoundaryConfig(boundaryConfig);
+  if (!valid) {
+    throw new BoundaryError(`Invalid boundary configuration: ${errors.join('; ')}`);
+  }
 
-      let isViolation = false;
+  const modules = resolveModules(boundaryConfig);
+  if (modules.size === 0) return { violations: [], violationCount: 0 };
 
-      if (rule.notTo?.includes(toModule)) {
-        isViolation = true;
-      } else if (rule.onlyTo && !rule.onlyTo.includes(toModule)) {
-        isViolation = true;
-      }
+  const allRules = collectAllRules(boundaryConfig, modules);
+  if (allRules.length === 0) return { violations: [], violationCount: 0 };
 
-      if (isViolation) {
-        violations.push({
-          rule: 'boundaries',
-          name: `${fromModule} -> ${toModule}`,
-          file: edge.source,
-          targetFile: edge.target,
-          message: rule.message || `${fromModule} must not depend on ${toModule}`,
-          value: 1,
-          threshold: 0,
-        });
-      }
-    }
+  const edges = loadImportEdges(db, opts);
+  const violations: BoundaryViolation[] = [];
+
+  for (const edge of edges) {
+    const fromModule = classifyFile(edge.source, modules);
+    const toModule = classifyFile(edge.target, modules);
+    if (!fromModule || !toModule) continue;
+    emitEdgeViolations(edge, fromModule, toModule, allRules, violations);
   }
 
   return { violations, violationCount: violations.length };

package/src/features/cfg.ts

@@ -18,7 +18,13 @@ import {
 } from '../db/index.js';
 import { debug, info } from '../infrastructure/logger.js';
 import { paginateResult } from '../shared/paginate.js';
-import type { BetterSqlite3Database, Definition, NodeRow, TreeSitterNode } from '../types.js';
+import type {
+  BetterSqlite3Database,
+  CfgRulesConfig,
+  Definition,
+  NodeRow,
+  TreeSitterNode,
+} from '../types.js';
 import { findNodes } from './shared/find-nodes.js';
 
 export { _makeCfgRules as makeCfgRules, CFG_RULES };
@@ -122,9 +128,8 @@ async function initCfgParsers(
   let getParserFn: unknown = null;
 
   if (needsFallback) {
-    const { createParsers } = await import('../domain/parser.js');
-    parsers = await createParsers();
     const mod = await import('../domain/parser.js');
+    parsers = await mod.createParsers();
     getParserFn = mod.getParser;
   }
 
@@ -187,7 +192,7 @@ interface VisitorCfgResult {
 
 function buildVisitorCfgMap(
   tree: { rootNode: TreeSitterNode } | null | undefined,
-  cfgRules: unknown,
+  cfgRules: CfgRulesConfig,
   symbols: FileSymbols,
   langId: string,
 ): Map<number, VisitorCfgResult[]> | null {
@@ -203,9 +208,8 @@ function buildVisitorCfgMap(
   if (!needsVisitor) return null;
 
   const visitor = createCfgVisitor(cfgRules);
-  const typedRules = cfgRules as { functionNodes: string[] };
   const walkerOpts = {
-    functionNodeTypes: new Set(typedRules.functionNodes),
+    functionNodeTypes: new Set(cfgRules.functionNodes),
     nestingNodeTypes: new Set<string>(),
     getFunctionName: (node: TreeSitterNode) => {
       const nameNode = node.childForFieldName?.('name');
@@ -365,79 +369,91 @@ function persistVisitorFileCfg(
   return count;
 }
 
-export async function buildCFGData(
+/**
+ * Build a single native bulk-insert entry for one definition.
+ * Returns null when the def has no CFG blocks or no associated node row.
+ */
+function buildNativeCfgEntry(
   db: BetterSqlite3Database,
-  fileSymbols: Map<string, FileSymbols>,
-  rootDir: string,
-  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);
+  def: Definition,
+  relPath: string,
+): Record<string, unknown> | null {
+  if (def.kind !== 'function' && def.kind !== 'method') return null;
+  if (!def.line) return null;
+
+  const nodeId = getFunctionNodeId(db, def.name, relPath, def.line);
+  if (!nodeId) return null;
+
+  const cfg = def.cfg as { blocks?: CfgBuildBlock[]; edges?: CfgBuildEdge[] } | undefined;
+  if (!cfg?.blocks?.length) return null;
+
+  return {
+    nodeId,
+    blocks: cfg.blocks.map((b) => ({
+      index: b.index,
+      blockType: b.type,
+      startLine: b.startLine ?? undefined,
+      endLine: b.endLine ?? undefined,
+      label: b.label ?? undefined,
+    })),
+    edges: (cfg.edges || []).map((e) => ({
+      sourceIndex: e.sourceIndex,
+      targetIndex: e.targetIndex,
+      kind: e.kind,
+    })),
+  };
+}
 
-  // ── Native bulk-insert fast path ──────────────────────────────────────
-  // The Rust bulkInsertCfg handles delete-before-insert atomically on a
-  // single rusqlite connection, so there is no dual-connection WAL conflict.
+/**
+ * Native bulk-insert fast path. The Rust bulkInsertCfg handles
+ * delete-before-insert atomically on a single rusqlite connection, so there
+ * is no dual-connection WAL conflict. Returns true if this path handled the
+ * request (caller should return early); false to fall through to WASM/JS.
+ */
+function tryNativeBulkInsertCfg(
+  db: BetterSqlite3Database,
+  fileSymbols: Map<string, FileSymbols>,
+  engineOpts:
+    | {
+        nativeDb?: { bulkInsertCfg?(entries: Array<Record<string, unknown>>): number };
+        suspendJsDb?: () => void;
+        resumeJsDb?: () => void;
+      }
+    | undefined,
+): boolean {
   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;
+  if (!nativeDb?.bulkInsertCfg) return false;
 
-      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 = def.cfg as { blocks?: CfgBuildBlock[]; edges?: CfgBuildEdge[] } | undefined;
-        if (!cfg?.blocks?.length) continue;
-
-        entries.push({
-          nodeId,
-          blocks: cfg.blocks.map((b) => ({
-            index: b.index,
-            blockType: b.type,
-            startLine: b.startLine ?? undefined,
-            endLine: b.endLine ?? undefined,
-            label: b.label ?? undefined,
-          })),
-          edges: (cfg.edges || []).map((e) => ({
-            sourceIndex: e.sourceIndex,
-            targetIndex: e.targetIndex,
-            kind: e.kind,
-          })),
-        });
-      }
-    }
+  const entries: Array<Record<string, unknown>> = [];
+  for (const [relPath, symbols] of fileSymbols) {
+    const ext = path.extname(relPath).toLowerCase();
+    if (!CFG_EXTENSIONS.has(ext)) continue;
 
-    if (entries.length > 0) {
-      let inserted = 0;
-      try {
-        engineOpts?.suspendJsDb?.();
-        inserted = nativeDb.bulkInsertCfg(entries);
-      } finally {
-        engineOpts?.resumeJsDb?.();
-      }
-      info(`CFG (native bulk): ${inserted} functions analyzed`);
+    for (const def of symbols.definitions) {
+      const entry = buildNativeCfgEntry(db, def, relPath);
+      if (entry) entries.push(entry);
     }
-    return;
   }
 
-  const extToLang = buildExtToLangMap();
-  let parsers: unknown = null;
-  let getParserFn: unknown = null;
-
-  if (!allNative) {
-    ({ parsers, getParserFn } = await initCfgParsers(fileSymbols));
+  if (entries.length > 0) {
+    let inserted = 0;
+    try {
+      engineOpts?.suspendJsDb?.();
+      inserted = nativeDb.bulkInsertCfg(entries);
+    } finally {
+      engineOpts?.resumeJsDb?.();
+    }
+    info(`CFG (native bulk): ${inserted} functions analyzed`);
   }
+  return true;
+}
 
+interface CfgInsertStatements {
+  insertBlock: ReturnType<BetterSqlite3Database['prepare']>;
+  insertEdge: ReturnType<BetterSqlite3Database['prepare']>;
+}
+
+function prepareCfgInsertStatements(db: BetterSqlite3Database): CfgInsertStatements {
   const insertBlock = db.prepare(
     `INSERT INTO cfg_blocks (function_node_id, block_index, block_type, start_line, end_line, label)
      VALUES (?, ?, ?, ?, ?, ?)`,
@@ -446,15 +462,31 @@ export async function buildCFGData(
     `INSERT INTO cfg_edges (function_node_id, source_block_id, target_block_id, kind)
      VALUES (?, ?, ?, ?)`,
   );
-  let analyzed = 0;
+  return { insertBlock, insertEdge };
+}
 
+/**
+ * Persist CFG for every CFG-eligible file inside a single transaction.
+ * Dispatches to native fast path or visitor path per file.
+ */
+function persistAllFileCfgs(
+  db: BetterSqlite3Database,
+  fileSymbols: Map<string, FileSymbols>,
+  rootDir: string,
+  allNative: boolean,
+  extToLang: Map<string, string>,
+  parsers: unknown,
+  getParserFn: unknown,
+  stmts: CfgInsertStatements,
+): number {
+  let analyzed = 0;
   const tx = db.transaction(() => {
     for (const [relPath, symbols] of fileSymbols) {
       const ext = path.extname(relPath).toLowerCase();
       if (!CFG_EXTENSIONS.has(ext)) continue;
 
       if (allNative && !symbols._tree) {
-        analyzed += persistNativeFileCfg(db, symbols, relPath, insertBlock, insertEdge);
+        analyzed += persistNativeFileCfg(db, symbols, relPath, stmts.insertBlock, stmts.insertEdge);
         continue;
       }
 
@@ -466,13 +498,52 @@ export async function buildCFGData(
         extToLang,
         parsers,
         getParserFn,
-        insertBlock,
-        insertEdge,
+        stmts.insertBlock,
+        stmts.insertEdge,
       );
     }
   });
-
   tx();
+  return analyzed;
+}
+
+export async function buildCFGData(
+  db: BetterSqlite3Database,
+  fileSymbols: Map<string, FileSymbols>,
+  rootDir: string,
+  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);
+
+  if (allNative && tryNativeBulkInsertCfg(db, fileSymbols, engineOpts)) {
+    return;
+  }
+
+  const extToLang = buildExtToLangMap();
+  let parsers: unknown = null;
+  let getParserFn: unknown = null;
+
+  if (!allNative) {
+    ({ parsers, getParserFn } = await initCfgParsers(fileSymbols));
+  }
+
+  const stmts = prepareCfgInsertStatements(db);
+  const analyzed = persistAllFileCfgs(
+    db,
+    fileSymbols,
+    rootDir,
+    allNative,
+    extToLang,
+    parsers,
+    getParserFn,
+    stmts,
+  );
 
   if (analyzed > 0) {
     info(`CFG: ${analyzed} functions analyzed`);

package/src/features/check.ts

@@ -22,6 +22,29 @@ interface ParsedDiff {
   newFiles: Set<string>;
 }
 
+const HUNK_RE = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/;
+const NEW_FILE_RE = /^\+\+\+ b\/(.+)/;
+
+function pushHunkRanges(
+  line: string,
+  currentFile: string,
+  changedRanges: Map<string, DiffRange[]>,
+  oldRanges: Map<string, DiffRange[]>,
+): void {
+  const hunkMatch = line.match(HUNK_RE);
+  if (!hunkMatch) return;
+  const oldStart = parseInt(hunkMatch[1]!, 10);
+  const oldCount = parseInt(hunkMatch[2] || '1', 10);
+  if (oldCount > 0) {
+    oldRanges.get(currentFile)!.push({ start: oldStart, end: oldStart + oldCount - 1 });
+  }
+  const newStart = parseInt(hunkMatch[3]!, 10);
+  const newCount = parseInt(hunkMatch[4] || '1', 10);
+  if (newCount > 0) {
+    changedRanges.get(currentFile)!.push({ start: newStart, end: newStart + newCount - 1 });
+  }
+}
+
 export function parseDiffOutput(diffOutput: string): ParsedDiff {
   const changedRanges = new Map<string, DiffRange[]>();
   const oldRanges = new Map<string, DiffRange[]>();
@@ -38,7 +61,7 @@ export function parseDiffOutput(diffOutput: string): ParsedDiff {
       prevIsDevNull = false;
       continue;
     }
-    const fileMatch = line.match(/^\+\+\+ b\/(.+)/);
+    const fileMatch = line.match(NEW_FILE_RE);
     if (fileMatch) {
       currentFile = fileMatch[1]!;
       if (!changedRanges.has(currentFile)) changedRanges.set(currentFile, []);
@@ -47,19 +70,7 @@ export function parseDiffOutput(diffOutput: string): ParsedDiff {
       prevIsDevNull = false;
       continue;
     }
-    const hunkMatch = line.match(/^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
-    if (hunkMatch && currentFile) {
-      const oldStart = parseInt(hunkMatch[1]!, 10);
-      const oldCount = parseInt(hunkMatch[2] || '1', 10);
-      if (oldCount > 0) {
-        oldRanges.get(currentFile)!.push({ start: oldStart, end: oldStart + oldCount - 1 });
-      }
-      const newStart = parseInt(hunkMatch[3]!, 10);
-      const newCount = parseInt(hunkMatch[4] || '1', 10);
-      if (newCount > 0) {
-        changedRanges.get(currentFile)!.push({ start: newStart, end: newStart + newCount - 1 });
-      }
-    }
+    if (currentFile) pushHunkRanges(line, currentFile, changedRanges, oldRanges);
   }
   return { changedRanges, oldRanges, newFiles };
 }
@@ -96,6 +107,26 @@ interface BlastRadiusResult {
   violations: BlastRadiusViolation[];
 }
 
+type DefRow = {
+  id: number;
+  name: string;
+  kind: string;
+  file: string;
+  line: number;
+  end_line: number | null;
+};
+
+function rangesOverlap(defLine: number, endLine: number, ranges: DiffRange[]): boolean {
+  for (const range of ranges) {
+    if (range.start <= endLine && range.end >= defLine) return true;
+  }
+  return false;
+}
+
+function defEndLine(def: DefRow, nextDef: DefRow | undefined): number {
+  return def.end_line || (nextDef ? nextDef.line - 1 : 999999);
+}
+
 export function checkMaxBlastRadius(
   db: BetterSqlite3Database,
   changedRanges: Map<string, DiffRange[]>,
@@ -105,34 +136,18 @@ export function checkMaxBlastRadius(
 ): BlastRadiusResult {
   const violations: BlastRadiusViolation[] = [];
   let maxFound = 0;
+  const defsStmt = db.prepare(
+    `SELECT * FROM nodes WHERE file = ? AND kind IN ('function', 'method', 'class') ORDER BY line`,
+  );
 
   for (const [file, ranges] of changedRanges) {
     if (noTests && isTestFile(file)) continue;
-    const defs = db
-      .prepare(
-        `SELECT * FROM nodes WHERE file = ? AND kind IN ('function', 'method', 'class') ORDER BY line`,
-      )
-      .all(file) as Array<{
-      id: number;
-      name: string;
-      kind: string;
-      file: string;
-      line: number;
-      end_line: number | null;
-    }>;
+    const defs = defsStmt.all(file) as DefRow[];
 
     for (let i = 0; i < defs.length; i++) {
       const def = defs[i]!;
-      const nextDef = defs[i + 1];
-      const endLine = def.end_line || (nextDef ? nextDef.line - 1 : 999999);
-      let overlaps = false;
-      for (const range of ranges) {
-        if (range.start <= endLine && range.end >= def.line) {
-          overlaps = true;
-          break;
-        }
-      }
-      if (!overlaps) continue;
+      const endLine = defEndLine(def, defs[i + 1]);
+      if (!rangesOverlap(def.line, endLine, ranges)) continue;
 
       const { totalDependents: totalCallers } = bfsTransitiveCallers(db, def.id, {
         noTests,
@@ -364,11 +379,13 @@ function runPredicates(
   return predicates;
 }
 
-const EMPTY_CHECK: CheckResult = {
-  predicates: [],
-  summary: { total: 0, passed: 0, failed: 0, changedFiles: 0, newFiles: 0 },
-  passed: true,
-};
+function makeEmptyCheck(): CheckResult {
+  return {
+    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);
@@ -394,10 +411,10 @@ export function checkData(customDbPath: string | undefined, opts: CheckOpts = {}
       return { error: `Failed to run git diff: ${(e as Error).message}` };
     }
 
-    if (!diffOutput.trim()) return EMPTY_CHECK;
+    if (!diffOutput.trim()) return makeEmptyCheck();
 
     const diff = parseDiffOutput(diffOutput);
-    if (diff.changedRanges.size === 0) return EMPTY_CHECK;
+    if (diff.changedRanges.size === 0) return makeEmptyCheck();
 
     const predicates = runPredicates(db, diff, flags, repoRoot, noTests, maxDepth);