@optave/codegraph 3.4.1 → 3.5.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,112 @@ interface PrecomputedFileData {
   _reverseDepOnly?: boolean;
 }
 
-// ── Phase 1: Insert file nodes, definitions, exports ────────────────────
+// ── Native fast-path ─────────────────────────────────────────────────
+
+function tryNativeInsert(ctx: PipelineContext): boolean {
+  // 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 | null;
+      visibility?: string | null;
+      children: Array<{
+        name: string;
+        kind: string;
+        line: number;
+        endLine?: number | null;
+        visibility?: string | null;
+      }>;
+    }>;
+    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 ?? null,
+        visibility: def.visibility ?? null,
+        children: (def.children ?? []).map((c) => ({
+          name: c.name,
+          kind: c.kind,
+          line: c.line,
+          endLine: c.endLine ?? null,
+          visibility: c.visibility ?? null,
+        })),
+      })),
+      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 +199,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 +274,7 @@ function insertChildrenAndEdges(
   batchInsertEdges(db, edgeRows);
 }
 
-// ── Phase 4: Update file hashes ─────────────────────────────────────────
+// ── JS fallback: Phase 4 ────────────────────────────────────────────
 
 function updateFileHashes(
   _db: BetterSqlite3Database,
@@ -218,11 +327,27 @@ function updateFileHashes(
   }
 }
 
