@optave/codegraph 3.8.1 → 3.9.1

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

@@ -45,7 +45,13 @@ import type {
   TriageNodeRow,
   TriageQueryOpts,
 } from '../../types.js';
-import { Repository } from './base.js';
+import {
+  type FnDepsCallerNode,
+  type FnDepsEntry,
+  type FnDepsNode,
+  type FnDepsResult,
+  Repository,
+} from './base.js';
 
 // ── Row converters (napi camelCase → Repository snake_case) ─────────────
 
@@ -291,6 +297,31 @@ export class NativeRepository extends Repository {
     return this.#ndb.findCallers(nodeId).map(toRelatedNodeRow);
   }
 
+  findCallersBatch(nodeIds: number[]): Map<number, RelatedNodeRow[]> {
+    if (nodeIds.length === 0) return new Map();
+    const placeholders = nodeIds.map(() => '?').join(',');
+    const rows = this.#ndb.queryAll(
+      `SELECT e.target_id AS queried_id, n.id, n.name, n.kind, n.file, n.line, n.end_line
+       FROM edges e JOIN nodes n ON e.source_id = n.id
+       WHERE e.target_id IN (${placeholders}) AND e.kind = 'calls'`,
+      nodeIds,
+    ) as Array<Record<string, unknown>>;
+    const result = new Map<number, RelatedNodeRow[]>();
+    for (const row of rows) {
+      const qid = row.queried_id as number;
+      if (!result.has(qid)) result.set(qid, []);
+      result.get(qid)!.push({
+        id: row.id as number,
+        name: row.name as string,
+        kind: row.kind as string,
+        file: row.file as string,
+        line: row.line as number,
+        end_line: (row.end_line as number | null) ?? null,
+      });
+    }
+    return result;
+  }
+
   findDistinctCallers(nodeId: number): RelatedNodeRow[] {
     return this.#ndb.findDistinctCallers(nodeId).map(toRelatedNodeRow);
   }
@@ -436,4 +467,64 @@ export class NativeRepository extends Repository {
     }
     return false;
   }
+
+  // ── Composite queries ──────────────────────────────────────────────
+  fnDeps(
+    name: string,
+    opts?: { depth?: number; noTests?: boolean; file?: string; kind?: string },
+  ): FnDepsResult | null {
+    if (typeof this.#ndb.fnDeps !== 'function') return null;
+    const raw = this.#ndb.fnDeps(
+      name,
+      opts?.depth ?? undefined,
+      opts?.noTests ?? undefined,
+      opts?.file ?? undefined,
+      opts?.kind ?? undefined,
+    );
+    // Convert from native format (transitive_callers as array of groups)
+    // to JS format (transitiveCallers as Record<number, Array>)
+    return {
+      name: raw.name,
+      results: raw.results.map((entry: any): FnDepsEntry => {
+        const transitiveCallers: Record<number, FnDepsNode[]> = {};
+        for (const group of entry.transitiveCallers ?? []) {
+          transitiveCallers[group.depth] = (group.callers ?? []).map(
+            (c: any): FnDepsNode => ({
+              name: c.name,
+              kind: c.kind,
+              file: c.file,
+              line: c.line ?? null,
+            }),
+          );
+        }
+        return {
+          name: entry.name,
+          kind: entry.kind,
+          file: entry.file,
+          line: entry.line ?? null,
+          endLine: entry.endLine ?? entry.end_line ?? null,
+          role: entry.role ?? null,
+          fileHash: entry.fileHash ?? entry.file_hash ?? null,
+          callees: (entry.callees ?? []).map(
+            (c: any): FnDepsNode => ({
+              name: c.name,
+              kind: c.kind,
+              file: c.file,
+              line: c.line ?? null,
+            }),
+          ),
+          callers: (entry.callers ?? []).map(
+            (c: any): FnDepsCallerNode => ({
+              name: c.name,
+              kind: c.kind,
+              file: c.file,
+              line: c.line ?? null,
+              viaHierarchy: c.viaHierarchy ?? c.via_hierarchy ?? undefined,
+            }),
+          ),
+          transitiveCallers,
+        };
+      }),
+    };
+  }
 }

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

