@optave/codegraph 3.4.0 → 3.5.0

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

@@ -5,9 +5,9 @@
  */
 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 { ExtractorOutput } from '../../../../types.js';
+import { debug } from '#infrastructure/logger.js';
+import { normalizePath } from '#shared/constants.js';
+import type { ExtractorOutput } from '#types';
 import type { PipelineContext } from '../context.js';
 import { readFileSafe } from '../helpers.js';
 
@@ -32,94 +32,107 @@ export async function buildStructure(ctx: PipelineContext): Promise<void> {
     }
   }
 
-  // For incremental builds, load unchanged files from DB for complete structure
-  if (!isFullBuild) {
-    const existingFiles = db
-      .prepare("SELECT DISTINCT file FROM nodes WHERE kind = 'file'")
-      .all() as Array<{ file: string }>;
-    const defsByFile = db.prepare(
-      "SELECT name, kind, line FROM nodes WHERE file = ? AND kind != 'file' AND kind != 'directory'",
-    );
-    const importCountByFile = db.prepare(
-      `SELECT COUNT(DISTINCT n2.file) AS cnt FROM edges e
-       JOIN nodes n1 ON e.source_id = n1.id
-       JOIN nodes n2 ON e.target_id = n2.id
-       WHERE n1.file = ? AND e.kind = 'imports'`,
-    );
-    const lineCountByFile = db.prepare(
-      `SELECT n.name AS file, m.line_count
-       FROM node_metrics m JOIN nodes n ON m.node_id = n.id
-       WHERE n.kind = 'file'`,
-    );
-    const cachedLineCounts = new Map<string, number>();
-    for (const row of lineCountByFile.all() as Array<{ file: string; line_count: number }>) {
-      cachedLineCounts.set(row.file, row.line_count);
-    }
-    let loadedFromDb = 0;
-    for (const { file: relPath } of existingFiles) {
-      if (!fileSymbols.has(relPath)) {
-        const importCount =
-          (importCountByFile.get(relPath) as { cnt: number } | undefined)?.cnt || 0;
-        fileSymbols.set(relPath, {
-          definitions: defsByFile.all(relPath),
-          imports: new Array(importCount) as unknown as ExtractorOutput['imports'],
-          exports: [],
-        } as unknown as ExtractorOutput);
-        loadedFromDb++;
-      }
-      if (!ctx.lineCountMap.has(relPath)) {
-        const cached = cachedLineCounts.get(relPath);
-        if (cached != null) {
-          ctx.lineCountMap.set(relPath, cached);
-        } else {
-          const absPath = path.join(rootDir, relPath);
-          try {
-            const content = readFileSafe(absPath);
-            ctx.lineCountMap.set(relPath, content.split('\n').length);
-          } catch {
-            ctx.lineCountMap.set(relPath, 0);
-          }
+  const changedFileList = isFullBuild ? null : [...allSymbols.keys()];
+
+  // For small incremental builds on large codebases, use a fast path that
+  // updates only the changed files' metrics via targeted SQL instead of
+  // loading ALL definitions from DB (~8ms) and recomputing ALL metrics (~15ms).
+  // Gate: ≤5 changed files AND significantly more existing files (>20) to
+  // avoid triggering on small test fixtures where directory metrics matter.
+  const existingFileCount = !isFullBuild
+    ? (
+        (ctx.nativeDb
+          ? ctx.nativeDb.queryGet("SELECT COUNT(*) as c FROM nodes WHERE kind = 'file'", [])
+          : db.prepare("SELECT COUNT(*) as c FROM nodes WHERE kind = 'file'").get()) as {
+          c: number;
         }
-      }
-    }
-    debug(`Structure: ${fileSymbols.size} files (${loadedFromDb} loaded from DB)`);
+      ).c
+    : 0;
+  const useSmallIncrementalFastPath =
+    !isFullBuild &&
+    changedFileList != null &&
+    changedFileList.length <= 5 &&
+    existingFileCount > 20;
+
+  if (!isFullBuild && !useSmallIncrementalFastPath) {
+    // Medium/large incremental: load unchanged files from DB for complete structure
+    loadUnchangedFilesFromDb(ctx);
   }
 
   // Build directory structure
   const t0 = performance.now();
-  const relDirs = new Set<string>();
-  for (const absDir of discoveredDirs) {
-    relDirs.add(normalizePath(path.relative(rootDir, absDir)));
-  }
-  try {
-    const { buildStructure: buildStructureFn } = (await import(
-      '../../../../features/structure.js'
-    )) as {
-      buildStructure: (
-        db: PipelineContext['db'],
-        fileSymbols: Map<string, ExtractorOutput>,
-        rootDir: string,
-        lineCountMap: Map<string, number>,
-        directories: Set<string>,
-        changedFiles: string[] | null,
-      ) => void;
-    };
-    const changedFilePaths = isFullBuild ? null : [...allSymbols.keys()];
-    buildStructureFn(db, fileSymbols, rootDir, ctx.lineCountMap, relDirs, changedFilePaths);
-  } catch (err) {
-    debug(`Structure analysis failed: ${(err as Error).message}`);
+  if (useSmallIncrementalFastPath) {
+    updateChangedFileMetrics(ctx, changedFileList!);
+  } else {
+    const relDirs = new Set<string>();
+    for (const absDir of discoveredDirs) {
+      relDirs.add(normalizePath(path.relative(rootDir, absDir)));
+    }
+    try {
+      const { buildStructure: buildStructureFn } = (await import(
+        '../../../../features/structure.js'
+      )) as {
+        buildStructure: (
+          db: PipelineContext['db'],
+          fileSymbols: Map<string, ExtractorOutput>,
+          rootDir: string,
+          lineCountMap: Map<string, number>,
+          directories: Set<string>,
+          changedFiles: string[] | null,
+        ) => void;
+      };
+      const changedFilePaths = isFullBuild ? null : [...allSymbols.keys()];
+      buildStructureFn(db, fileSymbols, rootDir, ctx.lineCountMap, relDirs, changedFilePaths);
+    } catch (err) {
+      debug(`Structure analysis failed: ${(err as Error).message}`);
+    }
   }
   ctx.timing.structureMs = performance.now() - t0;
 
-  // Classify node roles
+  // Classify node roles (incremental: only reclassify changed files' nodes)
   const t1 = performance.now();
   try {
-    const { classifyNodeRoles } = (await import('../../../../features/structure.js')) as {
-      classifyNodeRoles: (db: PipelineContext['db']) => Record<string, number>;
-    };
-    const roleSummary = classifyNodeRoles(db);
+    let roleSummary: Record<string, number> | null = null;
+
+    // Use NativeDatabase persistent connection (Phase 6.15+).
+    // Standalone napi functions were removed in 6.17 — falls through to JS if nativeDb unavailable.
+    if (ctx.nativeDb?.classifyRolesFull) {
+      const nativeResult =
+        changedFileList && changedFileList.length > 0
+          ? ctx.nativeDb.classifyRolesIncremental(changedFileList)
+          : ctx.nativeDb.classifyRolesFull();
+      if (nativeResult) {
+        roleSummary = {
+          entry: nativeResult.entry,
+          core: nativeResult.core,
+          utility: nativeResult.utility,
+          adapter: nativeResult.adapter,
+          dead: nativeResult.dead,
+          'dead-leaf': nativeResult.deadLeaf,
+          'dead-entry': nativeResult.deadEntry,
+          'dead-ffi': nativeResult.deadFfi,
+          'dead-unresolved': nativeResult.deadUnresolved,
+          'test-only': nativeResult.testOnly,
+          leaf: nativeResult.leaf,
+        };
+      }
+    }
+
+    // Fall back to JS path
+    if (!roleSummary) {
+      const { classifyNodeRoles } = (await import('../../../../features/structure.js')) as {
+        classifyNodeRoles: (
+          db: PipelineContext['db'],
+          changedFiles?: string[] | null,
+        ) => Record<string, number>;
+      };
+      roleSummary = classifyNodeRoles(db, changedFileList);
+    }
+
     debug(
-      `Roles: ${Object.entries(roleSummary)
+      `Roles${changedFileList ? ` (incremental, ${changedFileList.length} files)` : ''}: ${Object.entries(
+        roleSummary,
+      )
         .map(([r, c]) => `${r}=${c}`)
         .join(', ')}`,
     );
@@ -128,3 +141,155 @@ export async function buildStructure(ctx: PipelineContext): Promise<void> {
   }
   ctx.timing.rolesMs = performance.now() - t1;
 }
+
+// ── Small incremental fast path ──────────────────────────────────────────
+
+/**
+ * For small incremental builds, update only the changed files' node_metrics
+ * using targeted SQL queries. Skips the full DB load of all definitions
+ * (~8ms) and full structure rebuild (~15ms), replacing them with per-file
+ * indexed queries (~1-2ms total for 1-5 files).
+ *
+ * Directory metrics are not recomputed — a 1-5 file change won't
+ * meaningfully alter directory-level cohesion or symbol counts.
+ */
+function updateChangedFileMetrics(ctx: PipelineContext, changedFiles: string[]): void {
+  const { db } = ctx;
+
+  const getFileNodeId = db.prepare(
+    "SELECT id FROM nodes WHERE name = ? AND kind = 'file' AND file = ? AND line = 0",
+  );
+  const getSymbolCount = db.prepare(
+    "SELECT COUNT(*) as c FROM nodes WHERE file = ? AND kind != 'file' AND kind != 'directory'",
+  );
+  const getImportCount = db.prepare(`
+    SELECT COUNT(DISTINCT n2.file) AS cnt FROM edges e
+    JOIN nodes n1 ON e.source_id = n1.id
+    JOIN nodes n2 ON e.target_id = n2.id
+    WHERE e.kind = 'imports' AND n1.file = ?
+  `);
+  const getFanIn = db.prepare(`
+    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
+  `);
+  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
+  `);
+  const upsertMetric = db.prepare(`
+    INSERT OR REPLACE INTO node_metrics
+      (node_id, line_count, symbol_count, import_count, export_count, fan_in, fan_out, cohesion, file_count)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+
+  db.transaction(() => {
+    for (const relPath of changedFiles) {
+      const fileRow = getFileNodeId.get(relPath, relPath) as { id: number } | undefined;
+      if (!fileRow) continue;
+
+      const lineCount = ctx.lineCountMap.get(relPath) || 0;
+      const symbolCount = (getSymbolCount.get(relPath) as { c: number }).c;
+      const importCount = (getImportCount.get(relPath) as { cnt: number }).cnt;
+      const exportCount = ctx.fileSymbols.get(relPath)?.exports.length || 0;
+      const fanIn = (getFanIn.get(relPath) as { cnt: number }).cnt;
+      const fanOut = (getFanOut.get(relPath) as { cnt: number }).cnt;
+
+      upsertMetric.run(
+        fileRow.id,
+        lineCount,
+        symbolCount,
+        importCount,
+        exportCount,
+        fanIn,
+        fanOut,
+        null,
+        null,
+      );
+    }
+  })();
+
+  debug(`Structure (fast path): updated metrics for ${changedFiles.length} files`);
+}
+
+// ── Full incremental DB load (medium/large changes) ──────────────────────
+
+function loadUnchangedFilesFromDb(ctx: PipelineContext): void {
+  const { db, fileSymbols, rootDir } = ctx;
+
+  const existingFiles = db
+    .prepare("SELECT DISTINCT file FROM nodes WHERE kind = 'file'")
+    .all() as Array<{ file: string }>;
+
+  // Batch load: all definitions, import counts, and line counts in single queries
+  const allDefs = db
+    .prepare(
+      "SELECT file, name, kind, line FROM nodes WHERE kind != 'file' AND kind != 'directory'",
+    )
+    .all() as Array<{ file: string; name: string; kind: string; line: number }>;
+  const defsByFileMap = new Map<string, Array<{ name: string; kind: string; line: number }>>();
+  for (const row of allDefs) {
+    let arr = defsByFileMap.get(row.file);
+    if (!arr) {
+      arr = [];
+      defsByFileMap.set(row.file, arr);
+    }
+    arr.push({ name: row.name, kind: row.kind, line: row.line });
+  }
+
+  const allImportCounts = db
+    .prepare(
+      `SELECT n1.file, COUNT(DISTINCT n2.file) AS cnt FROM edges e
+       JOIN nodes n1 ON e.source_id = n1.id
+       JOIN nodes n2 ON e.target_id = n2.id
+       WHERE e.kind = 'imports'
+       GROUP BY n1.file`,
+    )
+    .all() as Array<{ file: string; cnt: number }>;
+  const importCountMap = new Map<string, number>();
+  for (const row of allImportCounts) {
+    importCountMap.set(row.file, row.cnt);
+  }
+
+  const cachedLineCounts = new Map<string, number>();
+  for (const row of db
+    .prepare(
+      `SELECT n.name AS file, m.line_count
+       FROM node_metrics m JOIN nodes n ON m.node_id = n.id
+       WHERE n.kind = 'file'`,
+    )
+    .all() as Array<{ file: string; line_count: number }>) {
+    cachedLineCounts.set(row.file, row.line_count);
+  }
+
+  let loadedFromDb = 0;
+  for (const { file: relPath } of existingFiles) {
+    if (!fileSymbols.has(relPath)) {
+      const importCount = importCountMap.get(relPath) || 0;
+      fileSymbols.set(relPath, {
+        definitions: defsByFileMap.get(relPath) || [],
+        imports: new Array(importCount) as unknown as ExtractorOutput['imports'],
+        exports: [],
+      } as unknown as ExtractorOutput);
+      loadedFromDb++;
+    }
+    if (!ctx.lineCountMap.has(relPath)) {
+      const cached = cachedLineCounts.get(relPath);
+      if (cached != null) {
+        ctx.lineCountMap.set(relPath, cached);
+      } else {
+        const absPath = path.join(rootDir, relPath);
+        try {
+          const content = readFileSafe(absPath);
+          ctx.lineCountMap.set(relPath, content.split('\n').length);
+        } catch {
+          ctx.lineCountMap.set(relPath, 0);
+        }
+      }
+    }
+  }
+  debug(`Structure: ${fileSymbols.size} files (${loadedFromDb} loaded from DB)`);
+}

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

@@ -2,14 +2,78 @@
  * Stage: collectFiles
  *
  * Collects all source files to process. Handles both normal and scoped rebuilds.
+ * For incremental builds with a valid journal, reconstructs the file list from
+ * the DB's file_hashes table + journal deltas, skipping the filesystem scan.
  */
 import fs from 'node:fs';
 import path from 'node:path';
-import { info } from '../../../../infrastructure/logger.js';
-import { normalizePath } from '../../../../shared/constants.js';
+import { debug, info } from '#infrastructure/logger.js';
+import { normalizePath } from '#shared/constants.js';
+import { readJournal } from '../../journal.js';
 import type { PipelineContext } from '../context.js';
 import { collectFiles as collectFilesUtil } from '../helpers.js';
 
+/**
+ * Reconstruct allFiles from DB file_hashes + journal deltas.
+ * Returns null when the fast path isn't applicable (first build, no journal, etc).
+ */
+function tryFastCollect(
+  ctx: PipelineContext,
+): { files: string[]; directories: Set<string> } | null {
+  const { db, rootDir } = ctx;
+
+  // 1. Check that file_hashes table exists and has entries
+  let dbFileCount: number;
+  try {
+    dbFileCount = (db.prepare('SELECT COUNT(*) as c FROM file_hashes').get() as { c: number }).c;
+  } catch {
+    return null;
+  }
+  if (dbFileCount === 0) return null;
+
+  // 2. Read the journal — only use fast path when journal has entries,
+  // proving the watcher was active and tracking changes. An empty-but-valid
+  // journal (no watcher) could miss file deletions.
+  const journal = readJournal(rootDir);
+  if (!journal.valid) return null;
+  const hasEntries =
+    (journal.changed && journal.changed.length > 0) ||
+    (journal.removed && journal.removed.length > 0);
+  if (!hasEntries) return null;
+
+  // 3. Load existing file list from file_hashes (relative paths)
+  const dbFiles = (db.prepare('SELECT file FROM file_hashes').all() as Array<{ file: string }>).map(
+    (r) => r.file,
+  );
+
+  // 4. Apply journal deltas: remove deleted files, add new/changed files
+  const fileSet = new Set(dbFiles);
+  if (journal.removed) {
+    for (const removed of journal.removed) {
+      fileSet.delete(removed);
+    }
+  }
+  if (journal.changed) {
+    for (const changed of journal.changed) {
+      fileSet.add(changed);
+    }
+  }
+
+  // 5. Convert to absolute paths and compute directories
+  const files: string[] = [];
+  const directories = new Set<string>();
+  for (const relPath of fileSet) {
+    const absPath = path.join(rootDir, relPath);
+    files.push(absPath);
+    directories.add(path.dirname(absPath));
+  }
+
+  debug(
+    `collectFiles fast path: ${dbFiles.length} from DB, journal: +${journal.changed?.length ?? 0}/-${journal.removed?.length ?? 0} → ${files.length} files`,
+  );
+  return { files, directories };
+}
+
 export async function collectFiles(ctx: PipelineContext): Promise<void> {
   const { rootDir, config, opts } = ctx;
 
@@ -33,10 +97,23 @@ export async function collectFiles(ctx: PipelineContext): Promise<void> {
     ctx.removed = missing;
     ctx.isFullBuild = false;
     info(`Scoped rebuild: ${existing.length} files to rebuild, ${missing.length} to purge`);
-  } else {
-    const collected = collectFilesUtil(rootDir, [], config, new Set<string>());
-    ctx.allFiles = collected.files;
-    ctx.discoveredDirs = collected.directories;
-    info(`Found ${ctx.allFiles.length} files to parse`);
+    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 collected = collectFilesUtil(rootDir, [], config, new Set<string>());
+  ctx.allFiles = collected.files;
+  ctx.discoveredDirs = collected.directories;
+  info(`Found ${ctx.allFiles.length} files to parse`);
 }

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

@@ -7,11 +7,10 @@
  */
 import fs from 'node:fs';
 import path from 'node:path';
-import type BetterSqlite3 from 'better-sqlite3';
 import { closeDb } from '../../../../db/index.js';
 import { debug, info } from '../../../../infrastructure/logger.js';
 import { normalizePath } from '../../../../shared/constants.js';
-import type { EngineOpts, ExtractorOutput } from '../../../../types.js';
+import type { BetterSqlite3Database, ExtractorOutput, NativeDatabase } from '../../../../types.js';
 import { parseFilesAuto } from '../../../parser.js';
 import { readJournal, writeJournalHeader } from '../../journal.js';
 import type { PipelineContext } from '../context.js';
@@ -56,13 +55,19 @@ interface NeedsHashItem {
 // ── Helpers ────────────────────────────────────────────────────────────
 
 function getChangedFiles(
-  db: BetterSqlite3.Database,
+  db: BetterSqlite3Database,
   allFiles: string[],
   rootDir: string,
+  nativeDb?: NativeDatabase,
 ): ChangeResult {
   let hasTable = false;
   try {
-    db.prepare('SELECT 1 FROM file_hashes LIMIT 1').get();
+    if (nativeDb) {
+      nativeDb.queryGet('SELECT 1 FROM file_hashes LIMIT 1', []);
+    } else {
+      db.prepare('SELECT 1 FROM file_hashes LIMIT 1').get();
+    }
+    // Query succeeded → table exists (result may be undefined if table is empty)
     hasTable = true;
   } catch {
     /* table doesn't exist */
@@ -76,11 +81,11 @@ function getChangedFiles(
     };
   }
 
-  const existing = new Map<string, FileHashRow>(
-    (db.prepare('SELECT file, hash, mtime, size FROM file_hashes').all() as FileHashRow[]).map(
-      (r) => [r.file, r],
-    ),
-  );
+  const sql = 'SELECT file, hash, mtime, size FROM file_hashes';
+  const rows = nativeDb
+    ? (nativeDb.queryAll(sql, []) as unknown as FileHashRow[])
+    : (db.prepare(sql).all() as FileHashRow[]);
+  const existing = new Map<string, FileHashRow>(rows.map((r) => [r.file, r]));
 
   const removed = detectRemovedFiles(existing, allFiles, rootDir);
   const journalResult = tryJournalTier(db, existing, rootDir, removed);
@@ -107,7 +112,7 @@ function detectRemovedFiles(
 }
 
 function tryJournalTier(
-  db: BetterSqlite3.Database,
+  db: BetterSqlite3Database,
   existing: Map<string, FileHashRow>,
   rootDir: string,
   removed: string[],
@@ -227,7 +232,7 @@ function mtimeAndHashTiers(
 async function runPendingAnalysis(ctx: PipelineContext): Promise<boolean> {
   const { db, opts, engineOpts, allFiles, rootDir } = ctx;
   const needsCfg =
-    (opts as Record<string, unknown>)['cfg'] !== false &&
+    (opts as Record<string, unknown>).cfg !== false &&
     (() => {
       try {
         return (
@@ -239,7 +244,7 @@ async function runPendingAnalysis(ctx: PipelineContext): Promise<boolean> {
       }
     })();
   const needsDataflow =
-    (opts as Record<string, unknown>)['dataflow'] !== false &&
+    (opts as Record<string, unknown>).dataflow !== false &&
     (() => {
       try {
         return (
@@ -255,7 +260,7 @@ async function runPendingAnalysis(ctx: PipelineContext): Promise<boolean> {
   info('No file changes. Running pending analysis pass...');
   const analysisOpts = {
     ...engineOpts,
-    dataflow: needsDataflow && (opts as Record<string, unknown>)['dataflow'] !== false,
+    dataflow: needsDataflow && (opts as Record<string, unknown>).dataflow !== false,
   };
   const analysisSymbols: Map<string, ExtractorOutput> = await parseFilesAuto(
     allFiles,
@@ -295,7 +300,7 @@ function healMetadata(ctx: PipelineContext): void {
 }
 
 function findReverseDependencies(
-  db: BetterSqlite3.Database,
+  db: BetterSqlite3Database,
   changedRelPaths: Set<string>,
   rootDir: string,
 ): Set<string> {
@@ -326,24 +331,36 @@ function purgeAndAddReverseDeps(
   reverseDeps: Set<string>,
 ): void {
   const { db, rootDir } = ctx;
-  if (changePaths.length > 0 || ctx.removed.length > 0) {
-    purgeFilesFromGraph(db, [...ctx.removed, ...changePaths], { purgeHashes: false });
-  }
-  if (reverseDeps.size > 0) {
-    const deleteOutgoingEdgesForFile = db.prepare(
-      'DELETE FROM edges WHERE source_id IN (SELECT id FROM nodes WHERE file = ?)',
-    );
-    for (const relPath of reverseDeps) {
-      deleteOutgoingEdgesForFile.run(relPath);
-    }
-    for (const relPath of reverseDeps) {
-      const absPath = path.join(rootDir, relPath);
-      ctx.parseChanges.push({ file: absPath, relPath, _reverseDepOnly: true });
+  const hasPurge = changePaths.length > 0 || ctx.removed.length > 0;
+  const hasReverseDeps = reverseDeps.size > 0;
+  const reverseDepList = hasReverseDeps ? [...reverseDeps] : [];
+
+  if (hasPurge || hasReverseDeps) {
+    const filesToPurge = hasPurge ? [...ctx.removed, ...changePaths] : [];
+    // Prefer NativeDatabase: purge + reverse-dep edge deletion in one transaction (#670)
+    if (ctx.nativeDb?.purgeFilesData) {
+      ctx.nativeDb.purgeFilesData(filesToPurge, false, hasReverseDeps ? reverseDepList : undefined);
+    } else {
+      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);
+        }
+      }
     }
   }
+  for (const relPath of reverseDeps) {
+    const absPath = path.join(rootDir, relPath);
+    ctx.parseChanges.push({ file: absPath, relPath, _reverseDepOnly: true });
+  }
 }
 
-function detectHasEmbeddings(db: BetterSqlite3.Database): boolean {
+function detectHasEmbeddings(db: BetterSqlite3Database): boolean {
   try {
     db.prepare('SELECT 1 FROM embeddings LIMIT 1').get();
     return true;
@@ -359,7 +376,7 @@ function handleScopedBuild(ctx: PipelineContext): void {
     (item) => item.relPath || normalizePath(path.relative(rootDir, item.file)),
   );
   let reverseDeps = new Set<string>();
-  if (!(opts as Record<string, unknown>)['noReverseDeps']) {
+  if (!(opts as Record<string, unknown>).noReverseDeps) {
     const changedRelPaths = new Set<string>([...changePaths, ...ctx.removed]);
     reverseDeps = findReverseDependencies(db, changedRelPaths, rootDir);
   }
@@ -386,7 +403,7 @@ function handleIncrementalBuild(ctx: PipelineContext): void {
   const { db, rootDir, opts } = ctx;
   ctx.hasEmbeddings = detectHasEmbeddings(db);
   let reverseDeps = new Set<string>();
-  if (!(opts as Record<string, unknown>)['noReverseDeps']) {
+  if (!(opts as Record<string, unknown>).noReverseDeps) {
     const changedRelPaths = new Set<string>();
     for (const item of ctx.parseChanges) {
       changedRelPaths.add(item.relPath || normalizePath(path.relative(rootDir, item.file)));
@@ -410,13 +427,13 @@ 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']) {
+  if ((opts as Record<string, unknown>).scope) {
     handleScopedBuild(ctx);
     return;
   }
   const increResult =
     incremental && !forceFullRebuild
-      ? getChangedFiles(db, allFiles, rootDir)
+      ? getChangedFiles(db, allFiles, rootDir, ctx.nativeDb)
       : {
           changed: allFiles.map((f): ChangedFile => ({ file: f })),
           removed: [] as string[],