@optave/codegraph 3.11.1 → 3.11.2

package/src/domain/graph/builder/stages/build-edges.ts

@@ -20,6 +20,12 @@ import type {
   TypeMapEntry,
 } from '../../../../types.js';
 import { computeConfidence } from '../../resolve.js';
+import {
+  type CallNodeLookup,
+  findCaller,
+  resolveCallTargets,
+  resolveReceiverEdge,
+} from '../call-resolver.js';
 import type { PipelineContext } from '../context.js';
 import { BUILTIN_RECEIVERS, batchInsertEdges } from '../helpers.js';
 
@@ -486,6 +492,7 @@ function buildCallEdgesJS(
   allEdgeRows: EdgeRowTuple[],
 ): void {
   const { fileSymbols, barrelOnlyFiles, rootDir } = ctx;
+  const lookup = makeContextLookup(ctx, getNodeIdStmt);
 
   for (const [relPath, symbols] of fileSymbols) {
     if (barrelOnlyFiles.has(relPath)) continue;
@@ -497,13 +504,12 @@ function buildCallEdgesJS(
     const seenCallEdges = new Set<string>();
 
     buildFileCallEdges(
-      ctx,
       relPath,
       symbols,
       fileNodeRow,
       importedNames,
       seenCallEdges,
-      getNodeIdStmt,
+      lookup,
       allEdgeRows,
       typeMap,
     );
@@ -540,127 +546,37 @@ function buildImportedNamesMap(
   return importedNames;
 }
 
-function findCaller(
-  call: Call,
-  definitions: ReadonlyArray<{ name: string; kind: string; line: number; endLine?: number | null }>,
-  relPath: string,
-  getNodeIdStmt: NodeIdStmt,
-  fileNodeRow: { id: number },
-): { id: number } {
-  let caller: { id: number } | null = null;
-  let callerSpan = Infinity;
-  for (const def of definitions) {
-    if (def.line <= call.line) {
-      const end = def.endLine || Infinity;
-      if (call.line <= end) {
-        const span = end - def.line;
-        if (span < callerSpan) {
-          const row = getNodeIdStmt.get(def.name, def.kind, relPath, def.line);
-          if (row) {
-            caller = row;
-            callerSpan = span;
-          }
-        }
-      }
-    }
-  }
-  return caller || fileNodeRow;
-}
-
-function resolveCallTargets(
-  ctx: PipelineContext,
-  call: Call,
-  relPath: string,
-  importedNames: Map<string, string>,
-  typeMap: Map<string, TypeMapEntry | string>,
-): { targets: NodeRow[]; importedFrom: string | undefined } {
-  const importedFrom = importedNames.get(call.name);
-  let targets: NodeRow[] | undefined;
-
-  if (importedFrom) {
-    targets = ctx.nodesByNameAndFile.get(`${call.name}|${importedFrom}`) || [];
-    if (targets.length === 0 && isBarrelFile(ctx, importedFrom)) {
-      const actualSource = resolveBarrelExport(ctx, importedFrom, call.name);
-      if (actualSource) {
-        targets = ctx.nodesByNameAndFile.get(`${call.name}|${actualSource}`) || [];
-      }
-    }
-  }
-
-  if (!targets || targets.length === 0) {
-    targets = ctx.nodesByNameAndFile.get(`${call.name}|${relPath}`) || [];
-    if (targets.length === 0) {
-      targets = resolveByMethodOrGlobal(ctx, call, relPath, typeMap);
-    }
-  }
-
-  if (targets.length > 1) {
-    targets.sort((a, b) => {
-      const confA = computeConfidence(relPath, a.file, importedFrom ?? null);
-      const confB = computeConfidence(relPath, b.file, importedFrom ?? null);
-      return confB - confA;
-    });
-  }
-
-  return { targets, importedFrom };
-}
-
-function resolveByMethodOrGlobal(
-  ctx: PipelineContext,
-  call: Call,
-  relPath: string,
-  typeMap: Map<string, TypeMapEntry | string>,
-): NodeRow[] {
-  // Type-aware resolution: translate variable receiver to its declared type
-  if (call.receiver && typeMap) {
-    const typeEntry = typeMap.get(call.receiver);
-    const typeName = typeEntry
-      ? typeof typeEntry === 'string'
-        ? typeEntry
-        : typeEntry.type
-      : null;
-    if (typeName) {
-      const qualifiedName = `${typeName}.${call.name}`;
-      const typed = (ctx.nodesByName.get(qualifiedName) || []).filter((n) => n.kind === 'method');
-      if (typed.length > 0) return typed;
-    }
-  }
-
-  if (
-    !call.receiver ||
-    call.receiver === 'this' ||
-    call.receiver === 'self' ||
-    call.receiver === 'super'
-  ) {
-    return (ctx.nodesByName.get(call.name) || []).filter(
-      (n) => computeConfidence(relPath, n.file, null) >= 0.5,
-    );
-  }
-  return [];
+function makeContextLookup(ctx: PipelineContext, getNodeIdStmt: NodeIdStmt): CallNodeLookup {
+  return {
+    byNameAndFile: (name, file) => ctx.nodesByNameAndFile.get(`${name}|${file}`) ?? [],
+    byName: (name) => ctx.nodesByName.get(name) ?? [],
+    isBarrel: (file) => isBarrelFile(ctx, file),
+    resolveBarrel: (barrelFile, symbolName) => resolveBarrelExport(ctx, barrelFile, symbolName),
+    nodeId: (name, kind, file, line) => getNodeIdStmt.get(name, kind, file, line),
+  };
 }
 
 function buildFileCallEdges(
-  ctx: PipelineContext,
   relPath: string,
   symbols: ExtractorOutput,
   fileNodeRow: { id: number },
   importedNames: Map<string, string>,
   seenCallEdges: Set<string>,
-  getNodeIdStmt: NodeIdStmt,
+  lookup: CallNodeLookup,
   allEdgeRows: EdgeRowTuple[],
   typeMap: Map<string, TypeMapEntry | string>,
 ): void {
   for (const call of symbols.calls) {
     if (call.receiver && BUILTIN_RECEIVERS.has(call.receiver)) continue;
 
-    const caller = findCaller(call, symbols.definitions, relPath, getNodeIdStmt, fileNodeRow);
+    const caller = findCaller(lookup, call, symbols.definitions, relPath, fileNodeRow);
     const isDynamic: number = call.dynamic ? 1 : 0;
     const { targets, importedFrom } = resolveCallTargets(
-      ctx,
+      lookup,
       call,
       relPath,
       importedNames,
-      typeMap,
+      typeMap as Map<string, unknown>,
     );
 
     for (const t of targets) {
@@ -672,7 +588,6 @@ function buildFileCallEdges(
       }
     }
 
-    // Receiver edge
     if (
       call.receiver &&
       !BUILTIN_RECEIVERS.has(call.receiver) &&
@@ -680,36 +595,17 @@ function buildFileCallEdges(
       call.receiver !== 'self' &&
       call.receiver !== 'super'
     ) {
-      buildReceiverEdge(ctx, call, caller, relPath, seenCallEdges, allEdgeRows, typeMap);
-    }
-  }
-}
-
-function buildReceiverEdge(
-  ctx: PipelineContext,
-  call: Call,
-  caller: { id: number },
-  relPath: string,
-  seenCallEdges: Set<string>,
-  allEdgeRows: EdgeRowTuple[],
-  typeMap: Map<string, TypeMapEntry | string>,
-): void {
-  const receiverKinds = new Set(['class', 'struct', 'interface', 'type', 'module']);
-  const typeEntry = typeMap?.get(call.receiver!);
-  const typeName = typeEntry ? (typeof typeEntry === 'string' ? typeEntry : typeEntry.type) : null;
-  const typeConfidence = typeEntry && typeof typeEntry === 'object' ? typeEntry.confidence : null;
-  const effectiveReceiver = typeName || call.receiver!;
-  const samefile = ctx.nodesByNameAndFile.get(`${effectiveReceiver}|${relPath}`) || [];
-  const candidates = samefile.length > 0 ? samefile : ctx.nodesByName.get(effectiveReceiver) || [];
-  const receiverNodes = candidates.filter((n) => receiverKinds.has(n.kind));
-  if (receiverNodes.length > 0 && caller) {
-    const recvTarget = receiverNodes[0]!;
-    const recvKey = `recv|${caller.id}|${recvTarget.id}`;
-    if (!seenCallEdges.has(recvKey)) {
-      seenCallEdges.add(recvKey);
-      // Use type source confidence when available, otherwise 0.7 for untyped receiver
-      const confidence = typeConfidence ?? (typeName ? 0.9 : 0.7);
-      allEdgeRows.push([caller.id, recvTarget.id, 'receiver', confidence, 0]);
+      const recv = resolveReceiverEdge(
+        lookup,
+        { name: call.name, receiver: call.receiver },
+        caller,
+        relPath,
+        typeMap as Map<string, unknown>,
+        seenCallEdges,
+      );
+      if (recv) {
+        allEdgeRows.push([recv.callerId, recv.receiverId, 'receiver', recv.confidence, 0]);
+      }
     }
   }
 }

package/src/domain/graph/watcher.ts

@@ -35,10 +35,12 @@ function prepareWatcherStatements(db: ReturnType<typeof openDb>): IncrementalStm
       'SELECT COUNT(*) as c FROM edges WHERE source_id IN (SELECT id FROM nodes WHERE file = ?)',
     ),
     findNodeInFile: db.prepare(
-      "SELECT id, file FROM nodes WHERE name = ? AND kind IN ('function', 'method', 'class', 'interface', 'type', 'struct', 'enum', 'trait', 'record', 'module', 'constant') AND file = ?",
+      "SELECT id, kind, file FROM nodes WHERE name = ? AND kind IN ('function', 'method', 'class', 'interface', 'type', 'struct', 'enum', 'trait', 'record', 'module', 'constant') AND file = ?",
     ),
     findNodeByName: db.prepare(
-      "SELECT id, file FROM nodes WHERE name = ? AND kind IN ('function', 'method', 'class', 'interface', 'type', 'struct', 'enum', 'trait', 'record', 'module', 'constant')",
+      // `kind` is included so resolveByMethodOrGlobal can filter to 'method' for
+      // type-aware receiver resolution (mirrors the full-build resolver).
+      "SELECT id, file, kind FROM nodes WHERE name = ? AND kind IN ('function', 'method', 'class', 'interface', 'type', 'struct', 'enum', 'trait', 'record', 'module', 'constant')",
     ),
     listSymbols: db.prepare("SELECT name, kind, line FROM nodes WHERE file = ? AND kind != 'file'"),
   };

package/src/features/structure.ts

@@ -1,5 +1,5 @@
 import path from 'node:path';
-import { getNodeId, testFilterSQL } from '../db/index.js';
+import { getBuildMeta, getNodeId, setBuildMeta, testFilterSQL } from '../db/index.js';
 import { debug } from '../infrastructure/logger.js';
 import { normalizePath } from '../shared/constants.js';
 import type { BetterSqlite3Database } from '../types.js';
@@ -582,6 +582,111 @@ function buildClassifierInput(
   }));
 }
 