@@ -154,6 +154,32 @@ export class SqliteRepository extends Repository {
     return findCallers(this.#db, nodeId);
   }
 
+  findCallersBatch(nodeIds: number[]): Map<number, RelatedNodeRow[]> {
+    if (nodeIds.length === 0) return new Map();
+    const placeholders = nodeIds.map(() => '?').join(',');
+    const rows = this.#db
+      .prepare(
+        `SELECT e.target_id AS queried_id, n.id, n.name, n.kind, n.file, n.line, n.end_line
+         FROM edges e JOIN nodes n ON e.source_id = n.id
+         WHERE e.target_id IN (${placeholders}) AND e.kind = 'calls'`,
+      )
+      .all(...nodeIds) as Array<RelatedNodeRow & { queried_id: number }>;
+    const result = new Map<number, RelatedNodeRow[]>();
+    for (const row of rows) {
+      const qid = row.queried_id;
+      if (!result.has(qid)) result.set(qid, []);
+      result.get(qid)!.push({
+        id: row.id,
+        name: row.name,
+        kind: row.kind,
+        file: row.file,
+        line: row.line,
+        end_line: row.end_line,
+      });
+    }
+    return result;
+  }
+
   findDistinctCallers(nodeId: number): RelatedNodeRow[] {
     return findDistinctCallers(this.#db, nodeId);
   }

package/src/domain/analysis/dependencies.ts

@@ -75,14 +75,20 @@ function buildTransitiveCallers(
   let frontier = callers;
 
   for (let d = 2; d <= depth; d++) {
+    // Collect unvisited frontier IDs for a single batched query per depth
+    const unvisited = frontier.filter((f) => !visited.has(f.id));
+    for (const f of unvisited) visited.add(f.id);
+    if (unvisited.length === 0) break;
+
+    const batchCallers = repo.findCallersBatch(unvisited.map((f) => f.id));
     const nextFrontier: typeof frontier = [];
-    for (const f of frontier) {
-      if (visited.has(f.id)) continue;
-      visited.add(f.id);
-      const upstream = repo.findCallers(f.id) as RelatedNodeRow[];
+    const nextFrontierIds = new Set<number>();
+    for (const f of unvisited) {
+      const upstream = batchCallers.get(f.id) || [];
       for (const u of upstream) {
         if (noTests && isTestFile(u.file)) continue;
-        if (!visited.has(u.id)) {
+        if (!visited.has(u.id) && !nextFrontierIds.has(u.id)) {
+          nextFrontierIds.add(u.id);
           nextFrontier.push(u);
         }
       }
@@ -96,7 +102,6 @@ function buildTransitiveCallers(
       }));
     }
     frontier = nextFrontier;
-    if (frontier.length === 0) break;
   }
 
   return transitiveCallers;
@@ -168,6 +173,19 @@ export function fnDepsData(
   } = {},
 ) {
   return withRepo(customDbPath, (repo) => {
+    // Try native composite path — single NAPI call for the entire query.
+    const nativeResult = repo.fnDeps(name, {
+      depth: opts.depth,
+      noTests: opts.noTests,
+      file: opts.file,
+      kind: opts.kind,
+    });
+    if (nativeResult) {
+      const base = { name: nativeResult.name, results: nativeResult.results };
+      return paginateResult(base, 'results', { limit: opts.limit, offset: opts.offset });
+    }
+
+    // Fallback: JS-orchestrated path (used when native engine is unavailable)
     const depth = opts.depth || 3;
     const noTests = opts.noTests || false;
     const hc = new Map();

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

@@ -366,6 +366,27 @@ function buildImportEdges(
       stmts.insertEdge.run(fileNodeId, targetRow.id, edgeKind, 1.0, 0);
       edgesAdded++;
 
+      // Type-only imports: create symbol-level edges so the target symbols
+      // get fan-in credit and aren't falsely classified as dead code.
+      if (imp.typeOnly) {
+        for (const name of imp.names) {
+          const cleanName = name.replace(/^\*\s+as\s+/, '');
+          let targetFile = resolvedPath;
+          if (db && isBarrelFile(db, resolvedPath)) {
+            const actual = resolveBarrelTarget(db, resolvedPath, cleanName);
+            if (actual) targetFile = actual;
+          }
+          const candidates = stmts.findNodeInFile.all(cleanName, targetFile) as Array<{
+            id: number;
+            file: string;
+          }>;
+          if (candidates.length > 0) {
+            stmts.insertEdge.run(fileNodeId, candidates[0]!.id, 'imports-type', 1.0, 0);
+            edgesAdded++;
+          }
+        }
+      }
+
       // Barrel resolution: create edges through re-export chains
       if (!imp.reexport && db) {
         edgesAdded += resolveBarrelImportEdges(db, stmts, fileNodeId, resolvedPath, imp);