@optave/codegraph 3.4.1 → 3.6.0

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

@@ -3,6 +3,10 @@
  *
  * Batch-inserts file nodes, definitions, exports, children, and contains/parameter_of edges.
  * Updates file hashes for incremental builds.
+ *
+ * When the native engine is available, delegates all SQLite writes to Rust via
+ * `bulkInsertNodes` — eliminating JS↔C boundary overhead. Falls back to the
+ * JS implementation on failure or when native is unavailable.
  */
 import path from 'node:path';
 import { performance } from 'node:perf_hooks';
@@ -32,7 +36,118 @@ interface PrecomputedFileData {
   _reverseDepOnly?: boolean;
 }
 
-// ── Phase 1: Insert file nodes, definitions, exports ────────────────────
+// ── 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;
+
+  const { allSymbols, filesToParse, metadataUpdates, rootDir, removed } = ctx;
+
+  // Marshal allSymbols → InsertNodesBatch[]
+  const batches: Array<{
+    file: string;
+    definitions: Array<{
+      name: string;
+      kind: string;
+      line: number;
+      endLine?: number;
+      visibility?: string;
+      children: Array<{
+        name: string;
+        kind: string;
+        line: number;
+        endLine?: number;
+        visibility?: string;
+      }>;
+    }>;
+    exports: Array<{ name: string; kind: string; line: number }>;
+  }> = [];
+
+  for (const [relPath, symbols] of allSymbols) {
+    batches.push({
+      file: relPath,
+      definitions: symbols.definitions.map((def) => ({
+        name: def.name,
+        kind: def.kind,
+        line: def.line,
+        endLine: def.endLine ?? undefined,
+        visibility: def.visibility ?? undefined,
+        children: (def.children ?? []).map((c) => ({
+          name: c.name,
+          kind: c.kind,
+          line: c.line,
+          endLine: c.endLine ?? undefined,
+          visibility: c.visibility ?? undefined,
+        })),
+      })),
+      exports: symbols.exports.map((exp) => ({
+        name: exp.name,
+        kind: exp.kind,
+        line: exp.line,
+      })),
+    });
+  }
+
+  // Build file hash entries
+  const precomputedData = new Map<string, PrecomputedFileData>();
+  for (const item of filesToParse) {
+    if (item.relPath) precomputedData.set(item.relPath, item as PrecomputedFileData);
+  }
+
+  const fileHashes: Array<{ file: string; hash: string; mtime: number; size: number }> = [];
+  for (const [relPath] of allSymbols) {
+    const precomputed = precomputedData.get(relPath);
+    if (precomputed?._reverseDepOnly) {
+      continue; // file unchanged, hash already correct
+    }
+    if (precomputed?.hash) {
+      let mtime: number;
+      let size: number;
+      if (precomputed.stat) {
+        mtime = precomputed.stat.mtime;
+        size = precomputed.stat.size;
+      } else {
+        const rawStat = fileStat(path.join(rootDir, relPath));
+        mtime = rawStat ? Math.floor(rawStat.mtimeMs) : 0;
+        size = rawStat ? rawStat.size : 0;
+      }
+      fileHashes.push({ file: relPath, hash: precomputed.hash, mtime, size });
+    } else {
+      const absPath = path.join(rootDir, relPath);
+      let code: string | null;
+      try {
+        code = readFileSafe(absPath);
+      } catch {
+        code = null;
+      }
+      if (code !== null) {
+        const stat = fileStat(absPath);
+        const mtime = stat ? Math.floor(stat.mtimeMs) : 0;
+        const size = stat ? stat.size : 0;
+        fileHashes.push({ file: relPath, hash: fileHash(code), mtime, size });
+      }
+    }
+  }
+
+  // Also include metadata-only updates (self-heal mtime/size without re-parse)
+  for (const item of metadataUpdates) {
+    const mtime = item.stat ? Math.floor(item.stat.mtime) : 0;
+    const size = item.stat ? item.stat.size : 0;
+    fileHashes.push({ file: item.relPath, hash: item.hash, mtime, size });
+  }
+
+  return ctx.nativeDb!.bulkInsertNodes(batches, fileHashes, removed);
+}
+
+// ── JS fallback: Phase 1 ────────────────────────────────────────────
 
 function insertDefinitionsAndExports(
   db: BetterSqlite3Database,
@@ -90,7 +205,7 @@ function insertDefinitionsAndExports(
   }
 }
 
