@optave/codegraph 3.9.2 → 3.9.3

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

@@ -23,7 +23,13 @@ import { loadNative } from '../../../infrastructure/native.js';
 import { semverCompare } from '../../../infrastructure/update-check.js';
 import { toErrorMessage } from '../../../shared/errors.js';
 import { CODEGRAPH_VERSION } from '../../../shared/version.js';
-import type { BuildGraphOpts, BuildResult, Definition, ExtractorOutput } from '../../../types.js';
+import type {
+  BetterSqlite3Database,
+  BuildGraphOpts,
+  BuildResult,
+  Definition,
+  ExtractorOutput,
+} from '../../../types.js';
 import { getActiveEngine } from '../../parser.js';
 import { setWorkspaces } from '../resolve.js';
 import { PipelineContext } from './context.js';
@@ -120,15 +126,11 @@ function setupPipeline(ctx: PipelineContext): void {
   const native = enginePref !== 'wasm' ? loadNative() : null;
   ctx.nativeAvailable = !!native?.NativeDatabase;
 
-  // Native-first: use only rusqlite for the entire pipeline (no better-sqlite3).
-  // This eliminates the dual-connection WAL corruption problem and enables all
-  // native fast-paths (bulkInsertNodes, classifyRolesFull, etc.).
-  // Fallback: if native is unavailable or FORCE_JS is set, use better-sqlite3.
-  if (
-    ctx.nativeAvailable &&
-    native?.NativeDatabase &&
-    process.env.CODEGRAPH_FORCE_JS_PIPELINE !== '1'
-  ) {
+  // When native is available, use a NativeDbProxy backed by a single rusqlite
+  // connection. This eliminates the dual-connection WAL corruption problem.
+  // The Rust orchestrator handles the full pipeline; the proxy is used for any
+  // JS post-processing (e.g. structure fallback on large builds).
+  if (ctx.nativeAvailable && native?.NativeDatabase) {
     try {
       const dir = path.dirname(ctx.dbPath);
       if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
@@ -264,13 +266,14 @@ interface NativeOrchestratorResult {
   structureScope?: string[];
   /** Whether the Rust pipeline handled the structure phase (small-incremental fast path). */
   structureHandled?: boolean;
+  /** Whether the Rust pipeline wrote AST/complexity/CFG/dataflow to DB. */
+  analysisComplete?: boolean;
 }
 
 // ── Native orchestrator helpers ───────────────────────────────────────
 
 /** Determine whether the native orchestrator should be skipped. Returns a reason string, or null if it should run. */
 function shouldSkipNativeOrchestrator(ctx: PipelineContext): string | null {
-  if (process.env.CODEGRAPH_FORCE_JS_PIPELINE === '1') return 'CODEGRAPH_FORCE_JS_PIPELINE=1';
   if (ctx.forceFullRebuild) return 'forceFullRebuild';
   // v3.9.0 addon had buggy incremental purge (wrong SQL on analysis tables,
   // scoped removal over-detection). Fixed in v3.9.1 by PR #865. Gate on
@@ -452,7 +455,11 @@ async function runPostNativeStructure(
   return performance.now() - structureStart;
 }
 
-/** Run AST/complexity/CFG/dataflow analysis after native orchestrator. */
+/**
+ * JS fallback for AST/complexity/CFG/dataflow analysis after native orchestrator.
+ * Used when the Rust addon doesn't include analysis persistence (older addon
+ * version) or when analysis failed on the Rust side.
+ */
 async function runPostNativeAnalysis(
   ctx: PipelineContext,
   allFileSymbols: Map<string, ExtractorOutput>,
@@ -472,30 +479,43 @@ async function runPostNativeAnalysis(
     analysisFileSymbols = allFileSymbols;
   }
 
-  // In native-first mode, nativeDb is already open — no reopen needed.
-  if (!ctx.nativeFirstProxy) {
-    const native = loadNative();
-    if (native?.NativeDatabase) {
-      try {
-        ctx.nativeDb = native.NativeDatabase.openReadWrite(ctx.dbPath);
-        if (ctx.engineOpts) ctx.engineOpts.nativeDb = ctx.nativeDb;
-      } catch {
-        ctx.nativeDb = undefined;
-        if (ctx.engineOpts) ctx.engineOpts.nativeDb = undefined;
-      }
+  // Reopen nativeDb for analysis features (suspend/resume WAL pattern).
+  const native = loadNative();
+  if (native?.NativeDatabase) {
+    try {
+      ctx.nativeDb = native.NativeDatabase.openReadWrite(ctx.dbPath);
+      if (ctx.engineOpts) ctx.engineOpts.nativeDb = ctx.nativeDb;
+    } catch {
+      ctx.nativeDb = undefined;
+      if (ctx.engineOpts) ctx.engineOpts.nativeDb = undefined;
     }
-  } else if (ctx.engineOpts) {
-    ctx.engineOpts.nativeDb = ctx.nativeDb;
+  }
+
+  // Flush JS WAL pages once so Rust can see them, then no-op callbacks.
+  // Previously each feature called wal_checkpoint(TRUNCATE) individually
+  // (~68ms each × 3-4 features). One FULL checkpoint suffices.
+  if (ctx.nativeDb && ctx.engineOpts) {
+    ctx.db.pragma('wal_checkpoint(FULL)');
+    ctx.engineOpts.suspendJsDb = () => {};
+    ctx.engineOpts.resumeJsDb = () => {};
   }
 
   try {
-    const { runAnalyses: runAnalysesFn } = await import('../../../ast-analysis/engine.js');
+    const { runAnalyses: runAnalysesFn } = (await import('../../../ast-analysis/engine.js')) as {
+      runAnalyses: (
+        db: BetterSqlite3Database,
+        fileSymbols: Map<string, ExtractorOutput>,
+        rootDir: string,
+        opts: Record<string, unknown>,
+        engineOpts?: Record<string, unknown>,
+      ) => Promise<{ astMs?: number; complexityMs?: number; cfgMs?: number; dataflowMs?: number }>;
+    };
     const result = await runAnalysesFn(
       ctx.db,
       analysisFileSymbols,
       ctx.rootDir,
-      ctx.opts,
-      ctx.engineOpts,
+      ctx.opts as Record<string, unknown>,
+      ctx.engineOpts as unknown as Record<string, unknown> | undefined,
     );
     timing.astMs = result.astMs ?? 0;
     timing.complexityMs = result.complexityMs ?? 0;
@@ -505,8 +525,10 @@ async function runPostNativeAnalysis(
     warn(`Analysis phases failed after native build: ${toErrorMessage(err)}`);
   }
 
-  // Close nativeDb after analyses (skip in native-first — single connection stays open)
-  if (ctx.nativeDb && !ctx.nativeFirstProxy) {
+  // Close nativeDb after analyses — TRUNCATE checkpoint flushes all Rust
+  // WAL writes so JS and external readers can see them. Runs once after
+  // all analysis features complete (not per-feature).
+  if (ctx.nativeDb) {
     try {
       ctx.nativeDb.exec('PRAGMA wal_checkpoint(TRUNCATE)');
     } catch {
@@ -518,7 +540,11 @@ async function runPostNativeAnalysis(
       /* ignore close errors */
     }
     ctx.nativeDb = undefined;
-    if (ctx.engineOpts) ctx.engineOpts.nativeDb = undefined;
+    if (ctx.engineOpts) {
+      ctx.engineOpts.nativeDb = undefined;
+      ctx.engineOpts.suspendJsDb = undefined;
+      ctx.engineOpts.resumeJsDb = undefined;
+    }
   }
 
   return timing;
@@ -620,30 +646,40 @@ async function tryNativeOrchestrator(
   );
 
   // ── Post-native structure + analysis ──────────────────────────────
-  let analysisTiming = { astMs: 0, complexityMs: 0, cfgMs: 0, dataflowMs: 0 };
+  let analysisTiming = {
+    astMs: +(p.astMs ?? 0),
+    complexityMs: +(p.complexityMs ?? 0),
+    cfgMs: +(p.cfgMs ?? 0),
+    dataflowMs: +(p.dataflowMs ?? 0),
+  };
   let structurePatchMs = 0;
-  const needsAnalysis =
-    ctx.opts.ast !== false ||
-    ctx.opts.complexity !== false ||
-    ctx.opts.cfg !== false ||
-    ctx.opts.dataflow !== false;
   // Skip JS structure when the Rust pipeline's small-incremental fast path
   // already handled it. For full builds and large incrementals where Rust
   // skipped structure, we must run the JS fallback.
   const needsStructure = !result.structureHandled;
-
-  if (needsAnalysis || needsStructure) {
-    // In native-first mode the proxy is already wired — no WAL handoff needed.
-    if (!ctx.nativeFirstProxy && !handoffWalAfterNativeBuild(ctx)) {
+  // When the Rust addon doesn't include analysis persistence (older addon
+  // version or analysis failed), fall back to JS-side analysis.
+  const needsAnalysisFallback =
+    !result.analysisComplete &&
+    (ctx.opts.ast !== false ||
+      ctx.opts.complexity !== false ||
+      ctx.opts.cfg !== false ||
+      ctx.opts.dataflow !== false);
+
+  if (needsStructure || needsAnalysisFallback) {
+    // When analysis fallback is needed, handoff to better-sqlite3 — the
+    // analysis engine uses the suspend/resume WAL pattern that requires a
+    // real better-sqlite3 connection, not the NativeDbProxy.
+    if (needsAnalysisFallback && ctx.nativeFirstProxy) {
+      closeNativeDb(ctx, 'pre-analysis-fallback');
+      ctx.db = openDb(ctx.dbPath);
+      ctx.nativeFirstProxy = false;
+    } else if (!ctx.nativeFirstProxy && !handoffWalAfterNativeBuild(ctx)) {
       // DB reopen failed — return partial result
       return formatNativeTimingResult(p, 0, analysisTiming);
     }
 
-    // When structure was handled by Rust, we only need changed files for
-    // analysis — no need to load the entire graph from DB. When structure
-    // was NOT handled, we need all files to build the complete directory tree.
-    const scopeFiles = needsStructure ? undefined : result.changedFiles;
-    const fileSymbols = reconstructFileSymbolsFromDb(ctx, scopeFiles);
+    const fileSymbols = reconstructFileSymbolsFromDb(ctx);
 
     if (needsStructure) {
       structurePatchMs = await runPostNativeStructure(
@@ -654,7 +690,7 @@ async function tryNativeOrchestrator(
       );
     }
 
-    if (needsAnalysis) {
+    if (needsAnalysisFallback) {
       analysisTiming = await runPostNativeAnalysis(ctx, fileSymbols, result.changedFiles);
     }
   }
@@ -666,30 +702,7 @@ async function tryNativeOrchestrator(
 // ── Pipeline stages execution ───────────────────────────────────────────
 
 async function runPipelineStages(ctx: PipelineContext): Promise<void> {
-  // ── Native-first mode ────────────────────────────────────────────────
-  // When ctx.nativeFirstProxy is true, ctx.db is a NativeDbProxy backed by
-  // the single rusqlite connection (ctx.nativeDb). No dual-connection WAL
-  // dance is needed — every stage uses the same connection transparently.
-  if (ctx.nativeFirstProxy) {
-    // Ensure engineOpts.nativeDb is set so stages can use dedicated native methods.
-    if (ctx.engineOpts) {
-      ctx.engineOpts.nativeDb = ctx.nativeDb;
-    }
-
-    await collectFiles(ctx);
-    await detectChanges(ctx);
-    if (ctx.earlyExit) return;
-    await parseFiles(ctx);
-    await insertNodes(ctx);
-    await resolveImports(ctx);
-    await buildEdges(ctx);
-    await buildStructure(ctx);
-    await runAnalyses(ctx);
-    await finalize(ctx);
-    return;
-  }
-
-  // ── Legacy dual-connection mode (WASM / fallback) ────────────────────
+  // ── WASM / fallback dual-connection mode ─────────────────────────────
   // NativeDatabase is deferred — not opened during setup. collectFiles and
   // detectChanges only need better-sqlite3. If no files changed, we exit
   // early without ever opening the native connection, saving ~5ms.
@@ -697,6 +710,13 @@ async function runPipelineStages(ctx: PipelineContext): Promise<void> {
   // suspend it now to avoid dual-connection WAL corruption during stages.
   if (ctx.db && ctx.nativeDb) {
     suspendNativeDb(ctx, 'pre-collect');
+    // When nativeFirstProxy is true, ctx.db is a NativeDbProxy wrapping the
+    // now-closed NativeDatabase. Replace it with a real better-sqlite3
+    // connection so the JS pipeline stages can operate normally.
+    if (ctx.nativeFirstProxy) {
+      ctx.db = openDb(ctx.dbPath);
+      ctx.nativeFirstProxy = false;
+    }
   }
 
   await collectFiles(ctx);
@@ -728,25 +748,20 @@ async function runPipelineStages(ctx: PipelineContext): Promise<void> {
   await buildEdges(ctx);
   await buildStructure(ctx);
 
-  // Reopen nativeDb for feature modules (ast, cfg, complexity, dataflow)
-  // which use suspendJsDb/resumeJsDb WAL checkpoint before native writes.
+  // Reopen nativeDb for feature modules (ast, cfg, complexity, dataflow).
   // Skip for small incremental builds — same rationale as insertNodes above.
+  //
+  // Perf: do ONE upfront FULL checkpoint to flush JS WAL pages so Rust
+  // can see the latest rows, then make suspendJsDb/resumeJsDb no-ops.
+  // Previously each feature called wal_checkpoint(TRUNCATE) individually
+  // (~68ms each × 3-4 features = ~200-270ms overhead on incremental builds).
   if (ctx.nativeAvailable && !smallIncremental) {
     reopenNativeDb(ctx, 'analyses');
     if (ctx.nativeDb && ctx.engineOpts) {
+      ctx.db.pragma('wal_checkpoint(FULL)');
       ctx.engineOpts.nativeDb = ctx.nativeDb;
-      ctx.engineOpts.suspendJsDb = () => {
-        ctx.db.pragma('wal_checkpoint(TRUNCATE)');
-      };
-      ctx.engineOpts.resumeJsDb = () => {
-        try {
-          ctx.nativeDb?.exec('PRAGMA wal_checkpoint(TRUNCATE)');
-        } catch (e) {
-          debug(
-            `resumeJsDb: WAL checkpoint failed (nativeDb may already be closed): ${toErrorMessage(e)}`,
-          );
-        }
-      };
+      ctx.engineOpts.suspendJsDb = () => {};
+      ctx.engineOpts.resumeJsDb = () => {};
     }
     if (!ctx.nativeDb && ctx.engineOpts) {
       ctx.engineOpts.nativeDb = undefined;
@@ -757,11 +772,15 @@ async function runPipelineStages(ctx: PipelineContext): Promise<void> {
 
   await runAnalyses(ctx);
 
-  // Keep nativeDb open through finalize so persistBuildMetadata, advisory
-  // checks, and count queries use the native path.  closeDbPair inside
-  // finalize handles both connections.  Refresh the JS db so it has a
-  // valid page cache in case finalize falls back to JS paths (#751).
+  // Flush Rust WAL writes (AST, complexity, CFG, dataflow) so the JS
+  // connection and any post-build readers can see them.  One TRUNCATE
+  // here replaces the N per-feature resumeJsDb checkpoints (#checkpoint-opt).
   if (ctx.nativeDb) {
+    try {
+      ctx.nativeDb.exec('PRAGMA wal_checkpoint(TRUNCATE)');
+    } catch (e) {
+      debug(`post-analyses WAL checkpoint failed: ${toErrorMessage(e)}`);
+    }
     refreshJsDb(ctx);
   }
 

package/src/domain/parser.ts

@@ -780,7 +780,7 @@ export async function parseFileAuto(
   const { native } = resolveEngine(opts);
 
   if (native) {
-    const result = native.parseFile(filePath, source, !!opts.dataflow, opts.ast !== false);
+    const result = native.parseFile(filePath, source, true, true);
     if (!result) return null;
     const patched = patchNativeResult(result);
     // Always backfill typeMap for TS/TSX from WASM — native parser's type
@@ -878,7 +878,11 @@ export async function parseFilesAuto(
   if (!native) return parseFilesWasm(filePaths, rootDir);
 
   const result = new Map<string, ExtractorOutput>();
-  const nativeResults = native.parseFiles(filePaths, rootDir, !!opts.dataflow, opts.ast !== false);
+  // Always extract all analysis data (dataflow + AST nodes) during native parse.
+  // This eliminates the need for any downstream WASM re-parse or native standalone calls.
+  const nativeResults = native.parseFilesFull
+    ? native.parseFilesFull(filePaths, rootDir)
+    : native.parseFiles(filePaths, rootDir, true, true);
   const needsTypeMap: { filePath: string; relPath: string }[] = [];
   for (const r of nativeResults) {
     if (!r) continue;

package/src/features/ast.ts

@@ -115,8 +115,8 @@ function tryNativeBulkInsert(
           receiver: n.receiver ?? '',
         })),
       });
-    } else if (symbols.calls || symbols._tree) {
-      return false; // needs JS fallback
+    } else if (symbols._tree) {
+      return false; // has WASM tree not yet processed — needs JS fallback
     }
   }
 

package/src/features/cfg.ts

@@ -369,7 +369,7 @@ export async function buildCFGData(
   db: BetterSqlite3Database,
   fileSymbols: Map<string, FileSymbols>,
   rootDir: string,
-  _engineOpts?: {
+  engineOpts?: {
     nativeDb?: { bulkInsertCfg?(entries: Array<Record<string, unknown>>): number };
     suspendJsDb?: () => void;
     resumeJsDb?: () => void;
@@ -379,11 +379,56 @@ export async function buildCFGData(
   // 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.
+  // ── 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.
+  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;
+
+        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,
+          })),
+        });
+      }
+    }
+
+    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;
+  }
 
   const extToLang = buildExtToLangMap();
   let parsers: unknown = null;

package/src/features/complexity.ts

@@ -545,6 +545,10 @@ function collectNativeBulkRows(
   const rows: Array<Record<string, unknown>> = [];
 
   for (const [relPath, symbols] of fileSymbols) {
+    const ext = path.extname(relPath).toLowerCase();
+    const langId = symbols._langId || '';
+    const langSupported = COMPLEXITY_EXTENSIONS.has(ext) || COMPLEXITY_RULES.has(langId);
+
     for (const def of symbols.definitions) {
       if (def.kind !== 'function' && def.kind !== 'method') continue;
       if (!def.line) continue;
@@ -554,6 +558,9 @@ function collectNativeBulkRows(
       // of the native bulk-insert path for every TypeScript codebase (#846).
       if (!def.complexity) {
         if (def.name.includes('.') || !def.endLine || def.endLine <= def.line) continue;
+        // Languages without complexity rules will never have data — skip them
+        // rather than bailing out of the entire native bulk path.
+        if (!langSupported) continue;
         return null; // genuine function body missing complexity — needs JS fallback
       }
       const nodeId = getFunctionNodeId(db, def.name, relPath, def.line);

package/src/infrastructure/update-check.ts

@@ -18,11 +18,11 @@ interface UpdateCache {
 
 /**
  * Minimal semver comparison. Returns -1, 0, or 1.
- * Only handles numeric x.y.z (no pre-release tags).
+ * Strips pre-release suffixes (e.g. "3.9.3-dev.6" → "3.9.3") before comparing.
  */
 export function semverCompare(a: string, b: string): -1 | 0 | 1 {
-  const pa = a.split('.').map(Number);
-  const pb = b.split('.').map(Number);
+  const pa = a.replace(/-.*$/, '').split('.').map(Number);
+  const pb = b.replace(/-.*$/, '').split('.').map(Number);
   for (let i = 0; i < 3; i++) {
     const na = pa[i] || 0;
     const nb = pb[i] || 0;

package/src/types.ts

@@ -1874,6 +1874,7 @@ export type StmtCache<TRow = unknown> = WeakMap<BetterSqlite3Database, SqliteSta
 export interface NativeAddon {
   parseFile(filePath: string, source: string, dataflow: boolean, ast: boolean): unknown;
   parseFiles(files: string[], rootDir: string, dataflow: boolean, ast: boolean): unknown[];
+  parseFilesFull?(files: string[], rootDir: string): unknown[];
   resolveImport(fromFile: string, importSource: string, rootDir: string, aliases: unknown): string;
   resolveImports(
     items: Array<{ fromFile: string; importSource: string }>,