+// ─── Median cache helpers ─────────────────────────────────────────────────────
+
+const ROLES_MEDIANS_KEY = 'roles_medians';
+
+// Invalidate cached medians when the edge count drifts past this threshold.
+// A 1-file rebuild adds/removes < 100 edges — well within the margin.
+const MEDIAN_INVALIDATION_DELTA = 500;
+
+/**
+ * Full edge-table GROUP BY scan — O(M). Only runs on cache miss.
+ *
+ * Joins `nodes` to restrict to the same non-leaf kinds that
+ * `classifyNodeRolesFull` uses when computing medians from in-memory rows
+ * (excludes 'file', 'directory', 'parameter', 'property'). This keeps the
+ * two paths consistent so a cold-cache fallback produces the same distribution
+ * as the full-build cached value.
+ *
+ * Also returns the filtered edge count used for computing the medians so the
+ * caller can pass it directly to `writeMedianCache` without a second query.
+ */
+function computeGlobalMediansFromEdges(db: BetterSqlite3Database): {
+  fanIn: number;
+  fanOut: number;
+  edgeCount: number;
+} {
+  const excludedKinds = `('file', 'directory', 'parameter', 'property')`;
+  const fanInRows = db
+    .prepare(
+      `SELECT COUNT(*) AS cnt FROM edges e
+       JOIN nodes t ON e.target_id = t.id
+       WHERE e.kind IN ('calls', 'imports-type')
+         AND t.kind NOT IN ${excludedKinds}
+       GROUP BY e.target_id`,
+    )
+    .all() as { cnt: number }[];
+  const fanOutRows = db
+    .prepare(
+      `SELECT COUNT(*) AS cnt FROM edges e
+       JOIN nodes s ON e.source_id = s.id
+       WHERE e.kind = 'calls'
+         AND s.kind NOT IN ${excludedKinds}
+       GROUP BY e.source_id`,
+    )
+    .all() as { cnt: number }[];
+  const fanInDist = fanInRows.map((r) => r.cnt).sort((a, b) => a - b);
+  const fanOutDist = fanOutRows.map((r) => r.cnt).sort((a, b) => a - b);
+  // Sum of fanInRows[*].cnt equals the total edge count for the relevant
+  // edge subset — no extra COUNT query needed.
+  const edgeCount = fanInRows.reduce((acc, r) => acc + r.cnt, 0);
+  return { fanIn: median(fanInDist), fanOut: median(fanOutDist), edgeCount };
+}
+
+/**
+ * Read cached role medians from build_meta. Returns null when absent or stale
+ * (edge count moved beyond MEDIAN_INVALIDATION_DELTA from the cached value).
+ *
+ * The staleness check uses the same edge subset (calls + imports-type) that
+ * the medians are derived from, so only changes to the edges that actually
+ * influence fan-in/fan-out can evict the cache.
+ */
+function readCachedMedians(db: BetterSqlite3Database): { fanIn: number; fanOut: number } | null {
+  const raw = getBuildMeta(db, ROLES_MEDIANS_KEY);
+  if (!raw) return null;
+  try {
+    const cached = JSON.parse(raw) as { fanIn: number; fanOut: number; edgeCount: number };
+    // Count only the edge kinds that drive median computation — same subset
+    // used by computeGlobalMediansFromEdges and classifyNodeRolesFull.
+    const currentCount = (
+      db
+        .prepare(`SELECT COUNT(*) AS cnt FROM edges WHERE kind IN ('calls', 'imports-type')`)
+        .get() as { cnt: number }
+    ).cnt;
+    if (
+      Math.abs(currentCount - cached.edgeCount) >
+      Math.max(MEDIAN_INVALIDATION_DELTA, cached.edgeCount * 0.1)
+    )
+      return null;
+    return { fanIn: cached.fanIn, fanOut: cached.fanOut };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Persist global role medians + current edge count to build_meta.
+ *
+ * @param edgeCount - pre-computed calls+imports-type edge count. When provided,
+ *   the function skips the COUNT query entirely. Pass when the count is already
+ *   known at the call site (e.g. from `computeGlobalMediansFromEdges`).
+ */
+function writeMedianCache(
+  db: BetterSqlite3Database,
+  medians: { fanIn: number; fanOut: number },
+  edgeCount?: number,
+): void {
+  const cnt =
+    edgeCount ??
+    (
+      db
+        .prepare(`SELECT COUNT(*) AS cnt FROM edges WHERE kind IN ('calls', 'imports-type')`)
+        .get() as { cnt: number }
+    ).cnt;
+  setBuildMeta(db, { [ROLES_MEDIANS_KEY]: JSON.stringify({ ...medians, edgeCount: cnt }) });
+}
+
 function classifyNodeRolesFull(db: BetterSqlite3Database, emptySummary: RoleSummary): RoleSummary {
   // Leaf kinds (parameter, property) can never have callers/callees.
   // Classify them directly as dead-leaf without the expensive fan-in/fan-out JOINs.
@@ -672,10 +777,28 @@ function classifyNodeRolesFull(db: BetterSqlite3Database, emptySummary: RoleSumm
     prodFanInMap.set(r.target_id, r.cnt);
   }
 
-  // Delegate classification to the pure-logic classifier
+  // Delegate classification to the pure-logic classifier.
+  // Compute medians from the already-loaded rows (no extra DB round-trip),
+  // pass them as overrides to avoid recomputing inside classifyRoles,
+  // and cache them for subsequent incremental builds.
   const activeFiles = buildActiveFilesSet(rows);
   const classifierInput = buildClassifierInput(rows, exportedIds, prodFanInMap, activeFiles);
-  const roleMap = classifyRoles(classifierInput);
+  const nonZeroFanIn = classifierInput
+    .filter((n) => n.fanIn > 0)
+    .map((n) => n.fanIn)
+    .sort((a, b) => a - b);
+  const nonZeroFanOut = classifierInput
+    .filter((n) => n.fanOut > 0)
+    .map((n) => n.fanOut)
+    .sort((a, b) => a - b);
+  const globalMedians = { fanIn: median(nonZeroFanIn), fanOut: median(nonZeroFanOut) };
+  const roleMap = classifyRoles(classifierInput, globalMedians);
+  // Derive the edge count from already-loaded in-memory rows: summing fan_in
+  // across all nodes equals COUNT(*) FROM edges WHERE kind IN ('calls','imports-type'),
+  // since the full-build query left-joins every matching edge exactly once per target.
+  // Passing this avoids an extra COUNT query on the full-build path.
+  const inMemoryEdgeCount = rows.reduce((acc, r) => acc + r.fan_in, 0);
+  writeMedianCache(db, globalMedians, inMemoryEdgeCount);
 
   const { summary, idsByRole } = buildRoleSummary(rows, leafRows, roleMap, emptySummary);
 
@@ -691,7 +814,9 @@ function classifyNodeRolesFull(db: BetterSqlite3Database, emptySummary: RoleSumm
  * plus their immediate edge neighbours (callers and callees in other files).
  *
  * Uses indexed point lookups for fan-in/fan-out instead of full table scans.
- * Global medians are computed from edge distribution (fast GROUP BY on index).
+ * Global medians are read from the build_meta cache written by the last full
+ * classification; the cache is only recomputed when the edge count drifts
+ * beyond MEDIAN_INVALIDATION_DELTA (i.e. large structural changes).
  * Unchanged files not connected to changed files keep their roles from the
  * previous build.
  */
@@ -718,25 +843,20 @@ function classifyNodeRolesIncremental(
   const allAffectedFiles = [...changedFiles, ...neighbourFiles.map((r) => r.file)];
   const placeholders = allAffectedFiles.map(() => '?').join(',');
 
-  // 1. Compute global medians from edge distribution (fast: scans edge index, no node join)
-  const fanInDist = (
-    db
-      .prepare(
-        `SELECT COUNT(*) AS cnt FROM edges WHERE kind IN ('calls', 'imports-type') GROUP BY target_id`,
-      )
-      .all() as { cnt: number }[]
-  )
-    .map((r) => r.cnt)
-    .sort((a, b) => a - b);
-  const fanOutDist = (
-    db
-      .prepare(`SELECT COUNT(*) AS cnt FROM edges WHERE kind = 'calls' GROUP BY source_id`)
-      .all() as { cnt: number }[]
-  )
-    .map((r) => r.cnt)
-    .sort((a, b) => a - b);
-
-  const globalMedians = { fanIn: median(fanInDist), fanOut: median(fanOutDist) };
+  // 1. Read global medians from cache; fall back to full edge scan only on miss.
+  // The median barely moves for a 1-file change, so the cache is almost always
+  // valid, eliminating 2× full edge-table GROUP BY queries (~10-15 ms on large graphs).
+  const cachedMedians = readCachedMedians(db);
+  let globalMedians: { fanIn: number; fanOut: number };
+  if (cachedMedians) {
+    globalMedians = cachedMedians;
+  } else {
+    const computed = computeGlobalMediansFromEdges(db);
+    // Pass the edgeCount returned by computeGlobalMediansFromEdges so
+    // writeMedianCache does not issue a second COUNT query.
+    writeMedianCache(db, computed, computed.edgeCount);
+    globalMedians = computed;
+  }
 
   // 2a. Leaf kinds (parameter, property) in affected files — always dead-leaf
   const leafRows = db