@optave/codegraph 3.6.0 → 3.8.0

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

@@ -155,6 +155,155 @@ function buildBarrelEdges(
   }
 }
 
+// ── Import edges (native engine) ────────────────────────────────────────
+
+function buildImportEdgesNative(
+  ctx: PipelineContext,
+  getNodeIdStmt: NodeIdStmt,
+  allEdgeRows: EdgeRowTuple[],
+  native: NativeAddon,
+): void {
+  const { fileSymbols, barrelOnlyFiles, rootDir } = ctx;
+
+  // 1. Build per-file input data
+  const files: Array<{
+    file: string;
+    fileNodeId: number;
+    isBarrelOnly: boolean;
+    imports: Array<{
+      source: string;
+      names: string[];
+      reexport: boolean;
+      typeOnly: boolean;
+      dynamicImport: boolean;
+      wildcardReexport: boolean;
+    }>;
+    definitionNames: string[];
+  }> = [];
+
+  // Collect all file node IDs we'll need (sources + targets)
+  const fileNodeIds: Array<{ file: string; nodeId: number }> = [];
+  const seenNodeFiles = new Set<string>();
+
+  const addFileNodeId = (relPath: string): { id: number } | undefined => {
+    if (seenNodeFiles.has(relPath)) return fileNodeRowCache.get(relPath);
+    const row = getNodeIdStmt.get(relPath, 'file', relPath, 0);
+    if (row) {
+      seenNodeFiles.add(relPath);
+      fileNodeIds.push({ file: relPath, nodeId: row.id });
+      fileNodeRowCache.set(relPath, row);
+    }
+    return row;
+  };
+  const fileNodeRowCache = new Map<string, { id: number }>();
+
+  // 2. Pre-resolve all imports and collect supplemental resolved entries
+  const supplementalResolved: Array<{ key: string; resolvedPath: string }> = [];
+
+  for (const [relPath, symbols] of fileSymbols) {
+    const fileNodeRow = addFileNodeId(relPath);
+    if (!fileNodeRow) continue;
+
+    const importInfos: Array<{
+      source: string;
+      names: string[];
+      reexport: boolean;
+      typeOnly: boolean;
+      dynamicImport: boolean;
+      wildcardReexport: boolean;
+    }> = [];
+
+    for (const imp of symbols.imports) {
+      // Pre-resolve and register target file node
+      const resolvedPath = getResolved(ctx, path.join(rootDir, relPath), imp.source);
+      addFileNodeId(resolvedPath);
+
+      // Check if this resolution is in batchResolved; if not, add supplemental
+      const resolveKey = `${path.join(rootDir, relPath)}|${imp.source}`;
+      if (!ctx.batchResolved?.has(resolveKey)) {
+        supplementalResolved.push({ key: resolveKey, resolvedPath });
+      }
+
+      importInfos.push({
+        source: imp.source,
+        names: imp.names,
+        reexport: !!imp.reexport,
+        typeOnly: !!imp.typeOnly,
+        dynamicImport: !!imp.dynamicImport,
+        wildcardReexport: !!imp.wildcardReexport,
+      });
+    }
+
+    files.push({
+      file: relPath,
+      fileNodeId: fileNodeRow.id,
+      isBarrelOnly: barrelOnlyFiles.has(relPath),
+      imports: importInfos,
+      definitionNames: symbols.definitions.map((d) => d.name),
+    });
+  }
+
+  // 3. Flatten batchResolved + supplemental into resolved imports array
+  const resolvedImports: Array<{ key: string; resolvedPath: string }> = [];
+  if (ctx.batchResolved) {
+    for (const [key, resolvedPath] of ctx.batchResolved) {
+      resolvedImports.push({ key, resolvedPath });
+    }
+  }
+  for (const entry of supplementalResolved) {
+    resolvedImports.push(entry);
+  }
+
+  // 4. Flatten reexportMap
+  const fileReexports: Array<{
+    file: string;
+    reexports: Array<{
+      source: string;
+      names: string[];
+      wildcardReexport: boolean;
+    }>;
+  }> = [];
+  if (ctx.reexportMap) {
+    for (const [file, entries] of ctx.reexportMap) {
+      const reexports = (
+        entries as Array<{ source: string; names: string[]; wildcardReexport: boolean }>
+      ).map((re) => ({
+        source: re.source,
+        names: re.names,
+        wildcardReexport: !!re.wildcardReexport,
+      }));
+      fileReexports.push({ file, reexports });
+
+      // Register reexport target files for node ID lookup
+      for (const re of reexports) {
+        addFileNodeId(re.source);
+      }
+    }
+  }
+
+  // 5. Compute barrel file list
+  const barrelFiles: string[] = [];
+  for (const [relPath] of fileSymbols) {
+    if (isBarrelFile(ctx, relPath)) {
+      barrelFiles.push(relPath);
+    }
+  }
+
+  // 6. Call native
+  const nativeEdges = native.buildImportEdges!(
+    files,
+    resolvedImports,
+    fileReexports,
+    fileNodeIds,
+    barrelFiles,
+    rootDir,
+  ) as NativeEdge[];
+
+  for (const e of nativeEdges) {
+    allEdgeRows.push([e.sourceId, e.targetId, e.kind, e.confidence, e.dynamic]);
+  }
+}
+
 // ── Call edges (native engine) ──────────────────────────────────────────
 
 function buildCallEdgesNative(
@@ -594,7 +743,15 @@ export async function buildEdges(ctx: PipelineContext): Promise<void> {
       }
     }
 
