@optave/codegraph 3.4.1 → 3.6.0

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/analysis/context.ts

@@ -15,10 +15,8 @@ import {
   getComplexityForNode,
   getLineCountForNode,
   getMaxEndLineForFile,
-  openReadonlyOrFail,
 } from '../../db/index.js';
 import { cachedStmt } from '../../db/repository/cached-stmt.js';
-import { loadConfig } from '../../infrastructure/config.js';
 import { debug } from '../../infrastructure/logger.js';
 import { isTestFile } from '../../infrastructure/test-filter.js';
 import {
@@ -40,6 +38,7 @@ import type {
   RelatedNodeRow,
   StmtCache,
 } from '../../types.js';
+import { resolveAnalysisOpts, withReadonlyDb } from './query-helpers.js';
 import { findMatchingNodes } from './symbol-lookup.js';
 
 interface DisplayOpts {
@@ -52,6 +51,60 @@ interface DisplayOpts {
   [key: string]: unknown;
 }
 
+/** Format a callee row into the output shape with summary and source. */
+function formatCalleeRow(
+  c: RelatedNodeRow,
+  repoRoot: string,
+  getFileLines: (file: string) => string[] | null,
+  displayOpts: DisplayOpts,
+  includeSource: boolean,
+) {
+  const cLines = getFileLines(c.file);
+  return {
+    name: c.name,
+    kind: c.kind,
+    file: c.file,
+    line: c.line,
+    endLine: c.end_line || null,
+    summary: cLines ? extractSummary(cLines, c.line, displayOpts) : null,
+    source: includeSource
+      ? readSourceRange(repoRoot, c.file, c.line, c.end_line ?? undefined, displayOpts)
+      : null,
+  };
+}
+
+/** BFS to collect deeper callees beyond the first level. */
+function collectDeeperCallees(
+  db: BetterSqlite3Database,
+  startIds: number[],
+  rootId: number,
+  repoRoot: string,
+  getFileLines: (file: string) => string[] | null,
+  opts: { noTests: boolean; maxDepth: number; displayOpts: DisplayOpts },
+) {
+  const { noTests, maxDepth, displayOpts } = opts;
+  const visited = new Set(startIds);
+  visited.add(rootId);
+  let frontier = [...startIds];
+  const result: ReturnType<typeof formatCalleeRow>[] = [];
+
+  for (let d = 2; d <= maxDepth; d++) {
+    const nextFrontier: number[] = [];
+    for (const fid of frontier) {
+      const deeper = findCallees(db, fid) as RelatedNodeRow[];
+      for (const c of deeper) {
+        if (visited.has(c.id) || (noTests && isTestFile(c.file))) continue;
+        visited.add(c.id);
+        nextFrontier.push(c.id);
+        result.push(formatCalleeRow(c, repoRoot, getFileLines, displayOpts, true));
+      }
+    }
+    frontier = nextFrontier;
+    if (frontier.length === 0) break;
+  }
+  return result;
+}
+
 function buildCallees(
   db: BetterSqlite3Database,
   node: NodeRow,
@@ -63,65 +116,20 @@ function buildCallees(
   const calleeRows = findCallees(db, node.id) as RelatedNodeRow[];
   const filteredCallees = noTests ? calleeRows.filter((c) => !isTestFile(c.file)) : calleeRows;
 
-  const callees = filteredCallees.map((c) => {
-    const cLines = getFileLines(c.file);
-    const summary = cLines ? extractSummary(cLines, c.line, displayOpts) : null;
-    let calleeSource: string | null = null;
-    if (depth >= 1) {
-      calleeSource = readSourceRange(
-        repoRoot,
-        c.file,
-        c.line,
-        c.end_line ?? undefined,
-        displayOpts,
-      );
-    }
-    return {
-      name: c.name,
-      kind: c.kind,
-      file: c.file,
-      line: c.line,
-      endLine: c.end_line || null,
-      summary,
-      source: calleeSource,
-    };
-  });
+  const callees = filteredCallees.map((c) =>
+    formatCalleeRow(c, repoRoot, getFileLines, displayOpts, depth >= 1),
+  );
 
   if (depth > 1) {
-    const visited = new Set(filteredCallees.map((c) => c.id));
-    visited.add(node.id);
-    let frontier = filteredCallees.map((c) => c.id);
-    const maxDepth = Math.min(depth, 5);
-    for (let d = 2; d <= maxDepth; d++) {
-      const nextFrontier: number[] = [];
-      for (const fid of frontier) {
-        const deeper = findCallees(db, fid) as RelatedNodeRow[];
-        for (const c of deeper) {
-          if (!visited.has(c.id) && (!noTests || !isTestFile(c.file))) {
-            visited.add(c.id);
-            nextFrontier.push(c.id);
-            const cLines = getFileLines(c.file);
-            callees.push({
-              name: c.name,
-              kind: c.kind,
-              file: c.file,
-              line: c.line,
-              endLine: c.end_line || null,
-              summary: cLines ? extractSummary(cLines, c.line, displayOpts) : null,
-              source: readSourceRange(
-                repoRoot,
-                c.file,
-                c.line,
-                c.end_line ?? undefined,
-                displayOpts,
-              ),
-            });
-          }
-        }
-      }
-      frontier = nextFrontier;
-      if (frontier.length === 0) break;
-    }
+    const deeper = collectDeeperCallees(
+      db,
+      filteredCallees.map((c) => c.id),
+      node.id,
+      repoRoot,
+      getFileLines,
+      { noTests, maxDepth: Math.min(depth, 5), displayOpts },
+    );
+    callees.push(...deeper);
   }
 
   return callees;
@@ -433,15 +441,12 @@ export function contextData(
     config?: any;
   } = {},
 ) {
-  const db = openReadonlyOrFail(customDbPath);
-  try {
+  return withReadonlyDb(customDbPath, (db) => {
     const depth = opts.depth || 0;
     const noSource = opts.noSource || false;
-    const noTests = opts.noTests || false;
     const includeTests = opts.includeTests || false;
 
-    const config = opts.config || loadConfig();
-    const displayOpts: DisplayOpts = config.display || {};
+    const { noTests, displayOpts } = resolveAnalysisOpts(opts);
 
     const dbPath = findDbPath(customDbPath);
     const repoRoot = path.resolve(path.dirname(dbPath), '..');
@@ -494,9 +499,7 @@ export function contextData(
 
     const base = { name, results };
     return paginateResult(base, 'results', { limit: opts.limit, offset: opts.offset });
-  } finally {
-    db.close();
-  }
+  });
 }
 
 export function explainData(
@@ -510,14 +513,11 @@ export function explainData(
     config?: any;
   } = {},
 ) {
-  const db = openReadonlyOrFail(customDbPath);
-  try {
-    const noTests = opts.noTests || false;
+  return withReadonlyDb(customDbPath, (db) => {
     const depth = opts.depth || 0;
     const kind = isFileLikeTarget(target) ? 'file' : 'function';
 
-    const config = opts.config || loadConfig();
-    const displayOpts: DisplayOpts = config.display || {};
+    const { noTests, displayOpts } = resolveAnalysisOpts(opts);
 
     const dbPath = findDbPath(customDbPath);
     const repoRoot = path.resolve(path.dirname(dbPath), '..');
@@ -536,7 +536,5 @@ export function explainData(
 
     const base = { target, kind, results };
     return paginateResult(base, 'results', { limit: opts.limit, offset: opts.offset });
-  } finally {
-    db.close();
-  }
+  });
 }