@optave/codegraph 3.4.0 → 3.5.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/brief.ts

@@ -113,7 +113,6 @@ function countTransitiveImporters(
 export function briefData(
   file: string,
   customDbPath: string,
-  // biome-ignore lint/suspicious/noExplicitAny: config shape is dynamic
   opts: { noTests?: boolean; config?: any } = {},
 ) {
   const db = openReadonlyOrFail(customDbPath);

package/src/domain/analysis/context.ts

@@ -379,7 +379,6 @@ function explainFunctionImpl(
   });
 }
 
-// biome-ignore lint/suspicious/noExplicitAny: explainFunctionImpl results have dynamic shape with _depth
 function explainCallees(
   parentResults: any[],
   currentDepth: number,
@@ -405,8 +404,8 @@ function explainCallees(
       );
       const exact = calleeResults.find((cr) => cr.file === callee.file && cr.line === callee.line);
       if (exact) {
-        (exact as Record<string, unknown>)['_depth'] =
-          (((r as Record<string, unknown>)['_depth'] as number) || 0) + 1;
+        (exact as Record<string, unknown>)._depth =
+          (((r as Record<string, unknown>)._depth as number) || 0) + 1;
         newCallees.push(exact);
       }
     }
@@ -431,7 +430,6 @@ export function contextData(
     kind?: string;
     limit?: number;
     offset?: number;
-    // biome-ignore lint/suspicious/noExplicitAny: config shape is dynamic
     config?: any;
   } = {},
 ) {
@@ -509,7 +507,6 @@ export function explainData(
     depth?: number;
     limit?: number;
     offset?: number;
-    // biome-ignore lint/suspicious/noExplicitAny: config shape is dynamic
     config?: any;
   } = {},
 ) {
@@ -533,7 +530,6 @@ export function explainData(
         : explainFunctionImpl(db, target, noTests, getFileLines, displayOpts);
 
     if (kind === 'function' && depth > 0 && results.length > 0) {
-      // biome-ignore lint/suspicious/noExplicitAny: results are function results when kind === 'function'
       const visited = new Set(results.map((r: any) => `${r.name}:${r.file}:${r.line ?? ''}`));
       explainCallees(results, depth, visited, db, noTests, getFileLines, displayOpts);
     }

package/src/domain/analysis/dependencies.ts

@@ -481,3 +481,168 @@ export function pathData(
     db.close();
   }
 }
+
+// ── File-level shortest path ────────────────────────────────────────────
+
+/**
+ * BFS at the file level: find shortest import/edge path between two files.
+ * Adjacency: file A → file B if any symbol in A has an edge to any symbol in B.
+ */
+export function filePathData(
+  from: string,
+  to: string,
+  customDbPath: string,
+  opts: {
+    noTests?: boolean;
+    maxDepth?: number;
+    edgeKinds?: string[];
+    reverse?: boolean;
+  } = {},
+) {
+  const db = openReadonlyOrFail(customDbPath);
+  try {
+    const noTests = opts.noTests || false;
+    const maxDepth = opts.maxDepth || 10;
+    const edgeKinds = opts.edgeKinds || ['imports', 'imports-type'];
+    const reverse = opts.reverse || false;
+
+    // Resolve from/to as file paths (LIKE match)
+    const fromFiles = findFileNodes(db, `%${from}%`) as NodeRow[];
+    if (fromFiles.length === 0) {
+      return {
+        from,
+        to,
+        found: false,
+        error: `No file matching "${from}"`,
+        path: [],
+        fromCandidates: [],
+        toCandidates: [],
+      };
+    }
+    const toFiles = findFileNodes(db, `%${to}%`) as NodeRow[];
+    if (toFiles.length === 0) {
+      return {
+        from,
+        to,
+        found: false,
+        error: `No file matching "${to}"`,
+        path: [],
+        fromCandidates: fromFiles.slice(0, 5).map((f) => f.file),
+        toCandidates: [],
+      };
+    }
+
+    const sourceFile = fromFiles[0]!.file;
+    const targetFile = toFiles[0]!.file;
+
+    const fromCandidates = fromFiles.slice(0, 5).map((f) => f.file);
+    const toCandidates = toFiles.slice(0, 5).map((f) => f.file);
+
+    if (sourceFile === targetFile) {
+      return {
+        from,
+        to,
+        fromCandidates,
+        toCandidates,
+        found: true,
+        hops: 0,
+        path: [sourceFile],
+        alternateCount: 0,
+        edgeKinds,
+        reverse,
+        maxDepth,
+      };
+    }
+
+    // Build neighbor query: find all distinct files adjacent to a given file via edges
+    const kindPlaceholders = edgeKinds.map(() => '?').join(', ');
+    const neighborQuery = reverse
+      ? `SELECT DISTINCT n_src.file AS neighbor_file
+         FROM nodes n_tgt
+         JOIN edges e ON e.target_id = n_tgt.id
+         JOIN nodes n_src ON e.source_id = n_src.id
+         WHERE n_tgt.file = ? AND e.kind IN (${kindPlaceholders}) AND n_src.file != n_tgt.file`
+      : `SELECT DISTINCT n_tgt.file AS neighbor_file
+         FROM nodes n_src
+         JOIN edges e ON e.source_id = n_src.id
+         JOIN nodes n_tgt ON e.target_id = n_tgt.id
+         WHERE n_src.file = ? AND e.kind IN (${kindPlaceholders}) AND n_tgt.file != n_src.file`;
+    const neighborStmt = db.prepare(neighborQuery);
+
+    // BFS
+    const visited = new Set([sourceFile]);
+    const parentMap = new Map<string, string>();
+    let queue = [sourceFile];
+    let found = false;
+    let alternateCount = 0;
+
+    for (let depth = 1; depth <= maxDepth; depth++) {
+      const nextQueue: string[] = [];
+      for (const currentFile of queue) {
+        const neighbors = neighborStmt.all(currentFile, ...edgeKinds) as Array<{
+          neighbor_file: string;
+        }>;
+        for (const n of neighbors) {
+          if (noTests && isTestFile(n.neighbor_file)) continue;
+          if (n.neighbor_file === targetFile) {
+            if (!found) {
+              found = true;
+              parentMap.set(n.neighbor_file, currentFile);
+            }
+            alternateCount++;
+            continue;
+          }
+          if (!visited.has(n.neighbor_file)) {
+            visited.add(n.neighbor_file);
+            parentMap.set(n.neighbor_file, currentFile);
+            nextQueue.push(n.neighbor_file);
+          }
+        }
+      }
+      if (found) break;
+      queue = nextQueue;
+      if (queue.length === 0) break;
+    }
+
+    if (!found) {
+      return {
+        from,
+        to,
+        fromCandidates,
+        toCandidates,
+        found: false,
+        hops: null,
+        path: [],
+        alternateCount: 0,
+        edgeKinds,
+        reverse,
+        maxDepth,
+      };
+    }
+
+    // Reconstruct path
+    const filePath: string[] = [targetFile];
+    let cur = targetFile;
+    while (cur !== sourceFile) {
+      cur = parentMap.get(cur)!;
+      filePath.push(cur);
+    }
+    filePath.reverse();
+
+    return {
+      from,
+      to,
+      fromCandidates,
+      toCandidates,
+      found: true,
+      hops: filePath.length - 1,
+      path: filePath,
+      alternateCount: Math.max(0, alternateCount - 1),
+      edgeKinds,
+      reverse,
+      maxDepth,
+    };
+  } finally {
+    db.close();
+  }
+}