@optave/codegraph 3.9.3 → 3.9.4

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

@@ -88,10 +88,17 @@ function checkEngineSchemaMismatch(ctx: PipelineContext): void {
     );
     ctx.forceFullRebuild = true;
   }
+  // When the native engine is active, the Rust addon's version (ctx.engineVersion)
+  // is written into codegraph_version by setBuildMeta after a native orchestrator
+  // build. The check must compare against the same version, otherwise JS and Rust
+  // fight over which version to record — causing every incremental build to be
+  // promoted to a full rebuild when npm and crate versions diverge.
+  const effectiveVersion =
+    ctx.engineName === 'native' && ctx.engineVersion ? ctx.engineVersion : CODEGRAPH_VERSION;
   const prevVersion = meta('codegraph_version');
-  if (prevVersion && prevVersion !== CODEGRAPH_VERSION) {
+  if (prevVersion && prevVersion !== effectiveVersion) {
     info(
-      `Codegraph version changed (${prevVersion} → ${CODEGRAPH_VERSION}), promoting to full rebuild.`,
+      `Codegraph version changed (${prevVersion} → ${effectiveVersion}), promoting to full rebuild.`,
     );
     ctx.forceFullRebuild = true;
   }
@@ -126,38 +133,15 @@ function setupPipeline(ctx: PipelineContext): void {
   const native = enginePref !== 'wasm' ? loadNative() : null;
   ctx.nativeAvailable = !!native?.NativeDatabase;
 
-  // 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 });
-      acquireAdvisoryLock(ctx.dbPath);
-      ctx.nativeDb = native.NativeDatabase.openReadWrite(ctx.dbPath);
-      ctx.nativeDb.initSchema();
-      const proxy = new NativeDbProxy(ctx.nativeDb);
-      proxy.__lockPath = `${ctx.dbPath}.lock`;
-      ctx.db = proxy as unknown as typeof ctx.db;
-      ctx.nativeFirstProxy = true;
-    } catch (err) {
-      warn(`NativeDatabase setup failed, falling back to better-sqlite3: ${toErrorMessage(err)}`);
-      try {
-        ctx.nativeDb?.close();
-      } catch {
-        /* ignore */
-      }
-      ctx.nativeDb = undefined;
-      ctx.nativeFirstProxy = false;
-      releaseAdvisoryLock(`${ctx.dbPath}.lock`);
-      ctx.db = openDb(ctx.dbPath);
-      initSchema(ctx.db);
-    }
-  } else {
-    ctx.db = openDb(ctx.dbPath);
-    initSchema(ctx.db);
-  }
+  // Always use better-sqlite3 for setup — it's cheap (~4ms) and only needed
+  // for metadata reads (schema mismatch check). NativeDatabase.openReadWrite
+  // is deferred to tryNativeOrchestrator, saving ~60ms on incremental builds
+  // where the Rust orchestrator handles the full pipeline, and avoiding the
+  // cost entirely on no-op builds that exit before reaching the orchestrator.
+  const dir = path.dirname(ctx.dbPath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  ctx.db = openDb(ctx.dbPath);
+  initSchema(ctx.db);
 
   ctx.config = loadConfig(ctx.rootDir);
   ctx.incremental =
@@ -262,8 +246,6 @@ interface NativeOrchestratorResult {
   changedCount?: number;
   removedCount?: number;
   isFullBuild?: boolean;
-  /** Full changed files including reverse-dep files — used by JS structure fallback. */
-  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. */
@@ -584,15 +566,26 @@ async function tryNativeOrchestrator(
     return undefined;
   }
 
-  // In native-first mode, nativeDb is already open from setupPipeline.
-  // Otherwise, open it on demand (deferred to skip overhead on no-op rebuilds).
+  // Open NativeDatabase on demand — deferred from setupPipeline to skip the
+  // ~60ms cost on no-op/early-exit builds. Close the better-sqlite3 connection
+  // first to avoid dual-connection WAL corruption.
   if (!ctx.nativeDb && ctx.nativeAvailable) {
     const native = loadNative();
     if (native?.NativeDatabase) {
       try {
+        // Close better-sqlite3 before opening rusqlite to avoid WAL conflicts.
+        // Uses raw close() instead of closeDb() intentionally — the advisory lock
+        // is kept and transferred to the NativeDbProxy below, not released here.
+        ctx.db.close();
+        acquireAdvisoryLock(ctx.dbPath);
         ctx.nativeDb = native.NativeDatabase.openReadWrite(ctx.dbPath);
         ctx.nativeDb.initSchema();
-        ctx.nativeDb.exec('PRAGMA wal_checkpoint(TRUNCATE)');
+        // Replace ctx.db with a NativeDbProxy so post-native JS fallback
+        // (structure, analysis) can use it without reopening better-sqlite3.
+        const proxy = new NativeDbProxy(ctx.nativeDb);
+        proxy.__lockPath = `${ctx.dbPath}.lock`;
+        ctx.db = proxy as unknown as typeof ctx.db;
+        ctx.nativeFirstProxy = true;
       } catch (err) {
         warn(`NativeDatabase setup failed, falling back to JS: ${toErrorMessage(err)}`);
         try {
@@ -601,6 +594,10 @@ async function tryNativeOrchestrator(
           debug(`tryNativeOrchestrator: close failed during fallback: ${toErrorMessage(e)}`);
         }
         ctx.nativeDb = undefined;
+        ctx.nativeFirstProxy = false; // defensive: reset in case future refactors move the assignment above throwing lines
+        releaseAdvisoryLock(`${ctx.dbPath}.lock`);
+        // Reopen better-sqlite3 for JS pipeline fallback
+        ctx.db = openDb(ctx.dbPath);
       }
     }
   }
@@ -631,14 +628,18 @@ async function tryNativeOrchestrator(
   const p = result.phases;
 
   // Sync build_meta so JS-side version/engine checks work on next build.
+  // Use the Rust addon version as codegraph_version when the native
+  // orchestrator performed the build — the Rust side's check_version_mismatch
+  // compares this value against CARGO_PKG_VERSION.  Writing the JS
+  // CODEGRAPH_VERSION here would create a permanent mismatch whenever the
+  // npm package version diverges from the Rust crate version, forcing every
+  // subsequent native build to be a full rebuild (no incremental).
   setBuildMeta(ctx.db, {
     engine: ctx.engineName,
     engine_version: ctx.engineVersion || '',
-    codegraph_version: CODEGRAPH_VERSION,
+    codegraph_version: ctx.engineVersion || CODEGRAPH_VERSION,
     schema_version: String(ctx.schemaVersion),
     built_at: new Date().toISOString(),
-    node_count: String(result.nodeCount ?? 0),
-    edge_count: String(result.edgeCount ?? 0),
   });
 
   info(
@@ -686,7 +687,7 @@ async function tryNativeOrchestrator(
         ctx,
         fileSymbols,
         !!result.isFullBuild,
-        result.structureScope ?? result.changedFiles,
+        result.changedFiles,
       );
     }
 
@@ -772,6 +773,23 @@ async function runPipelineStages(ctx: PipelineContext): Promise<void> {
 
   await runAnalyses(ctx);
 
+  // Release WASM trees deterministically on the success path — same cleanup
+  // as the error-path catch block.  Without this, trees stay allocated until
+  // GC collects ctx, holding WASM memory for the rest of the build (#931).
+  if (ctx.allSymbols?.size > 0) {
+    for (const [, symbols] of ctx.allSymbols) {
+      const tree = symbols._tree as { delete?: () => void } | undefined;
+      if (tree && typeof tree.delete === 'function') {
+        try {
+          tree.delete();
+        } catch {
+          /* ignore cleanup errors */
+        }
+      }
+      symbols._tree = undefined;
+    }
+  }
+
   // 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).
@@ -816,13 +834,42 @@ export async function buildGraph(
       if (nativeResult) return nativeResult;
     } catch (err) {
       warn(`Native build orchestrator failed, falling back to JS pipeline: ${toErrorMessage(err)}`);
-      // Fall through to JS pipeline
+      // The version gate in checkEngineSchemaMismatch was skipped because
+      // nativeAvailable was true. Now that we're falling back to the JS
+      // pipeline, perform the codegraph_version check here so a version
+      // bump still promotes to a full rebuild (#928).
+      if (ctx.incremental && !ctx.forceFullRebuild) {
+        const prevVersion = getBuildMeta(ctx.db, 'codegraph_version');
+        if (prevVersion && prevVersion !== CODEGRAPH_VERSION) {
+          info(
+            `Codegraph version changed (${prevVersion} → ${CODEGRAPH_VERSION}), promoting to full rebuild.`,
+          );
+          ctx.forceFullRebuild = true;
+        }
+      }
     }
 
     await runPipelineStages(ctx);
   } catch (err) {
-    if (!ctx.earlyExit && ctx.db) {
-      closeDbPair({ db: ctx.db, nativeDb: ctx.nativeDb });
+    if (!ctx.earlyExit) {
+      // Release WASM trees before closing DB to prevent V8 crash during
+      // GC cleanup of orphaned WASM objects (#931).
+      if (ctx.allSymbols?.size > 0) {
+        for (const [, symbols] of ctx.allSymbols) {
+          const tree = symbols._tree as { delete?: () => void } | undefined;
+          if (tree && typeof tree.delete === 'function') {
+            try {
+              tree.delete();
+            } catch {
+              /* ignore cleanup errors */
+            }
+          }
+          symbols._tree = undefined;
+        }
+      }
+      if (ctx.db) {
+        closeDbPair({ db: ctx.db, nativeDb: ctx.nativeDb });
+      }
     }
     throw err;
   }

package/src/domain/graph/builder/stages/build-edges.ts

@@ -699,6 +699,69 @@ function buildClassHierarchyEdges(
   }
 }
 
+// ── Reverse-dep edge reconnection (#932, #933) ─────────────────────────
+
+/**
+ * Reconnect edges that were saved before changed-file purge.
+ *
+ * Each saved edge records: sourceId (still valid — reverse-dep nodes were not
+ * purged) and target attributes (name, kind, file, line).  The target node was
+ * deleted and re-inserted with a new ID by insertNodes.  We look up the new ID
+ * by (name, kind, file) and re-create the edge.
+ */
+function reconnectReverseDepEdges(ctx: PipelineContext): void {
+  const { db } = ctx;
+  const findNodeStmt = db.prepare(
+    'SELECT id FROM nodes WHERE name = ? AND kind = ? AND file = ? ORDER BY ABS(line - ?) LIMIT 1',
+  );
+  const reconnectedRows: EdgeRowTuple[] = [];
+  let dropped = 0;
+
+  for (const saved of ctx.savedReverseDepEdges) {
+    const newTarget = findNodeStmt.get(
+      saved.tgtName,
+      saved.tgtKind,
+      saved.tgtFile,
+      saved.tgtLine,
+    ) as { id: number } | undefined;
+    if (newTarget) {
+      reconnectedRows.push([
+        saved.sourceId,
+        newTarget.id,
+        saved.edgeKind,
+        saved.confidence,
+        saved.dynamic,
+      ]);
+    } else {
+      // Target was removed or renamed in the changed file — edge is stale
+      dropped++;
+    }
+  }
+
+  if (reconnectedRows.length > 0) {
+    if (ctx.nativeDb?.bulkInsertEdges) {
+      const nativeEdges = reconnectedRows.map((r) => ({
+        sourceId: r[0],
+        targetId: r[1],
+        kind: r[2],
+        confidence: r[3],
+        dynamic: r[4],
+      }));
+      const ok = ctx.nativeDb.bulkInsertEdges(nativeEdges);
+      if (!ok) {
+        batchInsertEdges(db, reconnectedRows);
+      }
+    } else {
+      batchInsertEdges(db, reconnectedRows);
+    }
+  }
+
+  debug(
+    `Reconnected ${reconnectedRows.length} reverse-dep edges` +
+      (dropped > 0 ? ` (${dropped} dropped — targets removed/renamed)` : ''),
+  );
+}
+
 // ── Main entry point ────────────────────────────────────────────────────
 
 /**
@@ -798,10 +861,11 @@ export async function buildEdges(ctx: PipelineContext): Promise<void> {
       }
     }
 
-    // Skip native import-edge path for small incremental builds (≤3 files):
-    // napi-rs marshaling overhead exceeds computation savings.
+    // Skip native import-edge path for small incremental builds: napi-rs
+    // marshaling overhead (~13ms) exceeds Rust computation savings at this scale.
     const useNativeImportEdges =
-      native?.buildImportEdges && (ctx.isFullBuild || ctx.fileSymbols.size > 3);
+      native?.buildImportEdges &&
+      (ctx.isFullBuild || ctx.fileSymbols.size > ctx.config.build.smallFilesThreshold);
     if (useNativeImportEdges) {
       const beforeLen = allEdgeRows.length;
       buildImportEdgesNative(ctx, getNodeIdStmt, allEdgeRows, native!);
@@ -821,10 +885,11 @@ export async function buildEdges(ctx: PipelineContext): Promise<void> {
       buildImportEdges(ctx, getNodeIdStmt, allEdgeRows);
     }
 
-    // Skip native call-edge path for small incremental builds (≤3 files):
-    // napi-rs marshaling overhead for allNodes exceeds computation savings.
+    // Skip native call-edge path for small incremental builds: napi-rs
+    // marshaling overhead for allNodes exceeds Rust computation savings.
     const useNativeCallEdges =
-      native?.buildCallEdges && (ctx.isFullBuild || ctx.fileSymbols.size > 3);
+      native?.buildCallEdges &&
+      (ctx.isFullBuild || ctx.fileSymbols.size > ctx.config.build.smallFilesThreshold);
     if (useNativeCallEdges) {
       buildCallEdgesNative(ctx, getNodeIdStmt, allEdgeRows, allNodesBefore, native!);
     } else {
@@ -858,5 +923,14 @@ export async function buildEdges(ctx: PipelineContext): Promise<void> {
     }
   }
 
+  // Phase 3: Reconnect saved reverse-dep edges (#932, #933).
+  // When the WASM/JS path purged changed files, edges FROM reverse-dep files TO
+  // those files were deleted (target-side).  The reverse-dep files were NOT
+  // reparsed — instead we saved the edge topology before purge and now reconnect
+  // each edge to the new node IDs created by insertNodes.
+  if (ctx.savedReverseDepEdges.length > 0) {
+    reconnectReverseDepEdges(ctx);
+  }
+
   ctx.timing.edgesMs = performance.now() - t0;
 }

package/src/domain/graph/builder/stages/build-structure.ts

@@ -174,13 +174,13 @@ function updateChangedFileMetrics(ctx: PipelineContext, changedFiles: string[]):
     SELECT COUNT(DISTINCT n_src.file) AS cnt FROM edges e
     JOIN nodes n_src ON e.source_id = n_src.id
     JOIN nodes n_tgt ON e.target_id = n_tgt.id
-    WHERE e.kind = 'imports' AND n_tgt.file = ? AND n_src.file != n_tgt.file
+    WHERE e.kind IN ('imports', 'imports-type') AND n_tgt.file = ? AND n_src.file != n_tgt.file
   `);
   const getFanOut = db.prepare(`
     SELECT COUNT(DISTINCT n_tgt.file) AS cnt FROM edges e
     JOIN nodes n_src ON e.source_id = n_src.id
     JOIN nodes n_tgt ON e.target_id = n_tgt.id
-    WHERE e.kind = 'imports' AND n_src.file = ? AND n_src.file != n_tgt.file
+    WHERE e.kind IN ('imports', 'imports-type') AND n_src.file = ? AND n_src.file != n_tgt.file
   `);
   const upsertMetric = db.prepare(`
     INSERT OR REPLACE INTO node_metrics

package/src/domain/graph/builder/stages/detect-changes.ts

@@ -374,24 +374,73 @@ function purgeAndAddReverseDeps(
     // Prefer NativeDatabase: purge + reverse-dep edge deletion in one transaction (#670)
     if (ctx.engineName === 'native' && ctx.nativeDb?.purgeFilesData) {
       ctx.nativeDb.purgeFilesData(filesToPurge, false, hasReverseDeps ? reverseDepList : undefined);
+      // Native path still reparses reverse-deps (works correctly with native edge builder)
+      for (const relPath of reverseDeps) {
+        const absPath = path.join(rootDir, relPath);
+        ctx.parseChanges.push({ file: absPath, relPath, _reverseDepOnly: true });
+      }
     } else {
+      // WASM/JS path: save edges from reverse-dep files → changed files BEFORE
+      // purge, then reconnect them to new node IDs after insertNodes (#932, #933).
+      //
+      // purgeFilesFromGraph deletes edges in BOTH directions for changed files,
+      // which already removes the reverse-dep → changed-file edges.  The old
+      // approach then over-deleted ALL outgoing edges from reverse-dep files and
+      // reparsed them to rebuild everything — expensive (87 extra parses) and
+      // lossy (442 missing edges due to imperfect resolution on rebuild).
+      //
+      // New approach: save the edge topology, let purge handle deletion, then
+      // reconnect using new node IDs.  No reparse needed.
+      if (hasReverseDeps && hasPurge) {
+        const changePathSet = new Set(changePaths);
+        const saveEdgesStmt = db.prepare(`
+          SELECT e.source_id, n_tgt.name AS tgt_name, n_tgt.kind AS tgt_kind,
+                 n_tgt.file AS tgt_file, n_tgt.line AS tgt_line,
+                 e.kind AS edge_kind, e.confidence, e.dynamic,
+                 n_src.file AS src_file
+          FROM edges e
+          JOIN nodes n_src ON e.source_id = n_src.id
+          JOIN nodes n_tgt ON e.target_id = n_tgt.id
+          WHERE n_tgt.file = ? AND n_src.file != n_tgt.file
+        `);
+        for (const changedPath of changePaths) {
+          for (const row of saveEdgesStmt.all(changedPath) as Array<{
+            source_id: number;
+            tgt_name: string;
+            tgt_kind: string;
+            tgt_file: string;
+            tgt_line: number;
+            edge_kind: string;
+            confidence: number;
+            dynamic: number;
+            src_file: string;
+          }>) {
+            // Skip edges whose source is also being purged — buildEdges will
+            // re-create them with correct new IDs.
+            if (changePathSet.has(row.src_file)) continue;
+            ctx.savedReverseDepEdges.push({
+              sourceId: row.source_id,
+              tgtName: row.tgt_name,
+              tgtKind: row.tgt_kind,
+              tgtFile: row.tgt_file,
+              tgtLine: row.tgt_line,
+              edgeKind: row.edge_kind,
+              confidence: row.confidence,
+              dynamic: row.dynamic,
+            });
+          }
+        }
+        debug(`Saved ${ctx.savedReverseDepEdges.length} reverse-dep edges for reconnection`);
+      }
+
       if (hasPurge) {
         purgeFilesFromGraph(db, filesToPurge, { purgeHashes: false });
       }
-      if (hasReverseDeps) {
-        const deleteOutgoingEdgesForFile = db.prepare(
-          'DELETE FROM edges WHERE source_id IN (SELECT id FROM nodes WHERE file = ?)',
-        );
-        for (const relPath of reverseDepList) {
-          deleteOutgoingEdgesForFile.run(relPath);
-        }
-      }
+      // No outgoing-edge deletion for reverse-deps — purge already removed
+      // edges targeting the changed files, and other outgoing edges are valid.
+      // No reverse-deps added to parseChanges — no reparse needed.
     }
   }
-  for (const relPath of reverseDeps) {
-    const absPath = path.join(rootDir, relPath);
-    ctx.parseChanges.push({ file: absPath, relPath, _reverseDepOnly: true });
-  }
 }
 
 function detectHasEmbeddings(db: BetterSqlite3Database, nativeDb?: NativeDatabase): boolean {

package/src/domain/graph/builder/stages/finalize.ts

@@ -81,13 +81,20 @@ function persistBuildMetadata(
 ): void {
   const useNativeDb = ctx.engineName === 'native' && !!ctx.nativeDb;
   if (!ctx.isFullBuild && ctx.allSymbols.size <= 3) return;
+  // When the native engine is active, persist the Rust addon version so that
+  // checkEngineSchemaMismatch compares against the same value on the next build.
+  // Writing CODEGRAPH_VERSION (the npm package version) here would create a
+  // permanent mismatch whenever npm and crate versions diverge, forcing every
+  // subsequent build to be a full rebuild.
+  const codeVersionToWrite =
+    ctx.engineName === 'native' && ctx.engineVersion ? ctx.engineVersion : CODEGRAPH_VERSION;
   try {
     if (useNativeDb) {
       ctx.nativeDb!.setBuildMeta(
         Object.entries({
           engine: ctx.engineName,
-          engine_version: CODEGRAPH_VERSION,
-          codegraph_version: CODEGRAPH_VERSION,
+          engine_version: codeVersionToWrite,
+          codegraph_version: codeVersionToWrite,
           schema_version: String(ctx.schemaVersion),
           built_at: buildNow.toISOString(),
           node_count: String(nodeCount),
@@ -97,8 +104,8 @@ function persistBuildMetadata(
     } else {
       setBuildMeta(ctx.db, {
         engine: ctx.engineName,
-        engine_version: CODEGRAPH_VERSION,
-        codegraph_version: CODEGRAPH_VERSION,
+        engine_version: codeVersionToWrite,
+        codegraph_version: codeVersionToWrite,
         schema_version: String(ctx.schemaVersion),
         built_at: buildNow.toISOString(),
         node_count: nodeCount,

package/src/domain/graph/builder/stages/run-analyses.ts

@@ -2,39 +2,18 @@
  * Stage: runAnalyses
  *
  * Dispatches to the unified AST analysis engine (AST nodes, complexity, CFG, dataflow).
- * Filters out reverse-dep files for incremental builds.
+ * Reverse-dep files are no longer in allSymbols (they are not reparsed since #932/#933),
+ * so no filtering is needed here.
  */
-import { debug, warn } from '../../../../infrastructure/logger.js';
-import type { ExtractorOutput } from '../../../../types.js';
+import { warn } from '../../../../infrastructure/logger.js';
 import type { PipelineContext } from '../context.js';
 
 export async function runAnalyses(ctx: PipelineContext): Promise<void> {
-  const { db, allSymbols, rootDir, opts, engineOpts, isFullBuild, filesToParse } = ctx;
-
-  // For incremental builds, exclude reverse-dep-only files
-  let astComplexitySymbols: Map<string, ExtractorOutput> = allSymbols;
-  if (!isFullBuild) {
-    const reverseDepFiles = new Set(
-      filesToParse
-        .filter((item) => (item as { _reverseDepOnly?: boolean })._reverseDepOnly)
-        .map((item) => item.relPath),
-    );
-    if (reverseDepFiles.size > 0) {
-      astComplexitySymbols = new Map();
-      for (const [relPath, symbols] of allSymbols) {
-        if (!reverseDepFiles.has(relPath)) {
-          astComplexitySymbols.set(relPath, symbols);
-        }
-      }
-      debug(
-        `AST/complexity/CFG/dataflow: processing ${astComplexitySymbols.size} changed files (skipping ${reverseDepFiles.size} reverse-deps)`,
-      );
-    }
-  }
+  const { db, allSymbols, rootDir, opts, engineOpts } = ctx;
 
   const { runAnalyses: runAnalysesFn } = await import('../../../../ast-analysis/engine.js');
   try {
-    const analysisTiming = await runAnalysesFn(db, astComplexitySymbols, rootDir, opts, engineOpts);
+    const analysisTiming = await runAnalysesFn(db, allSymbols, rootDir, opts, engineOpts);
     ctx.timing.astMs = analysisTiming.astMs;
     ctx.timing.complexityMs = analysisTiming.complexityMs;
     ctx.timing.cfgMs = analysisTiming.cfgMs;