-    buildImportEdges(ctx, getNodeIdStmt, allEdgeRows);
+    // Skip native import-edge path for small incremental builds (≤3 files):
+    // napi-rs marshaling overhead exceeds computation savings.
+    const useNativeImportEdges =
+      native?.buildImportEdges && (ctx.isFullBuild || ctx.fileSymbols.size > 3);
+    if (useNativeImportEdges) {
+      buildImportEdgesNative(ctx, getNodeIdStmt, allEdgeRows, native!);
+    } else {
+      buildImportEdges(ctx, getNodeIdStmt, allEdgeRows);
+    }
 
     // Skip native call-edge path for small incremental builds (≤3 files):
     // napi-rs marshaling overhead for allNodes exceeds computation savings.

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

@@ -21,13 +21,22 @@ function tryFastCollect(
   ctx: PipelineContext,
 ): { files: string[]; directories: Set<string> } | null {
   const { db, rootDir } = ctx;
+  const useNative = ctx.engineName === 'native' && !!ctx.nativeDb?.getCollectFilesData;
 
   // 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;
+  let dbFiles: string[];
+  if (useNative) {
+    const data = ctx.nativeDb!.getCollectFilesData!();
+    dbFileCount = data.count;
+    dbFiles = data.files;
+  } else {
+    try {
+      dbFileCount = (db.prepare('SELECT COUNT(*) as c FROM file_hashes').get() as { c: number }).c;
+    } catch {
+      return null;
+    }
+    dbFiles = []; // deferred — loaded below only if needed
   }
   if (dbFileCount === 0) return null;
 
@@ -42,9 +51,11 @@ function tryFastCollect(
   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,
-  );
+  if (!useNative) {
+    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);

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

@@ -60,14 +60,27 @@ function getChangedFiles(
   rootDir: string,
   nativeDb?: NativeDatabase,
 ): ChangeResult {
+  // Batched native path: single napi call for table check + all rows + max mtime
+  if (nativeDb?.getFileHashData) {
+    const data = nativeDb.getFileHashData();
+    if (!data.exists) {
+      return {
+        changed: allFiles.map((f) => ({ file: f })),
+        removed: [],
+        isFullBuild: true,
+      };
+    }
+    const existing = new Map<string, FileHashRow>(data.rows.map((r) => [r.file, r]));
+    const removed = detectRemovedFiles(existing, allFiles, rootDir);
+    const journalResult = tryJournalTier(db, existing, rootDir, removed, data.maxMtime);
+    if (journalResult) return journalResult;
+    return mtimeAndHashTiers(existing, allFiles, rootDir, removed);
+  }
+
+  // WASM / fallback path
   let hasTable = false;
   try {
-    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)
+    db.prepare('SELECT 1 FROM file_hashes LIMIT 1').get();
     hasTable = true;
   } catch {
     /* table doesn't exist */
@@ -81,10 +94,7 @@ function getChangedFiles(
     };
   }
 
-  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 rows = db.prepare('SELECT file, hash, mtime, size FROM file_hashes').all() as FileHashRow[];
   const existing = new Map<string, FileHashRow>(rows.map((r) => [r.file, r]));
 
   const removed = detectRemovedFiles(existing, allFiles, rootDir);
@@ -116,14 +126,19 @@ function tryJournalTier(
   existing: Map<string, FileHashRow>,
   rootDir: string,
   removed: string[],
+  precomputedMaxMtime?: number,
 ): ChangeResult | null {
   const journal = readJournal(rootDir);
   if (!journal.valid) return null;
 
-  const dbMtimes = db.prepare('SELECT MAX(mtime) as latest FROM file_hashes').get() as
-    | { latest: number | null }
-    | undefined;
-  const latestDbMtime = dbMtimes?.latest || 0;
+  const latestDbMtime =
+    precomputedMaxMtime ??
+    ((
+      db.prepare('SELECT MAX(mtime) as latest FROM file_hashes').get() as
+        | { latest: number | null }
+        | undefined
+    )?.latest ||
+      0);
   const hasJournalEntries = journal.changed!.length > 0 || journal.removed!.length > 0;
 
   if (!hasJournalEntries || journal.timestamp! < latestDbMtime) {
@@ -231,30 +246,42 @@ 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 &&
-    (() => {
-      try {
-        return (
-          (db.prepare('SELECT COUNT(*) as c FROM cfg_blocks').get() as { c: number } | undefined)
-            ?.c === 0
-        );
-      } catch {
-        return true;
-      }
-    })();
-  const needsDataflow =
-    (opts as Record<string, unknown>).dataflow !== false &&
-    (() => {
-      try {
-        return (
-          (db.prepare('SELECT COUNT(*) as c FROM dataflow').get() as { c: number } | undefined)
-            ?.c === 0
-        );
-      } catch {
-        return true;
-      }
-    })();
+  const useNative = ctx.engineName === 'native' && !!ctx.nativeDb?.checkPendingAnalysis;
+
+  let needsCfg: boolean;
+  let needsDataflow: boolean;
+
+  if (useNative) {
+    const counts = ctx.nativeDb!.checkPendingAnalysis!();
+    needsCfg = (opts as Record<string, unknown>).cfg !== false && counts.cfgCount <= 0;
+    needsDataflow =
+      (opts as Record<string, unknown>).dataflow !== false && counts.dataflowCount <= 0;
+  } else {
+    needsCfg =
+      (opts as Record<string, unknown>).cfg !== false &&
+      (() => {
+        try {
+          return (
+            (db.prepare('SELECT COUNT(*) as c FROM cfg_blocks').get() as { c: number } | undefined)
+              ?.c === 0
+          );
+        } catch {
+          return true;
+        }
+      })();
+    needsDataflow =
+      (opts as Record<string, unknown>).dataflow !== false &&
+      (() => {
+        try {
+          return (
+            (db.prepare('SELECT COUNT(*) as c FROM dataflow').get() as { c: number } | undefined)
+              ?.c === 0
+          );
+        } catch {
+          return true;
+        }
+      })();
+  }
   if (!needsCfg && !needsDataflow) return false;
 
   info('No file changes. Running pending analysis pass...');
@@ -282,17 +309,27 @@ function healMetadata(ctx: PipelineContext): void {
   const { db, metadataUpdates } = ctx;
   if (!metadataUpdates || metadataUpdates.length === 0) return;
   try {
-    const healHash = db.prepare(
-      'INSERT OR REPLACE INTO file_hashes (file, hash, mtime, size) VALUES (?, ?, ?, ?)',
-    );
-    const healTx = db.transaction(() => {
-      for (const item of metadataUpdates) {
-        const mtime = item.stat ? Math.floor(item.stat.mtime) : 0;
-        const size = item.stat ? item.stat.size : 0;
-        healHash.run(item.relPath, item.hash, mtime, size);
-      }
-    });
-    healTx();
+    if (ctx.engineName === 'native' && ctx.nativeDb?.healFileMetadata) {
+      const entries = metadataUpdates.map((item) => ({
+        file: item.relPath,
+        hash: item.hash,
+        mtime: item.stat ? Math.floor(item.stat.mtime) : 0,
+        size: item.stat ? item.stat.size : 0,
+      }));
+      ctx.nativeDb.healFileMetadata(entries);
+    } else {
+      const healHash = db.prepare(
+        'INSERT OR REPLACE INTO file_hashes (file, hash, mtime, size) VALUES (?, ?, ?, ?)',
+      );
+      const healTx = db.transaction(() => {
+        for (const item of metadataUpdates) {
+          const mtime = item.stat ? Math.floor(item.stat.mtime) : 0;
+          const size = item.stat ? item.stat.size : 0;
+          healHash.run(item.relPath, item.hash, mtime, size);
+        }
+      });
+      healTx();
+    }
     debug(`Self-healed mtime/size for ${metadataUpdates.length} files`);
   } catch {
     /* ignore heal errors */
@@ -303,9 +340,23 @@ function findReverseDependencies(
   db: BetterSqlite3Database,
   changedRelPaths: Set<string>,
   rootDir: string,
+  nativeDb?: NativeDatabase,
 ): Set<string> {
   const reverseDeps = new Set<string>();
   if (changedRelPaths.size === 0) return reverseDeps;
+
+  if (nativeDb?.findReverseDependencies) {
+    const changedArray = [...changedRelPaths];
+    const nativeResults = nativeDb.findReverseDependencies(changedArray);
+    for (const dep of nativeResults) {
+      const absPath = path.join(rootDir, dep);
+      if (fs.existsSync(absPath)) {
+        reverseDeps.add(dep);
+      }
+    }
+    return reverseDeps;
+  }
+
   const findReverseDepsStmt = db.prepare(`
     SELECT DISTINCT n_src.file FROM edges e
     JOIN nodes n_src ON e.source_id = n_src.id
@@ -360,7 +411,10 @@ function purgeAndAddReverseDeps(
   }
 }
 
-function detectHasEmbeddings(db: BetterSqlite3Database): boolean {
+function detectHasEmbeddings(db: BetterSqlite3Database, nativeDb?: NativeDatabase): boolean {
+  if (nativeDb?.hasEmbeddings) {
+    return nativeDb.hasEmbeddings();
+  }
   try {
     db.prepare('SELECT 1 FROM embeddings LIMIT 1').get();
     return true;
@@ -371,14 +425,14 @@ function detectHasEmbeddings(db: BetterSqlite3Database): boolean {
 
 function handleScopedBuild(ctx: PipelineContext): void {
   const { db, rootDir, opts } = ctx;
-  ctx.hasEmbeddings = detectHasEmbeddings(db);
+  ctx.hasEmbeddings = detectHasEmbeddings(db, ctx.nativeDb);
   const changePaths = ctx.parseChanges.map(
     (item) => item.relPath || normalizePath(path.relative(rootDir, item.file)),
   );
   let reverseDeps = new Set<string>();
   if (!(opts as Record<string, unknown>).noReverseDeps) {
     const changedRelPaths = new Set<string>([...changePaths, ...ctx.removed]);
-    reverseDeps = findReverseDependencies(db, changedRelPaths, rootDir);
+    reverseDeps = findReverseDependencies(db, changedRelPaths, rootDir, ctx.nativeDb);
   }
   purgeAndAddReverseDeps(ctx, changePaths, reverseDeps);
   info(
@@ -388,7 +442,7 @@ function handleScopedBuild(ctx: PipelineContext): void {
 
 function handleFullBuild(ctx: PipelineContext): void {
   const { db } = ctx;
-  const hasEmbeddings = detectHasEmbeddings(db);
+  const hasEmbeddings = detectHasEmbeddings(db, ctx.nativeDb);
   ctx.hasEmbeddings = hasEmbeddings;
   const deletions =
     'PRAGMA foreign_keys = OFF; DELETE FROM cfg_edges; DELETE FROM cfg_blocks; DELETE FROM node_metrics; DELETE FROM edges; DELETE FROM function_complexity; DELETE FROM dataflow; DELETE FROM ast_nodes; DELETE FROM nodes; PRAGMA foreign_keys = ON;';
@@ -401,7 +455,7 @@ function handleFullBuild(ctx: PipelineContext): void {
 
 function handleIncrementalBuild(ctx: PipelineContext): void {
   const { db, rootDir, opts } = ctx;
-  ctx.hasEmbeddings = detectHasEmbeddings(db);
+  ctx.hasEmbeddings = detectHasEmbeddings(db, ctx.nativeDb);
   let reverseDeps = new Set<string>();
   if (!(opts as Record<string, unknown>).noReverseDeps) {
     const changedRelPaths = new Set<string>();
@@ -411,7 +465,7 @@ function handleIncrementalBuild(ctx: PipelineContext): void {
     for (const relPath of ctx.removed) {
       changedRelPaths.add(relPath);
     }
-    reverseDeps = findReverseDependencies(db, changedRelPaths, rootDir);
+    reverseDeps = findReverseDependencies(db, changedRelPaths, rootDir, ctx.nativeDb);
   }
   info(
     `Incremental: ${ctx.parseChanges.length} changed, ${ctx.removed.length} removed${reverseDeps.size > 0 ? `, ${reverseDeps.size} reverse-deps` : ''}`,

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

@@ -114,11 +114,33 @@ function persistBuildMetadata(
  * Run advisory checks on full builds: orphaned embeddings, stale embeddings,
  * and unused exports. Informational only — does not affect correctness.
  */
-function runAdvisoryChecks(
-  db: PipelineContext['db'],
-  hasEmbeddings: boolean,
-  buildNow: Date,
-): void {
+function runAdvisoryChecks(ctx: PipelineContext, hasEmbeddings: boolean, buildNow: Date): void {
+  // Batched native path: single napi call for all 3 advisory checks
+  if (ctx.engineName === 'native' && ctx.nativeDb?.runAdvisoryChecks) {
+    const result = ctx.nativeDb.runAdvisoryChecks(hasEmbeddings);
+    if (result.orphanedEmbeddings > 0) {
+      warn(
+        `${result.orphanedEmbeddings} embeddings are orphaned (nodes changed). Run "codegraph embed" to refresh.`,
+      );
+    }
+    if (result.embedBuiltAt) {
+      const embedTime = new Date(result.embedBuiltAt).getTime();
+      if (!Number.isNaN(embedTime) && embedTime < buildNow.getTime()) {
+        warn(
+          'Embeddings were built before the last graph rebuild. Run "codegraph embed" to update.',
+        );
+      }
+    }
+    if (result.unusedExports > 0) {
+      warn(
+        `${result.unusedExports} exported symbol${result.unusedExports > 1 ? 's have' : ' has'} zero cross-file consumers. Run "codegraph exports <file> --unused" to inspect.`,
+      );
+    }
+    return;
+  }
+
+  const { db } = ctx;
+
   // Orphaned embeddings warning
   if (hasEmbeddings) {
     try {
@@ -197,9 +219,17 @@ export async function finalize(ctx: PipelineContext): Promise<void> {
   // both the stale-embeddings comparison and the persisted built_at metadata.
   const buildNow = new Date();
 
-  const nodeCount = (ctx.db.prepare('SELECT COUNT(*) as c FROM nodes').get() as { c: number }).c;
-  const actualEdgeCount = (ctx.db.prepare('SELECT COUNT(*) as c FROM edges').get() as { c: number })
-    .c;
+  const useNative = ctx.engineName === 'native' && !!ctx.nativeDb?.getFinalizeCounts;
+  let nodeCount: number;
+  let actualEdgeCount: number;
+  if (useNative) {
+    const counts = ctx.nativeDb!.getFinalizeCounts!();
+    nodeCount = counts.nodeCount;
+    actualEdgeCount = counts.edgeCount;
+  } else {
+    nodeCount = (ctx.db.prepare('SELECT COUNT(*) as c FROM nodes').get() as { c: number }).c;
+    actualEdgeCount = (ctx.db.prepare('SELECT COUNT(*) as c FROM edges').get() as { c: number }).c;
+  }
   info(`Graph built: ${nodeCount} nodes, ${actualEdgeCount} edges`);
   info(`Stored in ${ctx.dbPath}`);
 
@@ -213,7 +243,7 @@ export async function finalize(ctx: PipelineContext): Promise<void> {
       'Finalize: skipping advisory queries (orphaned/stale embeddings, unused exports) for incremental build',
     );
   } else {
-    runAdvisoryChecks(ctx.db, hasEmbeddings, buildNow);
+    runAdvisoryChecks(ctx, hasEmbeddings, buildNow);
   }
 
   // Intentionally measured before closeDb / writeJournalHeader / auto-registration:

package/src/domain/graph/builder/stages/insert-nodes.ts

@@ -39,12 +39,6 @@ interface PrecomputedFileData {
 // ── Native fast-path ─────────────────────────────────────────────────
 
 function tryNativeInsert(ctx: PipelineContext): boolean {
-  // Disabled: bulkInsertNodes corrupts the DB when both the JS (better-sqlite3)
-  // and Rust (rusqlite) connections are open to the same WAL-mode file.
-  // The native path was never operational before — it always crashed on null
-  // visibility serialisation. See #696 for the dual-connection fix.
-  if (ctx.db) return false;
-
   // 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?.bulkInsertNodes) return false;
@@ -144,7 +138,24 @@ function tryNativeInsert(ctx: PipelineContext): boolean {
     fileHashes.push({ file: item.relPath, hash: item.hash, mtime, size });
   }
 
-  return ctx.nativeDb!.bulkInsertNodes(batches, fileHashes, removed);
+  // WAL guard: same suspendJsDb/resumeJsDb pattern used by feature modules
+  // (ast, cfg, complexity, dataflow). Checkpoint JS side before native write,
+  // then checkpoint native side after, so neither library reads WAL frames
+  // written by the other (#696, #709, #715, #717).
+  let result: boolean;
+  try {
+    if (ctx.db) {
+      ctx.db.pragma('wal_checkpoint(TRUNCATE)');
+    }
+    result = ctx.nativeDb!.bulkInsertNodes(batches, fileHashes, removed);
+  } finally {
+    try {
+      ctx.nativeDb?.exec('PRAGMA wal_checkpoint(TRUNCATE)');
+    } catch {
+      /* ignore — nativeDb may already be closed */
+    }
+  }
+  return result;
 }
 
 // ── JS fallback: Phase 1 ────────────────────────────────────────────