@optave/codegraph 3.9.3 → 3.9.5

package/src/domain/graph/builder/stages/collect-files.ts

@@ -7,11 +7,13 @@
  */
 import fs from 'node:fs';
 import path from 'node:path';
+import { performance } from 'node:perf_hooks';
 import { debug, info } from '../../../../infrastructure/logger.js';
 import { normalizePath } from '../../../../shared/constants.js';
+import { compileGlobs } from '../../../../shared/globs.js';
 import { readJournal } from '../../journal.js';
 import type { PipelineContext } from '../context.js';
-import { collectFiles as collectFilesUtil } from '../helpers.js';
+import { collectFiles as collectFilesUtil, passesIncludeExclude } from '../helpers.js';
 
 /**
  * Reconstruct allFiles from DB file_hashes + journal deltas.
@@ -20,7 +22,7 @@ import { collectFiles as collectFilesUtil } from '../helpers.js';
 function tryFastCollect(
   ctx: PipelineContext,
 ): { files: string[]; directories: Set<string> } | null {
-  const { db, rootDir } = ctx;
+  const { db, rootDir, config } = ctx;
   const useNative = ctx.engineName === 'native' && !!ctx.nativeDb?.getCollectFilesData;
 
   // 1. Check that file_hashes table exists and has entries
@@ -70,10 +72,20 @@ function tryFastCollect(
     }
   }
 
-  // 5. Convert to absolute paths and compute directories
+  // 5. Convert to absolute paths and compute directories, honoring
+  //    config.include / config.exclude globs so incremental builds reflect
+  //    config changes (paths from the DB were collected under older config).
+  const includeRegexes = compileGlobs(config?.include);
+  const excludeRegexes = compileGlobs(config?.exclude);
+  const hasGlobFilters = includeRegexes.length > 0 || excludeRegexes.length > 0;
+
   const files: string[] = [];
   const directories = new Set<string>();
   for (const relPath of fileSet) {
+    if (hasGlobFilters) {
+      const normRel = normalizePath(relPath);
+      if (!passesIncludeExclude(normRel, includeRegexes, excludeRegexes)) continue;
+    }
     const absPath = path.join(rootDir, relPath);
     files.push(absPath);
     directories.add(path.dirname(absPath));
@@ -89,42 +101,60 @@ export async function collectFiles(ctx: PipelineContext): Promise<void> {
   const { rootDir, config, opts } = ctx;
 
   if (opts.scope) {
-    // Scoped rebuild: rebuild only specified files
+    // Scoped rebuild: rebuild only specified files.
+    //
+    // Timer only wraps the filesystem-walk portion (existence checks + file
+    // list construction). Change-detection outputs (parseChanges, removed,
+    // isFullBuild) are attributed to detectMs for semantic consistency with
+    // the non-scoped path, even though this stage computes them.
+    const start = performance.now();
     const scopedFiles = opts.scope.map((f: string) => normalizePath(f));
     const existing: Array<{ file: string; relPath: string }> = [];
     const missing: string[] = [];
-    for (const rel of scopedFiles) {
-      const abs = path.join(rootDir, rel);
-      if (fs.existsSync(abs)) {
-        existing.push({ file: abs, relPath: rel });
-      } else {
-        missing.push(rel);
+    try {
+      for (const rel of scopedFiles) {
+        const abs = path.join(rootDir, rel);
+        if (fs.existsSync(abs)) {
+          existing.push({ file: abs, relPath: rel });
+        } else {
+          missing.push(rel);
+        }
       }
+      ctx.allFiles = existing.map((e) => e.file);
+      ctx.discoveredDirs = new Set(existing.map((e) => path.dirname(e.file)));
+    } finally {
+      ctx.timing.collectMs = performance.now() - start;
     }
-    ctx.allFiles = existing.map((e) => e.file);
-    ctx.discoveredDirs = new Set(existing.map((e) => path.dirname(e.file)));
+    // Change-detection outputs — timed under detectMs for semantic parity.
+    const detectStart = performance.now();
     ctx.parseChanges = existing;
     ctx.metadataUpdates = [];
     ctx.removed = missing;
     ctx.isFullBuild = false;
+    ctx.timing.detectMs = (ctx.timing.detectMs ?? 0) + (performance.now() - detectStart);
     info(`Scoped rebuild: ${existing.length} files to rebuild, ${missing.length} to purge`);
     return;
   }
 
-  // Incremental fast path: reconstruct file list from DB + journal deltas
-  // instead of full recursive filesystem scan (~8ms savings on 473 files).
-  if (ctx.incremental && !ctx.forceFullRebuild) {
-    const fast = tryFastCollect(ctx);
-    if (fast) {
-      ctx.allFiles = fast.files;
-      ctx.discoveredDirs = fast.directories;
-      info(`Found ${ctx.allFiles.length} files (cached)`);
-      return;
+  const start = performance.now();
+  try {
+    // Incremental fast path: reconstruct file list from DB + journal deltas
+    // instead of full recursive filesystem scan (~8ms savings on 473 files).
+    if (ctx.incremental && !ctx.forceFullRebuild) {
+      const fast = tryFastCollect(ctx);
+      if (fast) {
+        ctx.allFiles = fast.files;
+        ctx.discoveredDirs = fast.directories;
+        info(`Found ${ctx.allFiles.length} files (cached)`);
+        return;
+      }
     }
-  }
 
-  const collected = collectFilesUtil(rootDir, [], config, new Set<string>());
-  ctx.allFiles = collected.files;
-  ctx.discoveredDirs = collected.directories;
-  info(`Found ${ctx.allFiles.length} files to parse`);
+    const collected = collectFilesUtil(rootDir, [], config, new Set<string>());
+    ctx.allFiles = collected.files;
+    ctx.discoveredDirs = collected.directories;
+    info(`Found ${ctx.allFiles.length} files to parse`);
+  } finally {
+    ctx.timing.collectMs = performance.now() - start;
+  }
 }

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

@@ -7,6 +7,7 @@
  */
 import fs from 'node:fs';
 import path from 'node:path';
