@optave/codegraph 3.4.1 → 3.5.0

package/src/db/index.ts

@@ -1,9 +1,11 @@
 // Barrel re-export — keeps all existing `import { ... } from '…/db/index.js'` working.
 
-export type { LockedDatabase } from './connection.js';
+export type { LockedDatabase, LockedDatabasePair } from './connection.js';
 export {
   closeDb,
   closeDbDeferred,
+  closeDbPair,
+  closeDbPairDeferred,
   findDbPath,
   findRepoRoot,
   flushDeferredClose,

package/src/db/migrations.ts

@@ -8,6 +8,8 @@ interface Migration {
   up: string;
 }
 
+// IMPORTANT: Migration DDL is mirrored in crates/codegraph-core/src/native_db.rs.
+// Any changes here MUST be reflected there (and vice-versa).
 export const MIGRATIONS: Migration[] = [
   {
     version: 1,

package/src/db/query-builder.ts

@@ -1,6 +1,6 @@
 import { DbError } from '../shared/errors.js';
 import { DEAD_ROLE_PREFIX, EVERY_EDGE_KIND } from '../shared/kinds.js';
-import type { BetterSqlite3Database } from '../types.js';
+import type { BetterSqlite3Database, NativeDatabase } from '../types.js';
 
 // ─── Validation Helpers ─────────────────────────────────────────────
 
@@ -66,6 +66,17 @@ function validateEdgeKind(edgeKind: string): void {
   }
 }
 
+/** Runtime-validate that every param is string, number, or null before sending to nativeDb. */
+function validateNativeParams(params: (string | number)[]): Array<string | number | null> {
+  for (let i = 0; i < params.length; i++) {
+    const p = params[i];
+    if (p !== null && typeof p !== 'string' && typeof p !== 'number') {
+      throw new DbError(`NodeQuery param[${i}] has unsupported type: ${typeof p}`);
+    }
+  }
+  return params as Array<string | number | null>;
+}
+
 // ─── LIKE Escaping ──────────────────────────────────────────────────
 
 /** Escape LIKE wildcards in a literal string segment. */
@@ -314,15 +325,29 @@ export class NodeQuery {
     return { sql, params };
   }
 
-  /** Execute and return all rows. */
-  all<TRow = Record<string, unknown>>(db: BetterSqlite3Database): TRow[] {
+  /** Execute and return all rows. When `nativeDb` is provided, dispatches through rusqlite. */
+  all<TRow = Record<string, unknown>>(
+    db: BetterSqlite3Database,
+    nativeDb?: NativeDatabase,
+  ): TRow[] {
     const { sql, params } = this.build();
+    if (nativeDb) {
+      return nativeDb.queryAll(sql, validateNativeParams(params)) as TRow[];
+    }
     return db.prepare<TRow>(sql).all(...params) as TRow[];
   }
 
-  /** Execute and return first row. */
-  get<TRow = Record<string, unknown>>(db: BetterSqlite3Database): TRow | undefined {
+  /** Execute and return first row. When `nativeDb` is provided, dispatches through rusqlite. */
+  get<TRow = Record<string, unknown>>(
+    db: BetterSqlite3Database,
+    nativeDb?: NativeDatabase,
+  ): TRow | undefined {
     const { sql, params } = this.build();
+    if (nativeDb) {
+      return (nativeDb.queryGet(sql, validateNativeParams(params)) ?? undefined) as
+        | TRow
+        | undefined;
+    }
     return db.prepare<TRow>(sql).get(...params) as TRow | undefined;
   }
 

package/src/db/repository/index.ts

@@ -28,6 +28,7 @@ export {
 export { getEmbeddingCount, getEmbeddingMeta, hasEmbeddings } from './embeddings.js';
 export { getCallableNodes, getCallEdges, getFileNodesAll, getImportEdges } from './graph-read.js';
 export { InMemoryRepository } from './in-memory-repository.js';
+export { NativeRepository } from './native-repository.js';
 export {
   bulkNodeIdsByFile,
   countEdges,

package/src/db/repository/native-repository.ts

@@ -0,0 +1,361 @@
+/**
+ * NativeRepository — delegates all Repository read methods to NativeDatabase (rusqlite via napi-rs).
+ *
+ * Phase 6.14: every query runs via rusqlite when the native engine is available.
+ * Falls back to SqliteRepository (better-sqlite3) when native is unavailable.
+ *
+ * napi-rs converts Rust snake_case fields to JS camelCase. This class maps them
+ * back to the snake_case field names that the Repository interface expects.
+ */
+
+import { ConfigError } from '../../shared/errors.js';
+import type {
+  AdjacentEdgeRow,
+  CallableNodeRow,
+  CallEdgeRow,
+  ChildNodeRow,
+  ComplexityMetrics,
+  FileNodeRow,
+  ImportEdgeRow,
+  ImportGraphEdgeRow,
+  IntraFileCallEdge,
+  ListFunctionOpts,
+  NativeAdjacentEdgeRow,
+  NativeCallableNodeRow,
+  NativeCallEdgeRow,
+  NativeChildNodeRow,
+  NativeComplexityMetrics,
+  NativeDatabase,
+  NativeFileNodeRow,
+  NativeImportEdgeRow,
+  NativeImportGraphEdgeRow,
+  NativeIntraFileCallEdge,
+  NativeNodeIdRow,
+  NativeNodeRow,
+  NativeNodeRowWithFanIn,
+  NativeRelatedNodeRow,
+  NativeTriageNodeRow,
+  NodeIdRow,
+  NodeRow,
+  NodeRowWithFanIn,
+  QueryOpts,
+  RelatedNodeRow,
+  TriageNodeRow,
+  TriageQueryOpts,
+} from '../../types.js';
+import { Repository } from './base.js';
+
+// ── Row converters (napi camelCase → Repository snake_case) ─────────────
+
+function toNodeRow(r: NativeNodeRow): NodeRow {
+  return {
+    id: r.id,
+    name: r.name,
+    kind: r.kind as NodeRow['kind'],
+    file: r.file,
+    line: r.line ?? 0,
+    end_line: r.endLine ?? null,
+    parent_id: r.parentId ?? null,
+    exported: (r.exported ?? null) as 0 | 1 | null,
+    qualified_name: r.qualifiedName ?? null,
+    scope: r.scope ?? null,
+    visibility: (r.visibility ?? null) as NodeRow['visibility'],
+    role: (r.role ?? null) as NodeRow['role'],
+  };
+}
+
+function toNodeRowWithFanIn(r: NativeNodeRowWithFanIn): NodeRowWithFanIn {
+  return { ...toNodeRow(r), fan_in: r.fanIn };
+}
+
+function toTriageNodeRow(r: NativeTriageNodeRow): TriageNodeRow {
+  return {
+    ...toNodeRow(r),
+    fan_in: r.fanIn,
+    cognitive: r.cognitive,
+    mi: r.mi,
+    cyclomatic: r.cyclomatic,
+    max_nesting: r.maxNesting,
+    churn: r.churn,
+  };
+}
+
+function toNodeIdRow(r: NativeNodeIdRow): NodeIdRow {
+  return { id: r.id, name: r.name, kind: r.kind, line: r.line ?? 0 };
+}
+
+function toChildNodeRow(r: NativeChildNodeRow): ChildNodeRow {
+  return {
+    name: r.name,
+    kind: r.kind as ChildNodeRow['kind'],
+    line: r.line ?? 0,
+    end_line: r.endLine ?? null,
+    qualified_name: r.qualifiedName ?? null,
+    scope: r.scope ?? null,
+    visibility: (r.visibility ?? null) as ChildNodeRow['visibility'],
+  };
+}
+
+function toRelatedNodeRow(r: NativeRelatedNodeRow): RelatedNodeRow {
+  return {
+    id: r.id,
+    name: r.name,
+    kind: r.kind,
+    file: r.file,
+    line: r.line ?? 0,
+    end_line: r.endLine,
+  };
+}
+
+function toAdjacentEdgeRow(r: NativeAdjacentEdgeRow): AdjacentEdgeRow {
+  return {
+    name: r.name,
+    kind: r.kind,
+    file: r.file,
+    line: r.line ?? 0,
+    edge_kind: r.edgeKind as AdjacentEdgeRow['edge_kind'],
+  };
+}
+
+function toImportEdgeRow(r: NativeImportEdgeRow): ImportEdgeRow {
+  return { file: r.file, edge_kind: r.edgeKind as ImportEdgeRow['edge_kind'] };
+}
+
+function toIntraFileCallEdge(r: NativeIntraFileCallEdge): IntraFileCallEdge {
+  return { caller_name: r.callerName, callee_name: r.calleeName };
+}
+
+function toCallableNodeRow(r: NativeCallableNodeRow): CallableNodeRow {
+  return { id: r.id, name: r.name, kind: r.kind, file: r.file };
+}
+
+function toCallEdgeRow(r: NativeCallEdgeRow): CallEdgeRow {
+  return {
+    source_id: r.sourceId,
+    target_id: r.targetId,
+    confidence: r.confidence,
+  };
+}
+
+function toFileNodeRow(r: NativeFileNodeRow): FileNodeRow {
+  return { id: r.id, name: r.name, file: r.file };
+}
+
+function toImportGraphEdgeRow(r: NativeImportGraphEdgeRow): ImportGraphEdgeRow {
+  return { source_id: r.sourceId, target_id: r.targetId };
+}
+
+function toComplexityMetrics(r: NativeComplexityMetrics): ComplexityMetrics {
+  return {
+    cognitive: r.cognitive,
+    cyclomatic: r.cyclomatic,
+    max_nesting: r.maxNesting,
+    maintainability_index: r.maintainabilityIndex ?? null,
+    halstead_volume: r.halsteadVolume ?? null,
+  };
+}
+
+// ── NativeRepository ────────────────────────────────────────────────────
+
+export class NativeRepository extends Repository {
+  #ndb: NativeDatabase;
+
+  constructor(ndb: NativeDatabase) {
+    super();
+    this.#ndb = ndb;
+  }
+
+  // ── Node lookups ──────────────────────────────────────────────────
+
+  findNodeById(id: number): NodeRow | undefined {
+    const r = this.#ndb.findNodeById(id);
+    return r ? toNodeRow(r) : undefined;
+  }
+
+  findNodesByFile(file: string): NodeRow[] {
+    return this.#ndb.findNodesByFile(file).map(toNodeRow);
+  }
+
+  findFileNodes(fileLike: string): NodeRow[] {
+    return this.#ndb.findFileNodes(fileLike).map(toNodeRow);
+  }
+
+  findNodesWithFanIn(namePattern: string, opts: QueryOpts = {}): NodeRowWithFanIn[] {
+    return this.#ndb
+      .findNodesWithFanIn(namePattern, opts.kinds ?? null, opts.file ?? null)
+      .map(toNodeRowWithFanIn);
+  }
+
+  countNodes(): number {
+    return this.#ndb.countNodes();
+  }
+
+  countEdges(): number {
+    return this.#ndb.countEdges();
+  }
+
+  countFiles(): number {
+    return this.#ndb.countFiles();
+  }
+
+  getNodeId(name: string, kind: string, file: string, line: number): number | undefined {
+    return this.#ndb.getNodeId(name, kind, file, line) ?? undefined;
+  }
+
+  getFunctionNodeId(name: string, file: string, line: number): number | undefined {
+    return this.#ndb.getFunctionNodeId(name, file, line) ?? undefined;
+  }
+
+  bulkNodeIdsByFile(file: string): NodeIdRow[] {
+    return this.#ndb.bulkNodeIdsByFile(file).map(toNodeIdRow);
+  }
+
+  findNodeChildren(parentId: number): ChildNodeRow[] {
+    return this.#ndb.findNodeChildren(parentId).map(toChildNodeRow);
+  }
+
+  findNodesByScope(scopeName: string, opts: QueryOpts = {}): NodeRow[] {
+    return this.#ndb
+      .findNodesByScope(scopeName, opts.kind ?? null, opts.file ?? null)
+      .map(toNodeRow);
+  }
+
+  findNodeByQualifiedName(qualifiedName: string, opts: { file?: string } = {}): NodeRow[] {
+    return this.#ndb.findNodeByQualifiedName(qualifiedName, opts.file ?? null).map(toNodeRow);
+  }
+
+  listFunctionNodes(opts: ListFunctionOpts = {}): NodeRow[] {
+    return this.#ndb
+      .listFunctionNodes(opts.file ?? null, opts.pattern ?? null, opts.noTests ?? null)
+      .map(toNodeRow);
+  }
+
+  iterateFunctionNodes(opts: ListFunctionOpts = {}): IterableIterator<NodeRow> {
+    const rows = this.#ndb
+      .iterateFunctionNodes(opts.file ?? null, opts.pattern ?? null, opts.noTests ?? null)
+      .map(toNodeRow);
+    return rows[Symbol.iterator]();
+  }
+
+  findNodesForTriage(opts: TriageQueryOpts = {}): TriageNodeRow[] {
+    try {
+      return this.#ndb
+        .findNodesForTriage(
+          opts.kind ?? null,
+          opts.role ?? null,
+          opts.file ?? null,
+          opts.noTests ?? null,
+        )
+        .map(toTriageNodeRow);
+    } catch (e: unknown) {
+      const msg = (e as Error).message;
+      if (msg.startsWith('Invalid kind:') || msg.startsWith('Invalid role:')) {
+        throw new ConfigError(msg);
+      }
+      throw e;
+    }
+  }
+
+  // ── Edge queries ──────────────────────────────────────────────────
+
+  findCallees(nodeId: number): RelatedNodeRow[] {
+    return this.#ndb.findCallees(nodeId).map(toRelatedNodeRow);
+  }
+
+  findCallers(nodeId: number): RelatedNodeRow[] {
+    return this.#ndb.findCallers(nodeId).map(toRelatedNodeRow);
+  }
+
+  findDistinctCallers(nodeId: number): RelatedNodeRow[] {
+    return this.#ndb.findDistinctCallers(nodeId).map(toRelatedNodeRow);
+  }
+
+  findAllOutgoingEdges(nodeId: number): AdjacentEdgeRow[] {
+    return this.#ndb.findAllOutgoingEdges(nodeId).map(toAdjacentEdgeRow);
+  }
+
+  findAllIncomingEdges(nodeId: number): AdjacentEdgeRow[] {
+    return this.#ndb.findAllIncomingEdges(nodeId).map(toAdjacentEdgeRow);
+  }
+
+  findCalleeNames(nodeId: number): string[] {
+    return this.#ndb.findCalleeNames(nodeId);
+  }
+
+  findCallerNames(nodeId: number): string[] {
+    return this.#ndb.findCallerNames(nodeId);
+  }
+
+  findImportTargets(nodeId: number): ImportEdgeRow[] {
+    return this.#ndb.findImportTargets(nodeId).map(toImportEdgeRow);
+  }
+
+  findImportSources(nodeId: number): ImportEdgeRow[] {
+    return this.#ndb.findImportSources(nodeId).map(toImportEdgeRow);
+  }
+
+  findImportDependents(nodeId: number): NodeRow[] {
+    return this.#ndb.findImportDependents(nodeId).map(toNodeRow);
+  }
+
+  findCrossFileCallTargets(file: string): Set<number> {
+    return new Set(this.#ndb.findCrossFileCallTargets(file));
+  }
+
+  countCrossFileCallers(nodeId: number, file: string): number {
+    return this.#ndb.countCrossFileCallers(nodeId, file);
+  }
+
+  getClassHierarchy(classNodeId: number): Set<number> {
+    return new Set(this.#ndb.getClassHierarchy(classNodeId));
+  }
+
+  findImplementors(nodeId: number): RelatedNodeRow[] {
+    return this.#ndb.findImplementors(nodeId).map(toRelatedNodeRow);
+  }
+
+  findInterfaces(nodeId: number): RelatedNodeRow[] {
+    return this.#ndb.findInterfaces(nodeId).map(toRelatedNodeRow);
+  }
+
+  findIntraFileCallEdges(file: string): IntraFileCallEdge[] {
+    return this.#ndb.findIntraFileCallEdges(file).map(toIntraFileCallEdge);
+  }
+
+  // ── Graph-read queries ────────────────────────────────────────────
+
+  getCallableNodes(): CallableNodeRow[] {
+    return this.#ndb.getCallableNodes().map(toCallableNodeRow);
+  }
+
+  getCallEdges(): CallEdgeRow[] {
+    return this.#ndb.getCallEdges().map(toCallEdgeRow);
+  }
+
+  getFileNodesAll(): FileNodeRow[] {
+    return this.#ndb.getFileNodesAll().map(toFileNodeRow);
+  }
+
+  getImportEdges(): ImportGraphEdgeRow[] {
+    return this.#ndb.getImportEdges().map(toImportGraphEdgeRow);
+  }
+
+  // ── Optional table checks ─────────────────────────────────────────
+
+  hasCfgTables(): boolean {
+    return this.#ndb.hasCfgTables();
+  }
+
+  hasEmbeddings(): boolean {
+    return this.#ndb.hasEmbeddings();
+  }
+
+  hasDataflowTable(): boolean {
+    return this.#ndb.hasDataflowTable();
+  }
+
+  getComplexityForNode(nodeId: number): ComplexityMetrics | undefined {
+    const r = this.#ndb.getComplexityForNode(nodeId);
+    return r ? toComplexityMetrics(r) : undefined;
+  }
+}

package/src/db/repository/nodes.ts

@@ -4,6 +4,7 @@ import type {
   BetterSqlite3Database,
   ChildNodeRow,
   ListFunctionOpts,
+  NativeDatabase,
   NodeIdRow,
   NodeRow,
   NodeRowWithFanIn,
@@ -24,6 +25,7 @@ export function findNodesWithFanIn(
   db: BetterSqlite3Database,
   namePattern: string,
   opts: QueryOpts = {},
+  nativeDb?: NativeDatabase,
 ): NodeRowWithFanIn[] {
   const q = new NodeQuery()
     .select('n.*, COALESCE(fi.cnt, 0) AS fan_in')
@@ -37,7 +39,7 @@ export function findNodesWithFanIn(
     q.fileFilter(opts.file);
   }
 
-  return q.all(db);
+  return q.all(db, nativeDb);
 }
 
 /**
@@ -46,6 +48,7 @@ export function findNodesWithFanIn(
 export function findNodesForTriage(
   db: BetterSqlite3Database,
   opts: TriageQueryOpts = {},
+  nativeDb?: NativeDatabase,
 ): TriageNodeRow[] {
   if (opts.kind && !(EVERY_SYMBOL_KIND as readonly string[]).includes(opts.kind)) {
     throw new ConfigError(
@@ -77,7 +80,7 @@ export function findNodesForTriage(
     .roleFilter(opts.role)
     .orderBy('n.file, n.line');
 
-  return q.all(db);
+  return q.all(db, nativeDb);
 }
 
 /**
@@ -99,8 +102,9 @@ function _functionNodeQuery(opts: ListFunctionOpts = {}): InstanceType<typeof No
 export function listFunctionNodes(
   db: BetterSqlite3Database,
   opts: ListFunctionOpts = {},
+  nativeDb?: NativeDatabase,
 ): NodeRow[] {
-  return _functionNodeQuery(opts).all(db);
+  return _functionNodeQuery(opts).all(db, nativeDb);
 }
 
 /**

package/src/domain/graph/builder/context.ts

@@ -12,6 +12,7 @@ import type {
   ExtractorOutput,
   FileToParse,
   MetadataUpdate,
+  NativeDatabase,
   NodeRow,
   ParseChange,
   PathAliases,
@@ -31,6 +32,7 @@ export class PipelineContext {
   incremental!: boolean;
   forceFullRebuild: boolean = false;
   schemaVersion!: number;
+  nativeDb?: NativeDatabase;
 
   // ── File collection (set by collectFiles stage) ────────────────────
   allFiles!: string[];

package/src/domain/graph/builder/pipeline.ts

@@ -6,9 +6,10 @@
  */
 import path from 'node:path';
 import { performance } from 'node:perf_hooks';
-import { closeDb, getBuildMeta, initSchema, MIGRATIONS, openDb } from '../../../db/index.js';
+import { closeDbPair, getBuildMeta, initSchema, MIGRATIONS, openDb } from '../../../db/index.js';
 import { detectWorkspaces, loadConfig } from '../../../infrastructure/config.js';
 import { info, warn } from '../../../infrastructure/logger.js';
+import { loadNative } from '../../../infrastructure/native.js';
 import { CODEGRAPH_VERSION } from '../../../shared/version.js';
 import type { BuildGraphOpts, BuildResult } from '../../../types.js';
 import { getActiveEngine } from '../../parser.js';
@@ -33,6 +34,7 @@ function initializeEngine(ctx: PipelineContext): void {
     engine: ctx.opts.engine || 'auto',
     dataflow: ctx.opts.dataflow !== false,
     ast: ctx.opts.ast !== false,
+    nativeDb: ctx.nativeDb,
   };
   const { name: engineName, version: engineVersion } = getActiveEngine(ctx.engineOpts);
   ctx.engineName = engineName as 'native' | 'wasm';
@@ -46,19 +48,23 @@ function checkEngineSchemaMismatch(ctx: PipelineContext): void {
   ctx.forceFullRebuild = false;
   if (!ctx.incremental) return;
 
-  const prevEngine = getBuildMeta(ctx.db, 'engine');
+  // Route metadata reads through NativeDatabase when available (Phase 6.13)
+  const meta = (key: string): string | null =>
+    ctx.nativeDb ? ctx.nativeDb.getBuildMeta(key) : getBuildMeta(ctx.db, key);
+
+  const prevEngine = meta('engine');
   if (prevEngine && prevEngine !== ctx.engineName) {
     info(`Engine changed (${prevEngine} → ${ctx.engineName}), promoting to full rebuild.`);
     ctx.forceFullRebuild = true;
   }
-  const prevSchema = getBuildMeta(ctx.db, 'schema_version');
+  const prevSchema = meta('schema_version');
   if (prevSchema && Number(prevSchema) !== ctx.schemaVersion) {
     info(
       `Schema version changed (${prevSchema} → ${ctx.schemaVersion}), promoting to full rebuild.`,
     );
     ctx.forceFullRebuild = true;
   }
-  const prevVersion = getBuildMeta(ctx.db, 'codegraph_version');
+  const prevVersion = meta('codegraph_version');
   if (prevVersion && prevVersion !== CODEGRAPH_VERSION) {
     info(
       `Codegraph version changed (${prevVersion} → ${CODEGRAPH_VERSION}), promoting to full rebuild.`,
@@ -91,7 +97,23 @@ function setupPipeline(ctx: PipelineContext): void {
   ctx.rootDir = path.resolve(ctx.rootDir);
   ctx.dbPath = path.join(ctx.rootDir, '.codegraph', 'graph.db');
   ctx.db = openDb(ctx.dbPath);
-  initSchema(ctx.db);
+
+  // Use NativeDatabase for schema init when native engine is available (Phase 6.13).
+  // better-sqlite3 (ctx.db) is still always opened — needed for queries and stages
+  // that haven't been migrated to rusqlite yet.
+  const native = loadNative();
+  if (native?.NativeDatabase) {
+    try {
+      ctx.nativeDb = native.NativeDatabase.openReadWrite(ctx.dbPath);
+      ctx.nativeDb.initSchema();
+    } catch (err) {
+      warn(`NativeDatabase init failed, falling back to JS: ${(err as Error).message}`);
+      ctx.nativeDb = undefined;
+      initSchema(ctx.db);
+    }
+  } else {
+    initSchema(ctx.db);
+  }
 
   ctx.config = loadConfig(ctx.rootDir);
   ctx.incremental =
@@ -168,7 +190,9 @@ export async function buildGraph(
     setupPipeline(ctx);
     await runPipelineStages(ctx);
   } catch (err) {
-    if (!ctx.earlyExit && ctx.db) closeDb(ctx.db);
+    if (!ctx.earlyExit && ctx.db) {
+      closeDbPair({ db: ctx.db, nativeDb: ctx.nativeDb });
+    }
     throw err;
   }