@optave/codegraph 3.3.0 → 3.4.0

package/src/domain/analysis/{dependencies.js → dependencies.ts}

@@ -7,29 +7,47 @@ import {
   findNodesByFile,
   openReadonlyOrFail,
 } from '../../db/index.js';
+import { cachedStmt } from '../../db/repository/cached-stmt.js';
 import { isTestFile } from '../../infrastructure/test-filter.js';
 import { resolveMethodViaHierarchy } from '../../shared/hierarchy.js';
 import { normalizeSymbol } from '../../shared/normalize.js';
 import { paginateResult } from '../../shared/paginate.js';
+import type {
+  BetterSqlite3Database,
+  ImportEdgeRow,
+  NodeRow,
+  RelatedNodeRow,
+  StmtCache,
+} from '../../types.js';
 import { findMatchingNodes } from './symbol-lookup.js';
 
-export function fileDepsData(file, customDbPath, opts = {}) {
+type UpstreamRow = { id: number; name: string; kind: string; file: string; line: number };
+type NodeByIdRow = { name: string; kind: string; file: string; line: number };
+
+const _upstreamStmtCache: StmtCache<UpstreamRow> = new WeakMap();
+const _nodeByIdStmtCache: StmtCache<NodeByIdRow> = new WeakMap();
+
+export function fileDepsData(
+  file: string,
+  customDbPath: string,
+  opts: { noTests?: boolean; limit?: number; offset?: number } = {},
+) {
   const db = openReadonlyOrFail(customDbPath);
   try {
     const noTests = opts.noTests || false;
-    const fileNodes = findFileNodes(db, `%${file}%`);
+    const fileNodes = findFileNodes(db, `%${file}%`) as NodeRow[];
     if (fileNodes.length === 0) {
       return { file, results: [] };
     }
 
     const results = fileNodes.map((fn) => {
-      let importsTo = findImportTargets(db, fn.id);
+      let importsTo = findImportTargets(db, fn.id) as ImportEdgeRow[];
       if (noTests) importsTo = importsTo.filter((i) => !isTestFile(i.file));
 
-      let importedBy = findImportSources(db, fn.id);
+      let importedBy = findImportSources(db, fn.id) as ImportEdgeRow[];
       if (noTests) importedBy = importedBy.filter((i) => !isTestFile(i.file));
 
-      const defs = findNodesByFile(db, fn.file);
+      const defs = findNodesByFile(db, fn.file) as NodeRow[];
 
       return {
         file: fn.file,
@@ -48,41 +66,50 @@ export function fileDepsData(file, customDbPath, opts = {}) {
 
 /**
  * BFS transitive caller traversal starting from `callers` of `nodeId`.
- * Returns an object keyed by depth (2..depth) → array of caller descriptors.
+ * Returns an object keyed by depth (2..depth) -> array of caller descriptors.
  */
-function buildTransitiveCallers(db, callers, nodeId, depth, noTests) {
-  const transitiveCallers = {};
+function buildTransitiveCallers(
+  db: BetterSqlite3Database,
+  callers: Array<{ id: number; name: string; kind: string; file: string; line: number }>,
+  nodeId: number,
+  depth: number,
+  noTests: boolean,
+) {
+  const transitiveCallers: Record<
+    number,
+    Array<{ name: string; kind: string; file: string; line: number }>
+  > = {};
   if (depth <= 1) return transitiveCallers;
 
   const visited = new Set([nodeId]);
-  let frontier = callers
-    .map((c) => {
-      const row = db
-        .prepare('SELECT id FROM nodes WHERE name = ? AND kind = ? AND file = ? AND line = ?')
-        .get(c.name, c.kind, c.file, c.line);
-      return row ? { ...c, id: row.id } : null;
-    })
-    .filter(Boolean);
+  let frontier = callers;
+
+  const upstreamStmt = cachedStmt(
+    _upstreamStmtCache,
+    db,
+    `
+    SELECT n.id, n.name, n.kind, n.file, n.line
+    FROM edges e JOIN nodes n ON e.source_id = n.id
+    WHERE e.target_id = ? AND e.kind = 'calls'
+  `,
+  );
 
   for (let d = 2; d <= depth; d++) {
-    const nextFrontier = [];
+    const nextFrontier: typeof frontier = [];
     for (const f of frontier) {
       if (visited.has(f.id)) continue;
       visited.add(f.id);
-      const upstream = db
-        .prepare(`
-          SELECT n.name, n.kind, n.file, n.line
-          FROM edges e JOIN nodes n ON e.source_id = n.id
-          WHERE e.target_id = ? AND e.kind = 'calls'
-        `)
-        .all(f.id);
+      const upstream = upstreamStmt.all(f.id) as Array<{
+        id: number;
+        name: string;
+        kind: string;
+        file: string;
+        line: number;
+      }>;
       for (const u of upstream) {
         if (noTests && isTestFile(u.file)) continue;
-        const uid = db
-          .prepare('SELECT id FROM nodes WHERE name = ? AND kind = ? AND file = ? AND line = ?')
-          .get(u.name, u.kind, u.file, u.line)?.id;
-        if (uid && !visited.has(uid)) {
-          nextFrontier.push({ ...u, id: uid });
+        if (!visited.has(u.id)) {
+          nextFrontier.push(u);
         }
       }
     }
@@ -101,7 +128,18 @@ function buildTransitiveCallers(db, callers, nodeId, depth, noTests) {
   return transitiveCallers;
 }
 
-export function fnDepsData(name, customDbPath, opts = {}) {
+export function fnDepsData(
+  name: string,
+  customDbPath: string,
+  opts: {
+    depth?: number;
+    noTests?: boolean;
+    file?: string;
+    kind?: string;
+    limit?: number;
+    offset?: number;
+  } = {},
+) {
   const db = openReadonlyOrFail(customDbPath);
   try {
     const depth = opts.depth || 3;
@@ -114,17 +152,20 @@ export function fnDepsData(name, customDbPath, opts = {}) {
     }
 
     const results = nodes.map((node) => {
-      const callees = findCallees(db, node.id);
+      const callees = findCallees(db, node.id) as RelatedNodeRow[];
       const filteredCallees = noTests ? callees.filter((c) => !isTestFile(c.file)) : callees;
 
-      let callers = findCallers(db, node.id);
+      let callers: Array<RelatedNodeRow & { viaHierarchy?: string }> = findCallers(
+        db,
+        node.id,
+      ) as RelatedNodeRow[];
 
       if (node.kind === 'method' && node.name.includes('.')) {
-        const methodName = node.name.split('.').pop();
+        const methodName = node.name.split('.').pop()!;
         const relatedMethods = resolveMethodViaHierarchy(db, methodName);
         for (const rm of relatedMethods) {
           if (rm.id === node.id) continue;
-          const extraCallers = findCallers(db, rm.id);
+          const extraCallers = findCallers(db, rm.id) as RelatedNodeRow[];
           callers.push(...extraCallers.map((c) => ({ ...c, viaHierarchy: rm.name })));
         }
       }
@@ -163,7 +204,12 @@ export function fnDepsData(name, customDbPath, opts = {}) {
  * Returns { sourceNode, targetNode, fromCandidates, toCandidates } on success,
  * or { earlyResult } when a caller-facing error/not-found response should be returned immediately.
  */
-function resolveEndpoints(db, from, to, opts) {
+function resolveEndpoints(
+  db: BetterSqlite3Database,
+  from: string,
+  to: string,
+  opts: { noTests?: boolean; fromFile?: string; toFile?: string; kind?: string },
+) {
   const { noTests = false } = opts;
 
   const fromNodes = findMatchingNodes(db, from, {
@@ -222,13 +268,21 @@ function resolveEndpoints(db, from, to, opts) {
 /**
  * BFS from sourceId toward targetId.
  * Returns { found, parent, alternateCount, foundDepth }.
- * `parent` maps nodeId → { parentId, edgeKind }.
+ * `parent` maps nodeId -> { parentId, edgeKind }.
  */
-function bfsShortestPath(db, sourceId, targetId, edgeKinds, reverse, maxDepth, noTests) {
+function bfsShortestPath(
+  db: BetterSqlite3Database,
+  sourceId: number,
+  targetId: number,
+  edgeKinds: string[],
+  reverse: boolean,
+  maxDepth: number,
+  noTests: boolean,
+) {
   const kindPlaceholders = edgeKinds.map(() => '?').join(', ');
 
-  // Forward: source_id → target_id (A calls... calls B)
-  // Reverse: target_id → source_id (B is called by... called by A)
+  // Forward: source_id -> target_id (A calls... calls B)
+  // Reverse: target_id -> source_id (B is called by... called by A)
   const neighborQuery = reverse
     ? `SELECT n.id, n.name, n.kind, n.file, n.line, e.kind AS edge_kind
        FROM edges e JOIN nodes n ON e.source_id = n.id
@@ -239,16 +293,23 @@ function bfsShortestPath(db, sourceId, targetId, edgeKinds, reverse, maxDepth, n
   const neighborStmt = db.prepare(neighborQuery);
 
   const visited = new Set([sourceId]);
-  const parent = new Map();
+  const parent = new Map<number, { parentId: number; edgeKind: string }>();
   let queue = [sourceId];
   let found = false;
   let alternateCount = 0;
   let foundDepth = -1;
 
   for (let depth = 1; depth <= maxDepth; depth++) {
-    const nextQueue = [];
+    const nextQueue: number[] = [];
     for (const currentId of queue) {
-      const neighbors = neighborStmt.all(currentId, ...edgeKinds);
+      const neighbors = neighborStmt.all(currentId, ...edgeKinds) as Array<{
+        id: number;
+        name: string;
+        kind: string;
+        file: string;
+        line: number;
+        edge_kind: string;
+      }>;
       for (const n of neighbors) {
         if (noTests && isTestFile(n.file)) continue;
         if (n.id === targetId) {
@@ -277,25 +338,52 @@ function bfsShortestPath(db, sourceId, targetId, edgeKinds, reverse, maxDepth, n
 
 /**
  * Walk the parent map from targetId back to sourceId and return an ordered
- * array of node IDs source → target.
+ * array of node IDs source -> target.
  */
-function reconstructPath(db, pathIds, parent) {
-  const nodeCache = new Map();
-  const getNode = (id) => {
-    if (nodeCache.has(id)) return nodeCache.get(id);
-    const row = db.prepare('SELECT name, kind, file, line FROM nodes WHERE id = ?').get(id);
+function reconstructPath(
+  db: BetterSqlite3Database,
+  pathIds: number[],
+  parent: Map<number, { parentId: number; edgeKind: string }>,
+) {
+  const nodeCache = new Map<number, NodeByIdRow>();
+  const nodeByIdStmt = cachedStmt(
+    _nodeByIdStmtCache,
+    db,
+    'SELECT name, kind, file, line FROM nodes WHERE id = ?',
+  );
+  const getNode = (id: number) => {
+    if (nodeCache.has(id)) return nodeCache.get(id)!;
+    const row = nodeByIdStmt.get(id) as {
+      name: string;
+      kind: string;
+      file: string;
+      line: number;
+    };
     nodeCache.set(id, row);
     return row;
   };
 
   return pathIds.map((id, idx) => {
     const node = getNode(id);
-    const edgeKind = idx === 0 ? null : parent.get(id).edgeKind;
+    const edgeKind = idx === 0 ? null : parent.get(id)!.edgeKind;
     return { name: node.name, kind: node.kind, file: node.file, line: node.line, edgeKind };
   });
 }
 
-export function pathData(from, to, customDbPath, opts = {}) {
+export function pathData(
+  from: string,
+  to: string,
+  customDbPath: string,
+  opts: {
+    noTests?: boolean;
+    maxDepth?: number;
+    edgeKinds?: string[];
+    reverse?: boolean;
+    fromFile?: string;
+    toFile?: string;
+    kind?: string;
+  } = {},
+) {
   const db = openReadonlyOrFail(customDbPath);
   try {
     const noTests = opts.noTests || false;
@@ -309,12 +397,12 @@ export function pathData(from, to, customDbPath, opts = {}) {
       toFile: opts.toFile,
       kind: opts.kind,
     });
-    if (resolved.earlyResult) return resolved.earlyResult;
+    if ('earlyResult' in resolved) return resolved.earlyResult;
 
     const { sourceNode, targetNode, fromCandidates, toCandidates } = resolved;
 
     // Self-path
-    if (sourceNode.id === targetNode.id) {
+    if (sourceNode!.id === targetNode!.id) {
       return {
         from,
         to,
@@ -324,10 +412,10 @@ export function pathData(from, to, customDbPath, opts = {}) {
         hops: 0,
         path: [
           {
-            name: sourceNode.name,
-            kind: sourceNode.kind,
-            file: sourceNode.file,
-            line: sourceNode.line,
+            name: sourceNode!.name,
+            kind: sourceNode!.kind,
+            file: sourceNode!.file,
+            line: sourceNode!.line,
             edgeKind: null,
           },
         ],
@@ -343,7 +431,7 @@ export function pathData(from, to, customDbPath, opts = {}) {
       parent,
       alternateCount: rawAlternateCount,
       foundDepth,
-    } = bfsShortestPath(db, sourceNode.id, targetNode.id, edgeKinds, reverse, maxDepth, noTests);
+    } = bfsShortestPath(db, sourceNode!.id, targetNode!.id, edgeKinds, reverse, maxDepth, noTests);
 
     if (!found) {
       return {
@@ -365,10 +453,10 @@ export function pathData(from, to, customDbPath, opts = {}) {
     const alternateCount = Math.max(0, rawAlternateCount - 1);
 
     // Reconstruct path from target back to source
-    const pathIds = [targetNode.id];
-    let cur = targetNode.id;
-    while (cur !== sourceNode.id) {
-      const p = parent.get(cur);
+    const pathIds = [targetNode!.id];
+    let cur = targetNode!.id;
+    while (cur !== sourceNode!.id) {
+      const p = parent.get(cur)!;
       pathIds.push(p.parentId);
       cur = p.parentId;
     }

package/src/domain/analysis/{exports.js → exports.ts}

@@ -6,6 +6,7 @@ import {
   findNodesByFile,
   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';
@@ -15,8 +16,28 @@ import {
   extractSummary,
 } from '../../shared/file-utils.js';
 import { paginateResult } from '../../shared/paginate.js';
-
-export function exportsData(file, customDbPath, opts = {}) {
+import type { BetterSqlite3Database, NodeRow, StmtCache } from '../../types.js';
+
+/** Cache the schema probe for the `exported` column per db handle. */
+const _hasExportedColCache: WeakMap<BetterSqlite3Database, boolean> = new WeakMap();
+
+const _exportedNodesStmtCache: StmtCache<NodeRow> = new WeakMap();
+const _consumersStmtCache: StmtCache<{ name: string; file: string; line: number }> = new WeakMap();
+const _reexportsFromStmtCache: StmtCache<{ file: string }> = new WeakMap();
+const _reexportsToStmtCache: StmtCache<{ file: string }> = new WeakMap();
+
+export function exportsData(
+  file: string,
+  customDbPath: string,
+  opts: {
+    noTests?: boolean;
+    unused?: boolean;
+    limit?: number;
+    offset?: number;
+    // biome-ignore lint/suspicious/noExplicitAny: config shape is dynamic
+    config?: any;
+  } = {},
+) {
   const db = openReadonlyOrFail(customDbPath);
   try {
     const noTests = opts.noTests || false;
@@ -51,7 +72,7 @@ export function exportsData(file, customDbPath, opts = {}) {
     }
 
     // For single-file match return flat; for multi-match return first (like explainData)
-    const first = fileResults[0];
+    const first = fileResults[0]!;
     const base = {
       file: first.file,
       results: first.results,
@@ -63,7 +84,11 @@ export function exportsData(file, customDbPath, opts = {}) {
       totalReexported: first.totalReexported,
       totalReexportedUnused: first.totalReexportedUnused,
     };
-    const paginated = paginateResult(base, 'results', { limit: opts.limit, offset: opts.offset });
+    // biome-ignore lint/suspicious/noExplicitAny: paginateResult returns dynamic shape
+    const paginated: any = paginateResult(base, 'results', {
+      limit: opts.limit,
+      offset: opts.offset,
+    });
     // Paginate reexportedSymbols with the same limit/offset (match paginateResult behaviour)
     if (opts.limit != null) {
       const off = opts.offset || 0;
@@ -83,44 +108,78 @@ export function exportsData(file, customDbPath, opts = {}) {
   }
 }
 
-function exportsFileImpl(db, target, noTests, getFileLines, unused, displayOpts) {
-  const fileNodes = findFileNodes(db, `%${target}%`);
+function exportsFileImpl(
+  db: BetterSqlite3Database,
+  target: string,
+  noTests: boolean,
+  getFileLines: (file: string) => string[] | null,
+  unused: boolean,
+  displayOpts: Record<string, unknown>,
+) {
+  const fileNodes = findFileNodes(db, `%${target}%`) as NodeRow[];
   if (fileNodes.length === 0) return [];
 
-  // Detect whether exported column exists
-  let hasExportedCol = false;
-  try {
-    db.prepare('SELECT exported FROM nodes LIMIT 0').raw();
-    hasExportedCol = true;
-  } catch (e) {
-    debug(`exported column not available, using fallback: ${e.message}`);
+  // Detect whether exported column exists (cached per db handle)
+  let hasExportedCol: boolean;
+  if (_hasExportedColCache.has(db)) {
+    hasExportedCol = _hasExportedColCache.get(db)!;
+  } else {
+    hasExportedCol = false;
+    try {
+      db.prepare('SELECT exported FROM nodes LIMIT 0').raw(true);
+      hasExportedCol = true;
+    } catch (e: unknown) {
+      debug(`exported column not available, using fallback: ${(e as Error).message}`);
+    }
+    _hasExportedColCache.set(db, hasExportedCol);
   }
 
+  const exportedNodesStmt = hasExportedCol
+    ? cachedStmt(
+        _exportedNodesStmtCache,
+        db,
+        "SELECT * FROM nodes WHERE file = ? AND kind != 'file' AND exported = 1 ORDER BY line",
+      )
+    : null;
+  const consumersStmt = cachedStmt(
+    _consumersStmtCache,
+    db,
+    `SELECT n.name, n.file, n.line FROM edges e JOIN nodes n ON e.source_id = n.id
+         WHERE e.target_id = ? AND e.kind = 'calls'`,
+  );
+  const reexportsFromStmt = cachedStmt(
+    _reexportsFromStmtCache,
+    db,
+    `SELECT DISTINCT n.file FROM edges e JOIN nodes n ON e.source_id = n.id
+       WHERE e.target_id = ? AND e.kind = 'reexports'`,
+  );
+  const reexportsToStmt = cachedStmt(
+    _reexportsToStmtCache,
+    db,
+    `SELECT DISTINCT n.file FROM edges e JOIN nodes n ON e.target_id = n.id
+       WHERE e.source_id = ? AND e.kind = 'reexports'`,
+  );
+
   return fileNodes.map((fn) => {
-    const symbols = findNodesByFile(db, fn.file);
+    const symbols = findNodesByFile(db, fn.file) as NodeRow[];
 
-    let exported;
+    let exported: NodeRow[];
     if (hasExportedCol) {
       // Use the exported column populated during build
-      exported = db
-        .prepare(
-          "SELECT * FROM nodes WHERE file = ? AND kind != 'file' AND exported = 1 ORDER BY line",
-        )
-        .all(fn.file);
+      exported = exportedNodesStmt!.all(fn.file) as NodeRow[];
     } else {
       // Fallback: symbols that have incoming calls from other files
-      const exportedIds = findCrossFileCallTargets(db, fn.file);
+      const exportedIds = findCrossFileCallTargets(db, fn.file) as Set<number>;
       exported = symbols.filter((s) => exportedIds.has(s.id));
     }
     const internalCount = symbols.length - exported.length;
 
-    const buildSymbolResult = (s, fileLines) => {
-      let consumers = db
-        .prepare(
-          `SELECT n.name, n.file, n.line FROM edges e JOIN nodes n ON e.source_id = n.id
-           WHERE e.target_id = ? AND e.kind = 'calls'`,
-        )
-        .all(s.id);
+    const buildSymbolResult = (s: NodeRow, fileLines: string[] | null) => {
+      let consumers = consumersStmt.all(s.id) as Array<{
+        name: string;
+        file: string;
+        line: number;
+      }>;
       if (noTests) consumers = consumers.filter((c) => !isTestFile(c.file));
 
       return {
@@ -140,43 +199,31 @@ function exportsFileImpl(db, target, noTests, getFileLines, unused, displayOpts)
 
     const totalUnused = results.filter((r) => r.consumerCount === 0).length;
 
-    // Files that re-export this file (barrel → this file)
-    const reexports = db
-      .prepare(
-        `SELECT DISTINCT n.file FROM edges e JOIN nodes n ON e.source_id = n.id
-         WHERE e.target_id = ? AND e.kind = 'reexports'`,
-      )
-      .all(fn.id)
-      .map((r) => ({ file: r.file }));
+    // Files that re-export this file (barrel -> this file)
+    const reexports = (reexportsFromStmt.all(fn.id) as Array<{ file: string }>).map((r) => ({
+      file: r.file,
+    }));
 
     // For barrel files: gather symbols re-exported from target modules
-    const reexportTargets = db
-      .prepare(
-        `SELECT DISTINCT n.file FROM edges e JOIN nodes n ON e.target_id = n.id
-         WHERE e.source_id = ? AND e.kind = 'reexports'`,
-      )
-      .all(fn.id);
+    const reexportTargets = reexportsToStmt.all(fn.id) as Array<{ file: string }>;
 
-    const reexportedSymbols = [];
-    for (const target of reexportTargets) {
-      let targetExported;
+    const reexportedSymbols: Array<ReturnType<typeof buildSymbolResult> & { originFile: string }> =
+      [];
+    for (const reexTarget of reexportTargets) {
+      let targetExported: NodeRow[];
       if (hasExportedCol) {
-        targetExported = db
-          .prepare(
-            "SELECT * FROM nodes WHERE file = ? AND kind != 'file' AND exported = 1 ORDER BY line",
-          )
-          .all(target.file);
+        targetExported = exportedNodesStmt!.all(reexTarget.file) as NodeRow[];
       } else {
         // Fallback: same heuristic as direct exports — symbols called from other files
-        const targetSymbols = findNodesByFile(db, target.file);
-        const exportedIds = findCrossFileCallTargets(db, target.file);
+        const targetSymbols = findNodesByFile(db, reexTarget.file) as NodeRow[];
+        const exportedIds = findCrossFileCallTargets(db, reexTarget.file) as Set<number>;
         targetExported = targetSymbols.filter((s) => exportedIds.has(s.id));
       }
       for (const s of targetExported) {
-        const fileLines = getFileLines(target.file);
+        const fileLines = getFileLines(reexTarget.file);
         reexportedSymbols.push({
           ...buildSymbolResult(s, fileLines),
-          originFile: target.file,
+          originFile: reexTarget.file,
         });
       }
     }