+import { performance } from 'node:perf_hooks';
 import { closeDb } from '../../../../db/index.js';
 import { debug, info } from '../../../../infrastructure/logger.js';
 import { normalizePath } from '../../../../shared/constants.js';
@@ -374,24 +375,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 {
@@ -463,59 +513,66 @@ function handleIncrementalBuild(ctx: PipelineContext): void {
 }
 
 export async function detectChanges(ctx: PipelineContext): Promise<void> {
-  const { db, allFiles, rootDir, incremental, forceFullRebuild, opts } = ctx;
-  if ((opts as Record<string, unknown>).scope) {
-    handleScopedBuild(ctx);
-    return;
-  }
-  const increResult =
-    incremental && !forceFullRebuild
-      ? getChangedFiles(db, allFiles, rootDir)
-      : {
-          changed: allFiles.map((f): ChangedFile => ({ file: f })),
-          removed: [] as string[],
-          isFullBuild: true,
-        };
-  ctx.removed = increResult.removed;
-  ctx.isFullBuild = increResult.isFullBuild;
-  ctx.parseChanges = increResult.changed
-    .filter((c) => !c.metadataOnly)
-    .map((c) => ({
-      file: c.file,
-      relPath: c.relPath,
-      content: c.content,
-      hash: c.hash,
-      stat: c.stat ? { mtime: Math.floor(c.stat.mtimeMs), size: c.stat.size } : undefined,
-      _reverseDepOnly: c._reverseDepOnly,
-    }));
-  ctx.metadataUpdates = increResult.changed
-    .filter(
-      (c): c is ChangedFile & { relPath: string; hash: string; stat: FileStat } =>
-        !!c.metadataOnly && !!c.relPath && !!c.hash && !!c.stat,
-    )
-    .map((c) => ({
-      relPath: c.relPath,
-      hash: c.hash,
-      stat: { mtime: Math.floor(c.stat.mtimeMs), size: c.stat.size },
-    }));
-  if (!ctx.isFullBuild && ctx.parseChanges.length === 0 && ctx.removed.length === 0) {
-    const ranAnalysis = await runPendingAnalysis(ctx);
-    if (ranAnalysis) {
+  const start = performance.now();
+  try {
+    const { db, allFiles, rootDir, incremental, forceFullRebuild, opts } = ctx;
+    if ((opts as Record<string, unknown>).scope) {
+      handleScopedBuild(ctx);
+      return;
+    }
+    const increResult =
+      incremental && !forceFullRebuild
+        ? getChangedFiles(db, allFiles, rootDir)
+        : {
+            changed: allFiles.map((f): ChangedFile => ({ file: f })),
+            removed: [] as string[],
+            isFullBuild: true,
+          };
+    ctx.removed = increResult.removed;
+    ctx.isFullBuild = increResult.isFullBuild;
+    ctx.parseChanges = increResult.changed
+      .filter((c) => !c.metadataOnly)
+      .map((c) => ({
+        file: c.file,
+        relPath: c.relPath,
+        content: c.content,
+        hash: c.hash,
+        stat: c.stat ? { mtime: Math.floor(c.stat.mtimeMs), size: c.stat.size } : undefined,
+        _reverseDepOnly: c._reverseDepOnly,
+      }));
+    ctx.metadataUpdates = increResult.changed
+      .filter(
+        (c): c is ChangedFile & { relPath: string; hash: string; stat: FileStat } =>
+          !!c.metadataOnly && !!c.relPath && !!c.hash && !!c.stat,
+      )
+      .map((c) => ({
+        relPath: c.relPath,
+        hash: c.hash,
+        stat: { mtime: Math.floor(c.stat.mtimeMs), size: c.stat.size },
+      }));
+    if (!ctx.isFullBuild && ctx.parseChanges.length === 0 && ctx.removed.length === 0) {
+      const ranAnalysis = await runPendingAnalysis(ctx);
+      if (ranAnalysis) {
+        closeDb(db);
+        writeJournalHeader(rootDir, Date.now());
+        ctx.earlyExit = true;
+        return;
+      }
+      healMetadata(ctx);
+      info('No changes detected. Graph is up to date.');
       closeDb(db);
       writeJournalHeader(rootDir, Date.now());
       ctx.earlyExit = true;
       return;
     }
-    healMetadata(ctx);
-    info('No changes detected. Graph is up to date.');
-    closeDb(db);
-    writeJournalHeader(rootDir, Date.now());
-    ctx.earlyExit = true;
-    return;
-  }
-  if (ctx.isFullBuild) {
-    handleFullBuild(ctx);
-  } else {
-    handleIncrementalBuild(ctx);
+    if (ctx.isFullBuild) {
+      handleFullBuild(ctx);
+    } else {
+      handleIncrementalBuild(ctx);
+    }
+  } finally {
+    // Additive to respect any partial detectMs contribution from collectFiles
+    // (scoped-rebuild path splits change-detection outputs across both stages).
+    ctx.timing.detectMs = (ctx.timing.detectMs ?? 0) + (performance.now() - start);
   }
 }

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

@@ -3,6 +3,7 @@
  *
  * WASM cleanup, stats logging, drift detection, build metadata, registry, journal.
  */
+import fs from 'node:fs';
 import { tmpdir } from 'node:os';
 import path from 'node:path';
 import { performance } from 'node:perf_hooks';
@@ -81,28 +82,50 @@ 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;
+  // Persist the repo root so downstream commands (e.g. `codegraph embed`)
+  // can resolve relative file paths regardless of the invoking cwd.
+  // Use realpathSync (symlink-resolving) to match the Rust engine's
+  // std::fs::canonicalize — otherwise the JS write here would overwrite the
+  // canonical path Rust wrote for native full builds and could re-introduce
+  // a non-canonical path when the project root is behind a symlink.
+  const resolvedRootDir = path.resolve(ctx.rootDir);
+  let rootDirToWrite = resolvedRootDir;
+  try {
+    rootDirToWrite = fs.realpathSync(resolvedRootDir);
+  } catch {
+    /* realpath can fail (e.g. path no longer exists); fall back to resolve() */
+  }
   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),
           edge_count: String(actualEdgeCount),
+          root_dir: rootDirToWrite,
         }).map(([key, value]) => ({ key, value: String(value) })),
       );
     } 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,
         edge_count: actualEdgeCount,
+        root_dir: rootDirToWrite,
       });
     }
   } catch (err) {

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;