fix: skip native build orchestrator for addon ≤3.8.0 and fix path bug (#758)

* fix: skip native build orchestrator for addon ≤3.8.0 and fix path bug

The native build orchestrator in addon 3.8.0 has a path normalization
bug: file_symbols keys use absolute paths but known_files uses relative
paths, causing zero import/call edges. Additionally, the orchestrator
ran even when engine: 'wasm' was explicitly requested.

JS-side fixes (immediate):
- Skip orchestrator when engine version is 3.8.0 (falls back to JS)
- Skip orchestrator when engine is not 'native' (respects engine option)
- Skip orchestrator on forceFullRebuild (version/schema mismatch)
- Add 'No changes detected' logging on native earlyExit
- Add 'Incremental: N changed' logging from native pipeline results
- Write build_meta after native build for cross-engine consistency

Rust-side fix (takes effect in next native addon release):
- Use relative_path() instead of normalize_path() when building
  file_symbols map, and update sym.file to relative path
- Add changedCount/removedCount/isFullBuild to BuildPipelineResult
  so JS side can emit incremental status logging

* fix: use semver comparison for orchestrator version check

Replace hardcoded `=== '3.8.0'` with `semverCompare(version, '3.8.0') <= 0`
so the check automatically passes for 3.9.0+ without manual updates.

* style: format orchestrator version check on single line

* fix: address review comments on native pipeline guard (#758)

- Fix comment: say "3.8.0" (exact match) instead of misleading "≤3.8.0"
- Log which condition triggered forceJs bypass for easier debugging
- Document why JS overwrites Rust-written codegraph_version in build_meta

* fix: include built_at in native orchestrator setBuildMeta (#758)

The native orchestrator path omitted built_at from setBuildMeta, leaving
the build timestamp stale after native runs. The JS finalize stage
already writes it — match that behavior so codegraph info shows the
correct build time regardless of which engine path ran.

* fix(native): normalize batch key separators for Windows import edge resolution

The Rust build_import_edges function constructs lookup keys as
format!("{}/{}", root_dir, file), mixing backslashes in root_dir with
forward slashes. On Windows, the JS batch map keys use path.join()
which produces all-backslash paths, causing key mismatches and
silently dropping 5 import edges.

Fix:
- Normalize batch map keys to forward slashes (resolve.ts, resolve-imports.ts)
- Normalize lookup keys in getResolved and buildImportEdgesNative
- Normalize root_dir in Rust key construction (edge_builder.rs)
- Skip native import-edge builder for addon 3.8.0 (pre-compiled addon
  still has the bug; Rust fix takes effect in 3.8.1+)

* fix: normalize batch key lookups in resolution tests for Windows

Tests that look up resolveImportsBatch results must use
normalizePath(fromFile) to match the normalized keys in the batch map.

Author: carlos-alm

crates/codegraph-core/src/build_pipeline.rs

@@ -57,6 +57,9 @@ pub struct BuildPipelineResult {
     pub edge_count: i64,
     pub file_count: usize,
     pub early_exit: bool,
+    pub changed_count: usize,
+    pub removed_count: usize,
+    pub is_full_build: bool,
 }
 
 /// Normalize path to forward slashes.
@@ -191,6 +194,9 @@ pub fn run_pipeline(
             edge_count: 0,
             file_count: collect_result.files.len(),
             early_exit: true,
+            changed_count: 0,
+            removed_count: 0,
+            is_full_build: false,
         });
     }
 
@@ -247,8 +253,9 @@ pub fn run_pipeline(
 
     // Build file symbols map (relative path → FileSymbols)
     let mut file_symbols: HashMap<String, FileSymbols> = HashMap::new();
-    for sym in parsed {
-        let rel = normalize_path(&sym.file);
+    for mut sym in parsed {
+        let rel = relative_path(root_dir, &sym.file);
+        sym.file = rel.clone();
         file_symbols.insert(rel, sym);
     }
     timing.parse_ms = t0.elapsed().as_secs_f64() * 1000.0;
@@ -426,6 +433,9 @@ pub fn run_pipeline(
         edge_count,
         file_count: collect_result.files.len(),
         early_exit: false,
+        changed_count: parse_changes.len(),
+        removed_count: change_result.removed.len(),
+        is_full_build: change_result.is_full_build,
     })
 }
 

crates/codegraph-core/src/edge_builder.rs

@@ -541,7 +541,7 @@ pub fn build_import_edges(
     let mut edges = Vec::new();
 
     for file_input in &files {
-        let abs_file = format!("{}/{}", root_dir, file_input.file);
+        let abs_file = format!("{}/{}", root_dir.replace('\\', "/"), file_input.file);
 
         for imp in &file_input.imports {
             // Barrel-only files: only emit reexport edges

src/domain/graph/builder/pipeline.ts

@@ -6,10 +6,18 @@
  */
 import path from 'node:path';
 import { performance } from 'node:perf_hooks';
-import { closeDbPair, getBuildMeta, initSchema, MIGRATIONS, openDb } from '../../../db/index.js';
+import {
+  closeDbPair,
+  getBuildMeta,
+  initSchema,
+  MIGRATIONS,
+  openDb,
+  setBuildMeta,
+} from '../../../db/index.js';
 import { detectWorkspaces, loadConfig } from '../../../infrastructure/config.js';
-import { info, warn } from '../../../infrastructure/logger.js';
+import { debug, info, warn } from '../../../infrastructure/logger.js';
 import { loadNative } from '../../../infrastructure/native.js';
+import { semverCompare } from '../../../infrastructure/update-check.js';
 import { CODEGRAPH_VERSION } from '../../../shared/version.js';
 import type { BuildGraphOpts, BuildResult } from '../../../types.js';
 import { getActiveEngine } from '../../parser.js';
@@ -338,7 +346,27 @@ export async function buildGraph(
     // 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';
+    //
+    // Native addon 3.8.0 has a path bug: file_symbols keys are absolute
+    // paths but known_files are relative, causing zero import/call edges.
+    // Skip the orchestrator for affected versions (fixed in 3.9.0+).
+    const orchestratorBuggy = !!ctx.engineVersion && semverCompare(ctx.engineVersion, '3.8.0') <= 0;
+    const forceJs =
+      process.env.CODEGRAPH_FORCE_JS_PIPELINE === '1' ||
+      ctx.forceFullRebuild ||
+      orchestratorBuggy ||
+      ctx.engineName !== 'native';
+    if (forceJs) {
+      const reason =
+        process.env.CODEGRAPH_FORCE_JS_PIPELINE === '1'
+          ? 'CODEGRAPH_FORCE_JS_PIPELINE=1'
+          : ctx.forceFullRebuild
+            ? 'forceFullRebuild'
+            : orchestratorBuggy
+              ? `buggy addon ${ctx.engineVersion}`
+              : `engine=${ctx.engineName}`;
+      debug(`Skipping native orchestrator: ${reason}`);
+    }
     if (!forceJs && ctx.nativeDb?.buildGraph) {
       try {
         const resultJson = ctx.nativeDb.buildGraph(
@@ -353,17 +381,44 @@ export async function buildGraph(
           nodeCount?: number;
           edgeCount?: number;
           fileCount?: number;
+          changedCount?: number;
+          removedCount?: number;
+          isFullBuild?: boolean;
         };
 
         if (result.earlyExit) {
+          info('No changes detected');
           closeDbPair({ db: ctx.db, nativeDb: ctx.nativeDb });
           return;
         }
 
+        // Log incremental status to match JS pipeline output
+        const changed = result.changedCount ?? 0;
+        const removed = result.removedCount ?? 0;
+        if (!result.isFullBuild && (changed > 0 || removed > 0)) {
+          info(`Incremental: ${changed} changed, ${removed} removed`);
+        }
+
         // 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;
+
+        // Sync build_meta so JS-side version/engine checks work on next build.
+        // Note: the Rust orchestrator also writes codegraph_version (using
+        // CARGO_PKG_VERSION). We intentionally overwrite it here with the npm
+        // package version so that the JS-side "version changed → full rebuild"
+        // detection (line ~97) compares against the authoritative JS version.
+        // The two versions are kept in lockstep by the release process.
+        setBuildMeta(ctx.db, {
+          engine: ctx.engineName,
+          engine_version: ctx.engineVersion || '',
+          codegraph_version: CODEGRAPH_VERSION,
+          schema_version: String(ctx.schemaVersion),
+          built_at: new Date().toISOString(),
+          node_count: String(result.nodeCount ?? 0),
+          edge_count: String(result.edgeCount ?? 0),
+        });
+
         closeDbPair({ db: ctx.db, nativeDb: ctx.nativeDb });
         info(
           `Native build orchestrator completed: ${result.nodeCount ?? 0} nodes, ${result.edgeCount ?? 0} edges, ${result.fileCount ?? 0} files`,

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

@@ -9,6 +9,7 @@ import { performance } from 'node:perf_hooks';
 import { getNodeId } from '../../../../db/index.js';
 import { debug } from '../../../../infrastructure/logger.js';
 import { loadNative } from '../../../../infrastructure/native.js';
+import { normalizePath } from '../../../../shared/constants.js';
 import type {
   BetterSqlite3Database,
   Call,
@@ -219,7 +220,7 @@ function buildImportEdgesNative(
       addFileNodeId(resolvedPath);
 
       // Check if this resolution is in batchResolved; if not, add supplemental
-      const resolveKey = `${path.join(rootDir, relPath)}|${imp.source}`;
+      const resolveKey = `${normalizePath(path.join(rootDir, relPath))}|${imp.source}`;
       if (!ctx.batchResolved?.has(resolveKey)) {
         supplementalResolved.push({ key: resolveKey, resolvedPath });
       }
@@ -743,10 +744,12 @@ 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 (≤3 files)
+    // and for addon 3.8.0 which has a Windows path-separator bug in key
+    // construction (format!("{}/{}", root_dir, file) vs path.join backslashes).
+    const importEdgeBuggy = ctx.engineVersion === '3.8.0';
     const useNativeImportEdges =
-      native?.buildImportEdges && (ctx.isFullBuild || ctx.fileSymbols.size > 3);
+      native?.buildImportEdges && !importEdgeBuggy && (ctx.isFullBuild || ctx.fileSymbols.size > 3);
     if (useNativeImportEdges) {
       buildImportEdgesNative(ctx, getNodeIdStmt, allEdgeRows, native!);
     } else {

src/domain/graph/builder/stages/resolve-imports.ts

@@ -1,6 +1,7 @@
 import path from 'node:path';
 import { performance } from 'node:perf_hooks';
 import { debug } from '../../../../infrastructure/logger.js';
+import { normalizePath } from '../../../../shared/constants.js';
 import type { Import } from '../../../../types.js';
 import { parseFilesAuto } from '../../../parser.js';
 import { resolveImportPath, resolveImportsBatch } from '../../resolve.js';
@@ -71,7 +72,9 @@ export async function resolveImports(ctx: PipelineContext): Promise<void> {
         const symbols = fileSymbols.get(relPath);
         if (!symbols) continue;
         for (const imp of symbols.imports) {
-          const resolved = ctx.batchResolved?.get(`${path.join(rootDir, relPath)}|${imp.source}`);
+          const resolved = ctx.batchResolved?.get(
+            `${normalizePath(path.join(rootDir, relPath))}|${imp.source}`,
+          );
           const target =
             resolved ??
             resolveImportPath(path.join(rootDir, relPath), imp.source, rootDir, aliases);
@@ -142,7 +145,7 @@ export async function resolveImports(ctx: PipelineContext): Promise<void> {
 
 export function getResolved(ctx: PipelineContext, absFile: string, importSource: string): string {
   if (ctx.batchResolved) {
-    const key = `${absFile}|${importSource}`;
+    const key = `${normalizePath(absFile)}|${importSource}`;
     const hit = ctx.batchResolved.get(key);
     if (hit !== undefined) return hit;
   }

src/domain/graph/resolve.ts

@@ -565,7 +565,7 @@ export function resolveImportsBatch(
       // Native resolver's .js → .ts remap fails on unnormalized paths —
       // apply JS-side fallback (same fix as resolveImportPath).
       const resolved = remapJsToTs(normalized, rootDir);
-      map.set(`${r.fromFile}|${r.importSource}`, resolved);
+      map.set(`${normalizePath(r.fromFile)}|${r.importSource}`, resolved);
     }
     return map;
   } catch (e) {

tests/resolution/parity.test.ts

@@ -15,6 +15,7 @@ import {
   resolveImportsBatch,
 } from '../../src/domain/graph/resolve.js';
 import { isNativeAvailable, loadNative } from '../../src/infrastructure/native.js';
+import { normalizePath } from '../../src/shared/constants.js';
 
 const hasNative = isNativeAvailable();
 
@@ -257,7 +258,7 @@ describe.skipIf(!hasNative)('Batch import resolution', () => {
 
     for (const { fromFile, importSource } of inputs) {
       const individual = resolveImportPathJS(fromFile, importSource, rootDir, noAliases);
-      const batchKey = `${fromFile}|${importSource}`;
+      const batchKey = `${normalizePath(fromFile)}|${importSource}`;
       expect(batchResult.get(batchKey)).toBe(individual);
     }
   });

tests/unit/resolve.test.ts

@@ -23,6 +23,7 @@ import {
   resolveViaWorkspace,
   setWorkspaces,
 } from '../../src/domain/graph/resolve.js';
+import { normalizePath } from '../../src/shared/constants.js';
 
 // ─── Temp project setup ──────────────────────────────────────────────
 
@@ -236,7 +237,7 @@ describe('resolveImportsBatch', () => {
     const result = resolveImportsBatch([{ fromFile, importSource: './math.js' }], tmpDir, null);
     // Skip when native addon is not available
     if (result === null) return;
-    const key = `${fromFile}|./math.js`;
+    const key = `${normalizePath(fromFile)}|./math.js`;
     const resolved = result.get(key);
     expect(resolved).toBeDefined();
     expect(resolved).toMatch(/math\.ts$/);