-// ── Phase 2+3: Insert children and containment edges (two nodeIdMap passes) ──
+// ── JS fallback: Phase 2+3 ──────────────────────────────────────────
 
 function insertChildrenAndEdges(
   db: BetterSqlite3Database,
@@ -165,7 +280,7 @@ function insertChildrenAndEdges(
   batchInsertEdges(db, edgeRows);
 }
 
-// ── Phase 4: Update file hashes ─────────────────────────────────────────
+// ── JS fallback: Phase 4 ────────────────────────────────────────────
 
 function updateFileHashes(
   _db: BetterSqlite3Database,
@@ -218,11 +333,32 @@ function updateFileHashes(
   }
 }
 
-// ── Main entry point ────────────────────────────────────────────────────
+// ── Main entry point ────────────────────────────────────────────────
 
 export async function insertNodes(ctx: PipelineContext): Promise<void> {
-  const { db, allSymbols, filesToParse, metadataUpdates, rootDir, removed } = ctx;
+  const { allSymbols, filesToParse, metadataUpdates, rootDir, removed } = ctx;
+
+  // Populate fileSymbols before any DB writes (used by later stages)
+  for (const [relPath, symbols] of allSymbols) {
+    ctx.fileSymbols.set(relPath, symbols);
+  }
+
+  const t0 = performance.now();
+
+  // Try native Rust path first — single transaction, no JS↔C overhead
+  if (ctx.engineName === 'native') {
+    try {
+      if (tryNativeInsert(ctx)) {
+        ctx.timing.insertMs = performance.now() - t0;
+        // Removed-file hash cleanup is handled inside the native call
+        return;
+      }
+    } catch {
+      // Native insert failed — fall through to JS implementation
+    }
+  }
 
+  // JS fallback
   const precomputedData = new Map<string, PrecomputedFileData>();
   for (const item of filesToParse) {
     if (item.relPath) precomputedData.set(item.relPath, item as PrecomputedFileData);
@@ -230,31 +366,25 @@ export async function insertNodes(ctx: PipelineContext): Promise<void> {
 
   let upsertHash: SqliteStatement | null;
   try {
-    upsertHash = db.prepare(
+    upsertHash = ctx.db.prepare(
       'INSERT OR REPLACE INTO file_hashes (file, hash, mtime, size) VALUES (?, ?, ?, ?)',
     );
   } catch {
     upsertHash = null;
   }
 
-  // Populate fileSymbols before the transaction so it is a pure input
-  for (const [relPath, symbols] of allSymbols) {
-    ctx.fileSymbols.set(relPath, symbols);
-  }
-
-  const insertAll = db.transaction(() => {
-    insertDefinitionsAndExports(db, allSymbols);
-    insertChildrenAndEdges(db, allSymbols);
-    updateFileHashes(db, allSymbols, precomputedData, metadataUpdates, rootDir, upsertHash);
+  const insertAll = ctx.db.transaction(() => {
+    insertDefinitionsAndExports(ctx.db, allSymbols);
+    insertChildrenAndEdges(ctx.db, allSymbols);
+    updateFileHashes(ctx.db, allSymbols, precomputedData, metadataUpdates, rootDir, upsertHash);
   });
 
-  const t0 = performance.now();
   insertAll();
   ctx.timing.insertMs = performance.now() - t0;
 
   // Clean up removed file hashes
   if (upsertHash && removed.length > 0) {
-    const deleteHash = db.prepare('DELETE FROM file_hashes WHERE file = ?');
+    const deleteHash = ctx.db.prepare('DELETE FROM file_hashes WHERE file = ?');
     for (const relPath of removed) {
       deleteHash.run(relPath);
     }

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

@@ -1,5 +1,6 @@
 import path from 'node:path';
 import { performance } from 'node:perf_hooks';
+import { debug } from '../../../../infrastructure/logger.js';
 import type { Import } from '../../../../types.js';
 import { parseFilesAuto } from '../../../parser.js';
 import { resolveImportPath, resolveImportsBatch } from '../../resolve.js';
@@ -132,8 +133,8 @@ export async function resolveImports(ctx: PipelineContext): Promise<void> {
             );
           }
         }
-      } catch {
-        /* skip if unreadable */
+      } catch (e: unknown) {
+        debug(`Barrel re-parse failed (non-fatal): ${(e as Error).message}`);
       }
     }
   }

package/src/domain/graph/resolve.ts

@@ -117,6 +117,35 @@ function matchSubpathPattern(pattern: string, subpath: string): string | null {
  * Resolve a bare specifier through the package.json exports field.
  * Returns an absolute path or null.
  */
+/** Try to resolve a condition target to a file path in packageDir. */
+function tryResolveTarget(target: string | null, packageDir: string): string | null {
+  if (!target) return null;
+  const resolved = path.resolve(packageDir, target);
+  return fs.existsSync(resolved) ? resolved : null;
+}
+
+/** Resolve subpath against a subpath map (object with "." keys). */
+function resolveSubpathMap(
+  exports: Record<string, unknown>,
+  subpath: string,
+  packageDir: string,
+): string | null {
+  // Exact match first
+  if (subpath in exports) {
+    return tryResolveTarget(resolveCondition(exports[subpath]), packageDir);
+  }
+  // Pattern matching (keys with *)
+  for (const [pattern, value] of Object.entries(exports)) {
+    if (!pattern.includes('*')) continue;
+    const matched = matchSubpathPattern(pattern, subpath);
+    if (matched == null) continue;
+    const rawTarget = resolveCondition(value);
+    if (!rawTarget) continue;
+    return tryResolveTarget(rawTarget.replace(/\*/g, matched), packageDir);
+  }
+  return null;
+}
+
 export function resolveViaExports(specifier: string, rootDir: string): string | null {
   const parsed = parseBareSpecifier(specifier);
   if (!parsed) return null;
@@ -131,66 +160,25 @@ export function resolveViaExports(specifier: string, rootDir: string): string |
 
   // Simple string exports: "exports": "./index.js"
   if (typeof exports === 'string') {
-    if (subpath === '.') {
-      const resolved = path.resolve(packageDir, exports);
-      return fs.existsSync(resolved) ? resolved : null;
-    }
-    return null;
+    return subpath === '.' ? tryResolveTarget(exports, packageDir) : null;
   }
 
   // Array form at top level
   if (Array.isArray(exports)) {
-    if (subpath === '.') {
-      const target = resolveCondition(exports);
-      if (target) {
-        const resolved = path.resolve(packageDir, target);
-        return fs.existsSync(resolved) ? resolved : null;
-      }
-    }
-    return null;
+    return subpath === '.' ? tryResolveTarget(resolveCondition(exports), packageDir) : null;
   }
 
   if (typeof exports !== 'object') return null;
 
-  // Determine if exports is a conditions object (no keys start with ".")
-  // or a subpath map (keys start with ".")
+  // Determine if exports is a conditions object or a subpath map
   const keys = Object.keys(exports);
   const isSubpathMap = keys.length > 0 && keys.some((k) => k.startsWith('.'));
 
   if (!isSubpathMap) {
-    // Conditions object at top level → applies to "." subpath only
-    if (subpath === '.') {
-      const target = resolveCondition(exports);
-      if (target) {
-        const resolved = path.resolve(packageDir, target);
-        return fs.existsSync(resolved) ? resolved : null;
-      }
-    }
-    return null;
+    return subpath === '.' ? tryResolveTarget(resolveCondition(exports), packageDir) : null;
   }
 
-  // Subpath map: try exact match first, then pattern match
-  if (subpath in exports) {
-    const target = resolveCondition(exports[subpath]);
-    if (target) {
-      const resolved = path.resolve(packageDir, target);
-      return fs.existsSync(resolved) ? resolved : null;
-    }
-  }
-
-  // Pattern matching (keys with *)
-  for (const [pattern, value] of Object.entries(exports)) {
-    if (!pattern.includes('*')) continue;
-    const matched = matchSubpathPattern(pattern, subpath);
-    if (matched == null) continue;
-    const rawTarget = resolveCondition(value);
-    if (!rawTarget) continue;
-    const target = rawTarget.replace(/\*/g, matched);
-    const resolved = path.resolve(packageDir, target);
-    if (fs.existsSync(resolved)) return resolved;
-  }
-
-  return null;
+  return resolveSubpathMap(exports as Record<string, unknown>, subpath, packageDir);
 }
 
 /** Clear the exports cache (for testing). */

package/src/domain/graph/watcher.ts

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { closeDb, getNodeId as getNodeIdQuery, initSchema, openDb } from '../../db/index.js';
-import { info } from '../../infrastructure/logger.js';
+import { debug, info } from '../../infrastructure/logger.js';
 import { EXTENSIONS, IGNORE_DIRS, normalizePath } from '../../shared/constants.js';
 import { DbError } from '../../shared/errors.js';
 import { createParseTreeCache, getActiveEngine } from '../parser.js';
@@ -32,12 +32,10 @@ export async function watchProject(rootDir: string, opts: { engine?: string } =
     ast: false,
   };
   const { name: engineName, version: engineVersion } = getActiveEngine(engineOpts);
-  console.log(
-    `Watch mode using ${engineName} engine${engineVersion ? ` (v${engineVersion})` : ''}`,
-  );
+  info(`Watch mode using ${engineName} engine${engineVersion ? ` (v${engineVersion})` : ''}`);
 
   const cache = createParseTreeCache();
-  console.log(
+  info(
     cache
       ? 'Incremental parsing enabled (native tree cache)'
       : 'Incremental parsing unavailable (full re-parse)',
@@ -124,8 +122,8 @@ export async function watchProject(rootDir: string, opts: { engine?: string } =
       }));
       try {
         appendJournalEntries(rootDir, entries);
-      } catch {
-        /* journal write failure is non-fatal */
+      } catch (e: unknown) {
+        debug(`Journal write failed (non-fatal): ${(e as Error).message}`);
       }
 
       const changeEvents = updates.map((r) =>
@@ -137,8 +135,8 @@ export async function watchProject(rootDir: string, opts: { engine?: string } =
       );
       try {
         appendChangeEvents(rootDir, changeEvents);
-      } catch {
-        /* change event write failure is non-fatal */
+      } catch (e: unknown) {
+        debug(`Change event write failed (non-fatal): ${(e as Error).message}`);
       }
     }
 
@@ -153,8 +151,8 @@ export async function watchProject(rootDir: string, opts: { engine?: string } =
     }
   }
 
-  console.log(`Watching ${rootDir} for changes...`);
-  console.log('Press Ctrl+C to stop.\n');
+  info(`Watching ${rootDir} for changes...`);
+  info('Press Ctrl+C to stop.');
 
   const watcher = fs.watch(rootDir, { recursive: true }, (_eventType, filename) => {
     if (!filename) return;
@@ -169,7 +167,7 @@ export async function watchProject(rootDir: string, opts: { engine?: string } =
   });
 
   process.on('SIGINT', () => {
-    console.log('\nStopping watcher...');
+    info('Stopping watcher...');
     watcher.close();
     // Flush any pending file paths to journal before exit
     if (pending.size > 0) {
@@ -178,8 +176,8 @@ export async function watchProject(rootDir: string, opts: { engine?: string } =
       }));
       try {
         appendJournalEntries(rootDir, entries);
-      } catch {
-        /* best-effort */
+      } catch (e: unknown) {
+        debug(`Journal flush on exit failed (non-fatal): ${(e as Error).message}`);
       }
     }
     if (cache) cache.clear();