-// ── Main entry point ────────────────────────────────────────────────────
+// ── Main entry point ────────────────────────────────────────────────
 
 export async function insertNodes(ctx: PipelineContext): Promise<void> {
   const { db, 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' && tryNativeInsert(ctx)) {
+    ctx.timing.insertMs = performance.now() - t0;
+
+    // Removed-file hash cleanup is handled inside the native call
+    return;
+  }
+
+  // JS fallback
   const precomputedData = new Map<string, PrecomputedFileData>();
   for (const item of filesToParse) {
     if (item.relPath) precomputedData.set(item.relPath, item as PrecomputedFileData);
@@ -237,18 +362,12 @@ export async function insertNodes(ctx: PipelineContext): Promise<void> {
     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 t0 = performance.now();
   insertAll();
   ctx.timing.insertMs = performance.now() - t0;
 

package/src/domain/parser.ts

@@ -85,6 +85,7 @@ const COMMON_QUERY_PATTERNS: string[] = [
   '(variable_declarator name: (identifier) @varfn_name value: (arrow_function) @varfn_value)',
   '(variable_declarator name: (identifier) @varfn_name value: (function_expression) @varfn_value)',
   '(method_definition name: (property_identifier) @meth_name) @meth_node',
+  '(method_definition name: (private_property_identifier) @meth_name) @meth_node',
   '(import_statement source: (string) @imp_source) @imp_node',
   '(export_statement) @exp_node',
   '(call_expression function: (identifier) @callfn_name) @callfn_node',

package/src/extractors/javascript.ts

@@ -260,51 +260,69 @@ function extractSymbolsQuery(tree: TreeSitterTree, query: TreeSitterQuery): Extr
   return { definitions, calls, imports, classes, exports: exps, typeMap };
 }
 
+/** Node types that define a function scope — constants inside these are skipped. */
+const FUNCTION_SCOPE_TYPES = new Set([
+  'function_declaration',
+  'arrow_function',
+  'function_expression',
+  'method_definition',
+  'generator_function_declaration',
+  'generator_function',
+]);
+
 /**
- * Walk program-level children to extract `const x = <literal>` as constants.
- * The query-based fast path has no pattern for lexical_declaration/variable_declaration,
- * so constants are missed. This targeted walk fills that gap without a full tree traversal.
+ * Recursively walk the AST to extract `const x = <literal>` as constants.
+ * Skips nodes inside function scopes so only file-level / block-level constants
+ * are captured — matching the native engine's behaviour.
  */
-function extractConstantsWalk(rootNode: TreeSitterNode, definitions: Definition[]): void {
-  for (let i = 0; i < rootNode.childCount; i++) {
-    const node = rootNode.child(i);
-    if (!node) continue;
+function extractConstantsWalk(node: TreeSitterNode, definitions: Definition[]): void {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+
+    // Don't descend into function scopes
+    if (FUNCTION_SCOPE_TYPES.has(child.type)) continue;
 
-    let declNode = node;
+    let declNode = child;
     // Handle `export const …` — unwrap the export_statement to its declaration child
-    if (node.type === 'export_statement') {
-      const inner = node.childForFieldName('declaration');
-      if (!inner) continue;
-      declNode = inner;
+    if (child.type === 'export_statement') {
+      const inner = child.childForFieldName('declaration');
+      if (inner) declNode = inner;
     }
 
     const t = declNode.type;
-    if (t !== 'lexical_declaration' && t !== 'variable_declaration') continue;
-    if (!declNode.text.startsWith('const ')) continue;
-
-    for (let j = 0; j < declNode.childCount; j++) {
-      const declarator = declNode.child(j);
-      if (!declarator || declarator.type !== 'variable_declarator') continue;
-      const nameN = declarator.childForFieldName('name');
-      const valueN = declarator.childForFieldName('value');
-      if (!nameN || nameN.type !== 'identifier' || !valueN) continue;
-      // Skip functions — already captured by query patterns
-      const valType = valueN.type;
-      if (
-        valType === 'arrow_function' ||
-        valType === 'function_expression' ||
-        valType === 'function'
-      )
-        continue;
-      if (isConstantValue(valueN)) {
-        definitions.push({
-          name: nameN.text,
-          kind: 'constant',
-          line: declNode.startPosition.row + 1,
-          endLine: nodeEndLine(declNode),
-        });
+    if (t === 'lexical_declaration' || t === 'variable_declaration') {
+      if (declNode.text.startsWith('const ')) {
+        for (let j = 0; j < declNode.childCount; j++) {
+          const declarator = declNode.child(j);
+          if (!declarator || declarator.type !== 'variable_declarator') continue;
+          const nameN = declarator.childForFieldName('name');
+          const valueN = declarator.childForFieldName('value');
+          if (!nameN || nameN.type !== 'identifier' || !valueN) continue;
+          // Skip functions — already captured by query patterns
+          const valType = valueN.type;
+          if (
+            valType === 'arrow_function' ||
+            valType === 'function_expression' ||
+            valType === 'function'
+          )
+            continue;
+          if (isConstantValue(valueN)) {
+            definitions.push({
+              name: nameN.text,
+              kind: 'constant',
+              line: declNode.startPosition.row + 1,
+              endLine: nodeEndLine(declNode),
+            });
+          }
+        }
       }
     }
+
+    // Recurse into non-function, non-export-statement children (blocks, if-statements, etc.)
+    if (child.type !== 'export_statement') {
+      extractConstantsWalk(child, definitions);
+    }
   }
 }
 

package/src/extractors/rust.ts

@@ -227,7 +227,8 @@ function extractRustParameters(paramListNode: TreeSitterNode | null): SubDeclara
     const param = paramListNode.child(i);
     if (!param) continue;
     if (param.type === 'self_parameter') {
-      params.push({ name: 'self', kind: 'parameter', line: param.startPosition.row + 1 });
+      // Skip self parameters — matches native engine behaviour
+      continue;
     } else if (param.type === 'parameter') {
       const pattern = param.childForFieldName('pattern');
       if (pattern) {

package/src/features/ast.ts

@@ -65,8 +65,73 @@ export async function buildAstNodes(
   db: BetterSqlite3Database,
   fileSymbols: Map<string, FileSymbols>,
   _rootDir: string,
-  _engineOpts?: unknown,
+  engineOpts?: {
+    nativeDb?: {
+      bulkInsertAstNodes(
+        batches: Array<{
+          file: string;
+          nodes: Array<{
+            line: number;
+            kind: string;
+            name: string;
+            text?: string | null;
+            receiver?: string | null;
+          }>;
+        }>,
+      ): number;
+    };
+  },
 ): Promise<void> {
+  // ── Native bulk-insert fast path ──────────────────────────────────────
+  // Uses NativeDatabase persistent connection (Phase 6.15+).
+  // Standalone napi functions were removed in 6.17.
+  const nativeDb = engineOpts?.nativeDb;
+  if (nativeDb?.bulkInsertAstNodes) {
+    let needsJsFallback = false;
+    const batches: Array<{
+      file: string;
+      nodes: Array<{
+        line: number;
+        kind: string;
+        name: string;
+        text?: string | null;
+        receiver?: string | null;
+      }>;
+    }> = [];
+
+    for (const [relPath, symbols] of fileSymbols) {
+      if (Array.isArray(symbols.astNodes)) {
+        batches.push({
+          file: relPath,
+          nodes: symbols.astNodes.map((n) => ({
+            line: n.line,
+            kind: n.kind,
+            name: n.name,
+            text: n.text,
+            receiver: n.receiver,
+          })),
+        });
+      } else if (symbols.calls || symbols._tree) {
+        needsJsFallback = true;
+        break;
+      }
+    }
+
+    if (!needsJsFallback) {
+      const expectedNodes = batches.reduce((s, b) => s + b.nodes.length, 0);
+      const inserted = nativeDb.bulkInsertAstNodes(batches);
+      if (inserted === expectedNodes) {
+        debug(`AST extraction (native bulk): ${inserted} nodes stored`);
+        return;
+      }
+      debug(
+        `AST extraction (native bulk): expected ${expectedNodes}, got ${inserted} — falling back to JS`,
+      );
+      // fall through to JS path
+    }
+  }
+
+  // ── JS fallback path ──────────────────────────────────────────────────
   let insertStmt: ReturnType<BetterSqlite3Database['prepare']>;
   try {
     insertStmt = db.prepare(

package/src/features/branch-compare.ts

@@ -2,7 +2,7 @@ import { execFileSync } from 'node:child_process';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import Database from 'better-sqlite3';
+import { getDatabase } from '../db/better-sqlite3.js';
 import { buildGraph } from '../domain/graph/builder.js';
 import { kindIcon } from '../domain/queries.js';
 import { isTestFile } from '../infrastructure/test-filter.js';
@@ -105,6 +105,7 @@ function loadSymbolsFromDb(
   changedFiles: string[],
   noTests: boolean,
 ): Map<string, SymbolInfo> {
+  const Database = getDatabase();
   const db = new Database(dbPath, { readonly: true });
   try {
     const symbols = new Map<string, SymbolInfo>();
@@ -174,6 +175,7 @@ function loadCallersFromDb(
 ): CallerInfo[] {
   if (nodeIds.length === 0) return [];
 
+  const Database = getDatabase();
   const db = new Database(dbPath, { readonly: true });
   try {
     const allCallers = new Set<string>();

package/src/features/snapshot.ts

@@ -1,6 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import Database from 'better-sqlite3';
+import { getDatabase } from '../db/better-sqlite3.js';
 import { findDbPath } from '../db/index.js';
 import { debug } from '../infrastructure/logger.js';
 import { ConfigError, DbError } from '../shared/errors.js';
@@ -47,6 +47,7 @@ export function snapshotSave(
 
   fs.mkdirSync(dir, { recursive: true });
 
+  const Database = getDatabase();
   const db = new Database(dbPath, { readonly: true });
   try {
     db.exec(`VACUUM INTO '${dest.replace(/'/g, "''")}'`);

package/src/mcp/server.ts

@@ -10,6 +10,7 @@ import { createRequire } from 'node:module';
 const require = createRequire(import.meta.url);
 const { version: PKG_VERSION } = require('../../package.json') as { version: string };
 
+import { getDatabase } from '../db/better-sqlite3.js';
 import { findDbPath } from '../db/index.js';
 import { loadConfig } from '../infrastructure/config.js';
 import { CodegraphError, ConfigError } from '../shared/errors.js';
@@ -64,22 +65,13 @@ async function loadMCPSdk(): Promise<{
 
 function createLazyLoaders(): {
   getQueries(): Promise<unknown>;
-  getDatabase(): unknown;
 } {
   let _queries: unknown;
-  let _Database: unknown;
   return {
     async getQueries(): Promise<unknown> {
       if (!_queries) _queries = await import('../domain/queries.js');
       return _queries;
     },
-    getDatabase(): unknown {
-      if (!_Database) {
-        const require = createRequire(import.meta.url);
-        _Database = require('better-sqlite3');
-      }
-      return _Database;
-    },
   };
 }
 
@@ -135,7 +127,7 @@ export async function startMCPServer(
   // `initialize` request while heavy modules (queries, better-sqlite3)
   // are still loading.  These are lazy-loaded on the first tool call
   // and cached for subsequent calls.
-  const { getQueries, getDatabase } = createLazyLoaders();
+  const { getQueries } = createLazyLoaders();
 
   const server = new (Server as any)(
     { name: 'codegraph', version: PKG_VERSION },