@optave/codegraph 3.7.0 → 3.8.0

package/src/ast-analysis/engine.ts

@@ -15,10 +15,12 @@
  * output). This eliminates redundant tree traversals per file.
  */
 
+import fs from 'node:fs';
 import path from 'node:path';
 import { performance } from 'node:perf_hooks';
 import { bulkNodeIdsByFile } from '../db/index.js';
 import { debug } from '../infrastructure/logger.js';
+import { loadNative } from '../infrastructure/native.js';
 import type {
   AnalysisOpts,
   AnalysisTiming,
@@ -30,6 +32,9 @@ import type {
   Definition,
   EngineOpts,
   ExtractorOutput,
+  NativeAddon,
+  NativeFunctionCfgResult,
+  NativeFunctionComplexityResult,
   TreeSitterNode,
   Visitor,
   WalkOptions,
@@ -95,6 +100,173 @@ async function getParserModule(): Promise<typeof import('../domain/parser.js')>
   return _parserModule;
 }
 
+// ─── Native standalone analysis ─────────────────────────────────────────
+
+/**
+ * Try native Rust analysis for files missing complexity/CFG/dataflow data.
+ * Reads source from disk, calls the native standalone functions, and stores
+ * results directly on definitions/symbols. Returns the set of files that
+ * were fully handled (no remaining gaps except possibly AST store).
+ */
+function runNativeAnalysis(
+  native: NativeAddon,
+  fileSymbols: Map<string, ExtractorOutput>,
+  rootDir: string,
+  opts: AnalysisOpts,
+  extToLang: Map<string, string>,
+): void {
+  const doComplexity = opts.complexity !== false;
+  const doCfg = opts.cfg !== false;
+  const doDataflow = opts.dataflow !== false;
+
+  for (const [relPath, symbols] of fileSymbols) {
+    if (symbols._tree) continue; // already has WASM tree, skip native
+    const ext = path.extname(relPath).toLowerCase();
+    const langId = symbols._langId || extToLang.get(ext);
+    if (!langId) continue;
+
+    const defs = symbols.definitions || [];
+
+    const needsComplexity =
+      doComplexity &&
+      COMPLEXITY_EXTENSIONS.has(ext) &&
+      defs.some((d) => hasFuncBody(d) && !d.complexity);
+    const needsCfg =
+      doCfg &&
+      CFG_EXTENSIONS.has(ext) &&
+      defs.some((d) => hasFuncBody(d) && d.cfg !== null && !Array.isArray(d.cfg?.blocks));
+    const needsDataflow = doDataflow && !symbols.dataflow && DATAFLOW_EXTENSIONS.has(ext);
+
+    if (!needsComplexity && !needsCfg && !needsDataflow) continue;
+
+    // Read source from disk
+    const absPath = path.join(rootDir, relPath);
+    let source: string;
+    try {
+      source = fs.readFileSync(absPath, 'utf-8');
+    } catch {
+      continue;
+    }
+
+    // Complexity
+    if (needsComplexity && native.analyzeComplexity) {
+      try {
+        const results = native.analyzeComplexity(source, absPath);
+        storeNativeComplexityResults(results, defs);
+      } catch (err: unknown) {
+        debug(`native analyzeComplexity failed for ${relPath}: ${(err as Error).message}`);
+      }
+    }
+
+    // CFG
+    if (needsCfg && native.buildCfgAnalysis) {
+      try {
+        const results = native.buildCfgAnalysis(source, absPath);
+        storeNativeCfgResults(results, defs);
+      } catch (err: unknown) {
+        debug(`native buildCfgAnalysis failed for ${relPath}: ${(err as Error).message}`);
+      }
+    }
+
+    // Dataflow
+    if (needsDataflow && native.extractDataflowAnalysis) {
+      try {
+        const result = native.extractDataflowAnalysis(source, absPath);
+        if (result) symbols.dataflow = result;
+      } catch (err: unknown) {
+        debug(`native extractDataflowAnalysis failed for ${relPath}: ${(err as Error).message}`);
+      }
+    }
+  }
+}
+
+/** Store native complexity results on definitions, matched by line number. */
+function storeNativeComplexityResults(
+  results: NativeFunctionComplexityResult[],
+  defs: Definition[],
+): void {
+  const byLine = new Map<number, NativeFunctionComplexityResult[]>();
+  for (const r of results) {
+    if (!byLine.has(r.line)) byLine.set(r.line, []);
+    byLine.get(r.line)!.push(r);
+  }
+
+  for (const def of defs) {
+    if ((def.kind === 'function' || def.kind === 'method') && def.line && !def.complexity) {
+      const candidates = byLine.get(def.line);
+      if (!candidates) continue;
+      const match =
+        candidates.length === 1
+          ? candidates[0]
+          : (candidates.find((r) => r.name === def.name) ?? candidates[0]);
+      if (!match) continue;
+      const { complexity: c } = match;
+      def.complexity = {
+        cognitive: c.cognitive,
+        cyclomatic: c.cyclomatic,
+        maxNesting: c.maxNesting,
+        halstead: c.halstead
+          ? {
+              volume: c.halstead.volume,
+              difficulty: c.halstead.difficulty,
+              effort: c.halstead.effort,
+              bugs: c.halstead.bugs,
+            }
+          : undefined,
+        loc: c.loc
+          ? { loc: c.loc.loc, sloc: c.loc.sloc, commentLines: c.loc.commentLines }
+          : undefined,
+        maintainabilityIndex: c.maintainabilityIndex ?? undefined,
+      };
+    }
+  }
+}
+
+/** Store native CFG results on definitions, matched by line number. */
+function storeNativeCfgResults(results: NativeFunctionCfgResult[], defs: Definition[]): void {
+  const byLine = new Map<number, NativeFunctionCfgResult[]>();
+  for (const r of results) {
+    if (!byLine.has(r.line)) byLine.set(r.line, []);
+    byLine.get(r.line)!.push(r);
+  }
+
+  for (const def of defs) {
+    if (
+      (def.kind === 'function' || def.kind === 'method') &&
+      def.line &&
+      def.cfg !== null &&
+      !def.cfg?.blocks?.length
+    ) {
+      const candidates = byLine.get(def.line);
+      if (!candidates) continue;
+      const match =
+        candidates.length === 1
+          ? candidates[0]
+          : (candidates.find((r) => r.name === def.name) ?? candidates[0]);
+      if (!match) continue;
+      def.cfg = match.cfg;
+
+      // Override complexity cyclomatic with CFG-derived value
+      const { edges, blocks } = match.cfg;
+      if (def.complexity && edges && blocks) {
+        const cfgCyclomatic = edges.length - blocks.length + 2;
+        if (cfgCyclomatic > 0) {
+          def.complexity.cyclomatic = cfgCyclomatic;
+          const { loc, halstead } = def.complexity;
+          const volume = halstead ? halstead.volume : 0;
+          const commentRatio = loc && loc.loc > 0 ? loc.commentLines / loc.loc : 0;
+          def.complexity.maintainabilityIndex = computeMaintainabilityIndex(
+            volume,
+            cfgCyclomatic,
+            loc?.sloc ?? 0,
+            commentRatio,
+          );
+        }
+      }
+    }
+  }
+}
+
 // ─── WASM pre-parse ─────────────────────────────────────────────────────
 
 async function ensureWasmTreesIfNeeded(
@@ -429,7 +601,17 @@ export async function runAnalyses(
 
   const extToLang = buildExtToLangMap();
 
-  // WASM pre-parse for files that need it
+  // Native analysis pass: try Rust standalone functions before WASM fallback.
+  // This fills in complexity/CFG/dataflow for files that the native parse pipeline
+  // missed, avoiding the need to parse with WASM + run JS visitors.
+  const native = loadNative();
+  if (native?.analyzeComplexity ?? native?.buildCfgAnalysis ?? native?.extractDataflowAnalysis) {
+    const t0native = performance.now();
+    runNativeAnalysis(native, fileSymbols, rootDir, opts, extToLang);
+    debug(`native standalone analysis: ${(performance.now() - t0native).toFixed(1)}ms`);
+  }
+
+  // WASM pre-parse for files that still need it (AST store, or native gaps)
   await ensureWasmTreesIfNeeded(fileSymbols, opts, rootDir);
 
   // Unified pre-walk: run all applicable visitors in a single DFS per file

package/src/ast-analysis/rules/javascript.ts

@@ -237,7 +237,6 @@ export const dataflow: DataflowRulesConfig = makeDataflowRules({
 // ─── AST Node Types ───────────────────────────────────────────────────────
 
 export const astTypes: Record<string, string> | null = {
-  call_expression: 'call',
   new_expression: 'new',
   throw_statement: 'throw',
   await_expression: 'await',

package/src/ast-analysis/visitors/ast-store-visitor.ts

@@ -44,22 +44,6 @@ function extractExpressionText(node: TreeSitterNode): string | null {
   return truncate(node.text);
 }
 
-function extractCallName(node: TreeSitterNode): string {
-  for (const field of ['function', 'method', 'name']) {
-    const fn = node.childForFieldName(field);
-    if (fn) return fn.text;
-  }
-  return node.text?.split('(')[0] || '?';
-}
-
-/** Extract receiver for call expressions (e.g. "obj" in "obj.method()"). */
-function extractCallReceiver(node: TreeSitterNode): string | null {
-  const fn = node.childForFieldName('function');
-  if (!fn || fn.type !== 'member_expression') return null;
-  const obj = fn.childForFieldName('object');
-  return obj ? obj.text : null;
-}
-
 function extractName(kind: string, node: TreeSitterNode): string | null {
   if (kind === 'throw') {
     for (let i = 0; i < node.childCount; i++) {
@@ -118,64 +102,14 @@ export function createAstStoreVisitor(
     return nodeIdMap.get(`${parentDef.name}|${parentDef.kind}|${parentDef.line}`) || null;
   }
 
-  /** Recursively walk a subtree collecting AST nodes — used for arguments-only traversal. */
-  function walkSubtree(node: TreeSitterNode | null): void {
-    if (!node) return;
-    if (matched.has(node.id)) return;
-
-    const kind = astTypeMap[node.type];
-    if (kind === 'call') {
-      // Capture this call and recurse only into its arguments
-      collectNode(node, kind);
-      walkCallArguments(node);
-      return;
-    }
-    if (kind) {
-      collectNode(node, kind);
-      if (kind !== 'string' && kind !== 'regex') return; // skipChildren for non-leaf kinds
-    }
-    for (let i = 0; i < node.childCount; i++) {
-      walkSubtree(node.child(i));
-    }
-  }
-
-  /**
-   * Recurse into only the arguments of a call node — mirrors the native engine's
-   * strategy that prevents double-counting nested calls in the function field
-   * (e.g. chained calls like `a().b()`).
-   */
-  function walkCallArguments(callNode: TreeSitterNode): void {
-    // Try field-based lookup first, fall back to kind-based matching
-    const argsNode =
-      callNode.childForFieldName('arguments') ??
-      findChildByKind(callNode, ['arguments', 'argument_list', 'method_arguments']);
-    if (!argsNode) return;
-    for (let i = 0; i < argsNode.childCount; i++) {
-      walkSubtree(argsNode.child(i));
-    }
-  }
-
-  function findChildByKind(node: TreeSitterNode, kinds: string[]): TreeSitterNode | null {
-    for (let i = 0; i < node.childCount; i++) {
-      const child = node.child(i);
-      if (child && kinds.includes(child.type)) return child;
-    }
-    return null;
-  }
-
   function collectNode(node: TreeSitterNode, kind: string): void {
     if (matched.has(node.id)) return;
 
     const line = node.startPosition.row + 1;
     let name: string | null | undefined;
     let text: string | null = null;
-    let receiver: string | null = null;
 
-    if (kind === 'call') {
-      name = extractCallName(node);
-      text = truncate(node.text);
-      receiver = extractCallReceiver(node);
-    } else if (kind === 'new') {
+    if (kind === 'new') {
       name = extractNewName(node);
       text = truncate(node.text);
     } else if (kind === 'throw') {
@@ -200,7 +134,7 @@ export function createAstStoreVisitor(
       kind,
       name,
       text,
-      receiver,
+      receiver: null,
       parentNodeId: resolveParentNodeId(line),
     });
 
@@ -221,13 +155,6 @@ export function createAstStoreVisitor(
 
       collectNode(node, kind);
 
-      if (kind === 'call') {
-        // Mirror native: skip full subtree, recurse only into arguments.
-        // Prevents double-counting chained calls like service.getUser().getName().
-        walkCallArguments(node);
-        return { skipChildren: true };
-      }
-
       if (kind !== 'string' && kind !== 'regex') {
         return { skipChildren: true };
       }

package/src/cli/commands/ast.ts

@@ -4,10 +4,10 @@ import type { CommandDefinition } from '../types.js';
 
 export const command: CommandDefinition = {
   name: 'ast [pattern]',
-  description: 'Search stored AST nodes (calls, new, string, regex, throw, await) by pattern',
+  description: 'Search stored AST nodes (new, string, regex, throw, await) by pattern',
   queryOpts: true,
   options: [
-    ['-k, --kind <kind>', 'Filter by AST node kind (call, new, string, regex, throw, await)'],
+    ['-k, --kind <kind>', 'Filter by AST node kind (new, string, regex, throw, await)'],
     ['-f, --file <path>', 'Scope to file (partial match, repeatable)', collectFile],
   ],
   async execute([pattern], opts, ctx) {

package/src/domain/graph/builder/pipeline.ts

@@ -35,18 +35,26 @@ function initializeEngine(ctx: PipelineContext): void {
     dataflow: ctx.opts.dataflow !== false,
     ast: ctx.opts.ast !== false,
     nativeDb: ctx.nativeDb,
-    // WAL checkpoint callbacks for dual-connection WAL guard (#696).
+    // WAL checkpoint callbacks for dual-connection WAL guard (#696, #715).
     // Feature modules (ast, cfg, complexity, dataflow) receive `db` as a
     // parameter and cannot tolerate close/reopen (stale reference). Instead,
-    // checkpoint the WAL so native writes start with a clean slate. Features
-    // return early on native success and never read native-written WAL data
-    // through the JS connection, so a post-write checkpoint is unnecessary.
+    // checkpoint the WAL so native writes start with a clean slate.
+    // After native writes, resumeJsDb checkpoints through rusqlite so
+    // better-sqlite3 never reads WAL frames from a different SQLite library.
     suspendJsDb: ctx.nativeDb
       ? () => {
           ctx.db.pragma('wal_checkpoint(TRUNCATE)');
         }
       : undefined,
-    resumeJsDb: ctx.nativeDb ? () => {} : undefined,
+    resumeJsDb: ctx.nativeDb
+      ? () => {
+          try {
+            ctx.nativeDb?.exec('PRAGMA wal_checkpoint(TRUNCATE)');
+          } catch {
+            /* ignore — nativeDb may already be closed */
+          }
+        }
+      : undefined,
   };
   const { name: engineName, version: engineVersion } = getActiveEngine(ctx.engineOpts);
   ctx.engineName = engineName as 'native' | 'wasm';
@@ -120,8 +128,16 @@ function setupPipeline(ctx: PipelineContext): void {
     try {
       ctx.nativeDb = native.NativeDatabase.openReadWrite(ctx.dbPath);
       ctx.nativeDb.initSchema();
+      // Checkpoint WAL through rusqlite so better-sqlite3 sees a clean DB
+      // with no cross-library WAL frames (#715, #717).
+      ctx.nativeDb.exec('PRAGMA wal_checkpoint(TRUNCATE)');
     } catch (err) {
-      warn(`NativeDatabase init failed, falling back to JS: ${(err as Error).message}`);
+      warn(`NativeDatabase setup failed, falling back to JS: ${(err as Error).message}`);
+      try {
+        ctx.nativeDb?.close();
+      } catch {
+        /* ignore close errors */
+      }
       ctx.nativeDb = undefined;
     }
     // Always run JS initSchema so better-sqlite3 sees the schema —
@@ -179,6 +195,15 @@ async function runPipelineStages(ctx: PipelineContext): Promise<void> {
   // that use suspendJsDb/resumeJsDb WAL checkpoint pattern (#696).
   const hadNativeDb = !!ctx.nativeDb;
   if (ctx.db && ctx.nativeDb) {
+    // Checkpoint WAL through rusqlite before closing so better-sqlite3 never
+    // needs to apply WAL frames written by a different SQLite library (#715, #717).
+    // Separate try/catch blocks ensure close() always runs even if checkpoint throws,
+    // preventing a live rusqlite connection from lingering until GC.
+    try {
+      ctx.nativeDb.exec('PRAGMA wal_checkpoint(TRUNCATE)');
+    } catch {
+      /* ignore checkpoint errors */
+    }
     try {
       ctx.nativeDb.close();
     } catch {
@@ -198,7 +223,51 @@ async function runPipelineStages(ctx: PipelineContext): Promise<void> {
   if (ctx.earlyExit) return;
 
   await parseFiles(ctx);
+
+  // Temporarily reopen nativeDb for insertNodes — it uses the WAL checkpoint
+  // guard internally (same pattern as feature modules). Closed again before
+  // resolveImports/buildEdges which don't yet have the guard (#709).
+  if (hadNativeDb && ctx.engineName === 'native') {
+    const native = loadNative();
+    if (native?.NativeDatabase) {
+      try {
+        ctx.nativeDb = native.NativeDatabase.openReadWrite(ctx.dbPath);
+      } catch {
+        ctx.nativeDb = undefined;
+      }
+    }
+  }
+
   await insertNodes(ctx);
+
+  // Close nativeDb after insertNodes — remaining pipeline stages use JS paths.
+  if (ctx.nativeDb && ctx.db) {
+    // Checkpoint WAL through rusqlite before closing so better-sqlite3 never
+    // needs to apply WAL frames written by a different SQLite library (#715, #717).
+    try {
+      ctx.nativeDb.exec('PRAGMA wal_checkpoint(TRUNCATE)');
+    } catch {
+      /* ignore checkpoint errors */
+    }
+    try {
+      ctx.nativeDb.close();
+    } catch {
+      /* ignore close errors */
+    }
+    ctx.nativeDb = undefined;
+    // Reopen better-sqlite3 connection to get a fresh page cache.
+    // After rusqlite truncates the WAL, better-sqlite3's internal WAL index
+    // (shared-memory mapping) may reference frames that no longer exist,
+    // causing SQLITE_CORRUPT on the next read. Closing and reopening
+    // forces a clean slate — the only reliable cross-library handoff (#715, #736).
+    try {
+      ctx.db.close();
+    } catch {
+      /* ignore close errors */
+    }
+    ctx.db = openDb(ctx.dbPath);
+  }
+
   await resolveImports(ctx);
   await buildEdges(ctx);
   await buildStructure(ctx);
@@ -227,6 +296,14 @@ async function runPipelineStages(ctx: PipelineContext): Promise<void> {
   // Close nativeDb after analyses — finalize uses JS paths for setBuildMeta
   // and closeDbPair handles cleanup. Avoids dual-connection during finalize.
   if (ctx.nativeDb) {
+    // Checkpoint WAL through rusqlite before closing so better-sqlite3 never
+    // needs to apply WAL frames written by a different SQLite library (#715, #717).
+    // Separate try/catch blocks ensure close() always runs even if checkpoint throws.
+    try {
+      ctx.nativeDb.exec('PRAGMA wal_checkpoint(TRUNCATE)');
+    } catch {
+      /* ignore checkpoint errors */
+    }
     try {
       ctx.nativeDb.close();
     } catch {
@@ -256,6 +333,65 @@ export async function buildGraph(
 
   try {
     setupPipeline(ctx);
+
+    // ── Rust orchestrator fast path (#695) ────────────────────────────
+    // When available, run the entire build pipeline in Rust with zero
+    // napi crossings (eliminates WAL dual-connection dance). Falls back
+    // to the JS pipeline on failure or when native is unavailable.
+    const forceJs = process.env.CODEGRAPH_FORCE_JS_PIPELINE === '1';
+    if (!forceJs && ctx.nativeDb?.buildGraph) {
+      try {
+        const resultJson = ctx.nativeDb.buildGraph(
+          ctx.rootDir,
+          JSON.stringify(ctx.config),
+          JSON.stringify(ctx.aliases),
+          JSON.stringify(opts),
+        );
+        const result = JSON.parse(resultJson) as {
+          phases: Record<string, number>;
+          earlyExit?: boolean;
+          nodeCount?: number;
+          edgeCount?: number;
+          fileCount?: number;
+        };
+
+        if (result.earlyExit) {
+          closeDbPair({ db: ctx.db, nativeDb: ctx.nativeDb });
+          return;
+        }
+
+        // Map Rust timing fields to the JS BuildResult format.
+        // Rust handles collect+detect+parse+insert+resolve+edges+structure+roles.
+        // AST/complexity/CFG/dataflow analyses are not yet ported to Rust.
+        const p = result.phases;
+        closeDbPair({ db: ctx.db, nativeDb: ctx.nativeDb });
+        info(
+          `Native build orchestrator completed: ${result.nodeCount ?? 0} nodes, ${result.edgeCount ?? 0} edges, ${result.fileCount ?? 0} files`,
+        );
+        return {
+          phases: {
+            setupMs: +((p.setupMs ?? 0) + (p.collectMs ?? 0) + (p.detectMs ?? 0)).toFixed(1),
+            parseMs: +(p.parseMs ?? 0).toFixed(1),
+            insertMs: +(p.insertMs ?? 0).toFixed(1),
+            resolveMs: +(p.resolveMs ?? 0).toFixed(1),
+            edgesMs: +(p.edgesMs ?? 0).toFixed(1),
+            structureMs: +(p.structureMs ?? 0).toFixed(1),
+            rolesMs: +(p.rolesMs ?? 0).toFixed(1),
+            astMs: 0,
+            complexityMs: 0,
+            cfgMs: 0,
+            dataflowMs: 0,
+            finalizeMs: +(p.finalizeMs ?? 0).toFixed(1),
+          },
+        };
+      } catch (err) {
+        warn(
+          `Native build orchestrator failed, falling back to JS pipeline: ${(err as Error).message}`,
+        );
+        // Fall through to JS pipeline
+      }
+    }
+
     await runPipelineStages(ctx);
   } catch (err) {
     if (!ctx.earlyExit && ctx.db) {