@optave/codegraph 3.10.0 → 3.11.1

package/src/features/sequence.ts

@@ -91,6 +91,40 @@ interface BfsResult {
   truncated: boolean;
 }
 
+type CalleeNode = { id: number; name: string; file: string; kind: string; line: number };
+
+interface BfsFrame {
+  visited: Set<number>;
+  messages: SequenceMessage[];
+  fileSet: Set<string>;
+  idToNode: Map<number, CalleeNode>;
+  nextFrontier: number[];
+}
+
+function processCallee(
+  c: CalleeNode,
+  caller: CalleeNode,
+  depth: number,
+  noTests: boolean,
+  frame: BfsFrame,
+): void {
+  if (noTests && isTestFile(c.file)) return;
+
+  frame.fileSet.add(c.file);
+  frame.messages.push({
+    from: caller.file,
+    to: c.file,
+    label: c.name,
+    type: 'call',
+    depth,
+  });
+
+  if (frame.visited.has(c.id)) return;
+  frame.visited.add(c.id);
+  frame.nextFrontier.push(c.id);
+  frame.idToNode.set(c.id, c);
+}
+
 function bfsCallees(
   repo: Repository,
   matchNode: MatchNode,
@@ -101,46 +135,25 @@ function bfsCallees(
   let frontier = [matchNode.id];
   const messages: SequenceMessage[] = [];
   const fileSet = new Set<string>([matchNode.file]);
-  const idToNode = new Map<
-    number,
-    { id: number; name: string; file: string; kind: string; line: number }
-  >();
+  const idToNode = new Map<number, CalleeNode>();
   idToNode.set(matchNode.id, matchNode);
   let truncated = false;
 
   for (let d = 1; d <= maxDepth; d++) {
-    const nextFrontier: number[] = [];
+    const frame: BfsFrame = { visited, messages, fileSet, idToNode, nextFrontier: [] };
 
     for (const fid of frontier) {
-      const callees = repo.findCallees(fid);
       const caller = idToNode.get(fid)!;
-
-      for (const c of callees) {
-        if (noTests && isTestFile(c.file)) continue;
-
-        fileSet.add(c.file);
-        messages.push({
-          from: caller.file,
-          to: c.file,
-          label: c.name,
-          type: 'call',
-          depth: d,
-        });
-
-        if (visited.has(c.id)) continue;
-
-        visited.add(c.id);
-        nextFrontier.push(c.id);
-        idToNode.set(c.id, c);
+      for (const c of repo.findCallees(fid)) {
+        processCallee(c, caller, d, noTests, frame);
       }
     }
 
-    frontier = nextFrontier;
+    frontier = frame.nextFrontier;
     if (frontier.length === 0) break;
 
-    if (d === maxDepth && frontier.length > 0) {
-      const hasMoreCalls = frontier.some((fid) => repo.findCallees(fid).length > 0);
-      if (hasMoreCalls) truncated = true;
+    if (d === maxDepth && frontier.some((fid) => repo.findCallees(fid).length > 0)) {
+      truncated = true;
     }
   }
 
@@ -174,26 +187,16 @@ function annotateDataflow(
   }
 }
 
-function _annotateDataflowImpl(
-  db: BetterSqlite3Database,
+type DataflowStmts = {
+  getReturns: ReturnType<BetterSqlite3Database['prepare']>;
+  getFlowsTo: ReturnType<BetterSqlite3Database['prepare']>;
+};
+
+function appendReturnMessages(
   messages: SequenceMessage[],
-  idToNode: Map<number, { id: number; name: string; file: string; kind: string; line: number }>,
+  nodeByNameFile: Map<string, { id: number; name: string; file: string }>,
+  stmts: DataflowStmts,
 ): void {
-  const nodeByNameFile = new Map<string, { id: number; name: string; file: string }>();
-  for (const n of idToNode.values()) {
-    nodeByNameFile.set(`${n.name}|${n.file}`, n);
-  }
-
-  const getReturns = db.prepare(
-    `SELECT d.expression FROM dataflow d
-         WHERE d.source_id = ? AND d.kind = 'returns'`,
-  );
-  const getFlowsTo = db.prepare(
-    `SELECT d.expression FROM dataflow d
-         WHERE d.target_id = ? AND d.kind = 'flows_to'
-         ORDER BY d.param_index`,
-  );
-
   const seenReturns = new Set<string>();
   for (const msg of [...messages]) {
     if (msg.type !== 'call') continue;
@@ -203,40 +206,67 @@ function _annotateDataflowImpl(
     const returnKey = `${msg.to}->${msg.from}:${msg.label}`;
     if (seenReturns.has(returnKey)) continue;
 
-    const returns = getReturns.all(targetNode.id) as { expression: string }[];
-
-    if (returns.length > 0) {
-      seenReturns.add(returnKey);
-      const expr = returns[0]!.expression || 'result';
-      messages.push({
-        from: msg.to,
-        to: msg.from,
-        label: expr,
-        type: 'return',
-        depth: msg.depth,
-      });
-    }
+    const returns = stmts.getReturns.all(targetNode.id) as { expression: string }[];
+    if (returns.length === 0) continue;
+
+    seenReturns.add(returnKey);
+    messages.push({
+      from: msg.to,
+      to: msg.from,
+      label: returns[0]!.expression || 'result',
+      type: 'return',
+      depth: msg.depth,
+    });
   }
+}
 
+function annotateCallParams(
+  messages: SequenceMessage[],
+  nodeByNameFile: Map<string, { id: number; name: string; file: string }>,
+  stmts: DataflowStmts,
+): void {
   for (const msg of messages) {
     if (msg.type !== 'call') continue;
     const targetNode = nodeByNameFile.get(`${msg.label}|${msg.to}`);
     if (!targetNode) continue;
 
-    const params = getFlowsTo.all(targetNode.id) as { expression: string }[];
-
-    if (params.length > 0) {
-      const paramNames = params
-        .map((p) => p.expression)
-        .filter(Boolean)
-        .slice(0, 3);
-      if (paramNames.length > 0) {
-        msg.label = `${msg.label}(${paramNames.join(', ')})`;
-      }
+    const params = stmts.getFlowsTo.all(targetNode.id) as { expression: string }[];
+    const paramNames = params
+      .map((p) => p.expression)
+      .filter(Boolean)
+      .slice(0, 3);
+    if (paramNames.length > 0) {
+      msg.label = `${msg.label}(${paramNames.join(', ')})`;
     }
   }
 }
 
+function _annotateDataflowImpl(
+  db: BetterSqlite3Database,
+  messages: SequenceMessage[],
+  idToNode: Map<number, { id: number; name: string; file: string; kind: string; line: number }>,
+): void {
+  const nodeByNameFile = new Map<string, { id: number; name: string; file: string }>();
+  for (const n of idToNode.values()) {
+    nodeByNameFile.set(`${n.name}|${n.file}`, n);
+  }
+
+  const stmts: DataflowStmts = {
+    getReturns: db.prepare(
+      `SELECT d.expression FROM dataflow d
+         WHERE d.source_id = ? AND d.kind = 'returns'`,
+    ),
+    getFlowsTo: db.prepare(
+      `SELECT d.expression FROM dataflow d
+         WHERE d.target_id = ? AND d.kind = 'flows_to'
+         ORDER BY d.param_index`,
+    ),
+  };
+
+  appendReturnMessages(messages, nodeByNameFile, stmts);
+  annotateCallParams(messages, nodeByNameFile, stmts);
+}
+
 interface Participant {
   id: string;
   label: string;

package/src/features/structure-query.ts

@@ -227,6 +227,96 @@ interface HotspotsDataOpts {
   noTests?: boolean;
 }
 
+type HotspotEntry = {
+  name: string;
+  kind: string;
+  lineCount: number | null;
+  symbolCount: number | null;
+  importCount: number | null;
+  exportCount: number | null;
+  fanIn: number | null;
+  fanOut: number | null;
+  cohesion: number | null;
+  fileCount: number | null;
+  density: number;
+  coupling: number;
+};
+
+/** Compute density from either fileCount/symbolCount or lineCount/symbolCount. */
+function computeHotspotDensity(
+  symbolCount: number | null,
+  fileCount: number | null,
+  lineCount: number | null,
+): number {
+  if ((fileCount ?? 0) > 0) return (symbolCount || 0) / (fileCount ?? 1);
+  if ((lineCount ?? 0) > 0) return (symbolCount || 0) / (lineCount ?? 1);
+  return 0;
+}
+
+/** Map a native-engine hotspot row (camelCase keys) to the public HotspotEntry shape. */
+function mapNativeHotspotRow(r: {
+  name: string;
+  kind: string;
+  lineCount: number | null;
+  symbolCount: number | null;
+  importCount: number | null;
+  exportCount: number | null;
+  fanIn: number | null;
+  fanOut: number | null;
+  cohesion: number | null;
+  fileCount: number | null;
+}): HotspotEntry {
+  return {
+    name: r.name,
+    kind: r.kind,
+    lineCount: r.lineCount,
+    symbolCount: r.symbolCount,
+    importCount: r.importCount,
+    exportCount: r.exportCount,
+    fanIn: r.fanIn,
+    fanOut: r.fanOut,
+    cohesion: r.cohesion,
+    fileCount: r.fileCount,
+    density: computeHotspotDensity(r.symbolCount, r.fileCount, r.lineCount),
+    coupling: (r.fanIn || 0) + (r.fanOut || 0),
+  };
+}
+
+/** Map a JS-path hotspot row (snake_case keys from SQLite) to the public HotspotEntry shape. */
+function mapJsHotspotRow(r: HotspotRow): HotspotEntry {
+  return {
+    name: r.name,
+    kind: r.kind,
+    lineCount: r.line_count,
+    symbolCount: r.symbol_count,
+    importCount: r.import_count,
+    exportCount: r.export_count,
+    fanIn: r.fan_in,
+    fanOut: r.fan_out,
+    cohesion: r.cohesion,
+    fileCount: r.file_count,
+    density: computeHotspotDensity(r.symbol_count, r.file_count, r.line_count),
+    coupling: (r.fan_in || 0) + (r.fan_out || 0),
+  };
+}
+
+/** ORDER BY clause for each ranking dimension (strategy pattern). */
+const HOTSPOT_ORDER_BY: Record<string, string> = {
+  'fan-in': 'nm.fan_in DESC NULLS LAST',
+  'fan-out': 'nm.fan_out DESC NULLS LAST',
+  density: 'nm.symbol_count DESC NULLS LAST',
+  coupling: '(COALESCE(nm.fan_in, 0) + COALESCE(nm.fan_out, 0)) DESC NULLS LAST',
+};
+
+/** Build the JS-path SQL query for a given metric and test filter. */
+function buildHotspotQuery(metric: string, testFilter: string): string {
+  const orderBy = HOTSPOT_ORDER_BY[metric] ?? HOTSPOT_ORDER_BY['fan-in'];
+  return `SELECT n.name, n.kind, nm.line_count, nm.symbol_count, nm.import_count, nm.export_count,
+                 nm.fan_in, nm.fan_out, nm.cohesion, nm.file_count
+          FROM nodes n JOIN node_metrics nm ON n.id = nm.node_id
+          WHERE n.kind = ? ${testFilter} ORDER BY ${orderBy} LIMIT ?`;
+}
+
 export function hotspotsData(
   customDbPath?: string,
   opts: HotspotsDataOpts = {},
@@ -242,96 +332,21 @@ export function hotspotsData(
     const level = opts.level || 'file';
     const limit = opts.limit || 10;
     const noTests = opts.noTests || false;
-
     const kind = level === 'directory' ? 'directory' : 'file';
 
-    const mapRow = (r: {
-      name: string;
-      kind: string;
-      lineCount: number | null;
-      symbolCount: number | null;
-      importCount: number | null;
-      exportCount: number | null;
-      fanIn: number | null;
-      fanOut: number | null;
-      cohesion: number | null;
-      fileCount: number | null;
-    }) => ({
-      name: r.name,
-      kind: r.kind,
-      lineCount: r.lineCount,
-      symbolCount: r.symbolCount,
-      importCount: r.importCount,
-      exportCount: r.exportCount,
-      fanIn: r.fanIn,
-      fanOut: r.fanOut,
-      cohesion: r.cohesion,
-      fileCount: r.fileCount,
-      density:
-        (r.fileCount ?? 0) > 0
-          ? (r.symbolCount || 0) / (r.fileCount ?? 1)
-          : (r.lineCount ?? 0) > 0
-            ? (r.symbolCount || 0) / (r.lineCount ?? 1)
-            : 0,
-      coupling: (r.fanIn || 0) + (r.fanOut || 0),
-    });
-
     // ── Native fast path: single query instead of 4 eagerly prepared ──
     if (nativeDb?.getHotspots) {
       const rows = nativeDb.getHotspots(kind, metric, noTests, limit);
-      const hotspots = rows.map(mapRow);
+      const hotspots = rows.map(mapNativeHotspotRow);
       const base = { metric, level, limit, hotspots };
       return paginateResult(base, 'hotspots', { limit: opts.limit, offset: opts.offset });
     }
 
     // ── JS fallback ───────────────────────────────────────────────────
     const testFilter = testFilterSQL('n.name', noTests && kind === 'file');
-
-    const HOTSPOT_QUERIES: Record<string, { all(...params: unknown[]): HotspotRow[] }> = {
-      'fan-in': db.prepare(`
-        SELECT n.name, n.kind, nm.line_count, nm.symbol_count, nm.import_count, nm.export_count,
-               nm.fan_in, nm.fan_out, nm.cohesion, nm.file_count
-        FROM nodes n JOIN node_metrics nm ON n.id = nm.node_id
-        WHERE n.kind = ? ${testFilter} ORDER BY nm.fan_in DESC NULLS LAST LIMIT ?`),
-      'fan-out': db.prepare(`
-        SELECT n.name, n.kind, nm.line_count, nm.symbol_count, nm.import_count, nm.export_count,
-               nm.fan_in, nm.fan_out, nm.cohesion, nm.file_count
-        FROM nodes n JOIN node_metrics nm ON n.id = nm.node_id
-        WHERE n.kind = ? ${testFilter} ORDER BY nm.fan_out DESC NULLS LAST LIMIT ?`),
-      density: db.prepare(`
-        SELECT n.name, n.kind, nm.line_count, nm.symbol_count, nm.import_count, nm.export_count,
-               nm.fan_in, nm.fan_out, nm.cohesion, nm.file_count
-        FROM nodes n JOIN node_metrics nm ON n.id = nm.node_id
-        WHERE n.kind = ? ${testFilter} ORDER BY nm.symbol_count DESC NULLS LAST LIMIT ?`),
-      coupling: db.prepare(`
-        SELECT n.name, n.kind, nm.line_count, nm.symbol_count, nm.import_count, nm.export_count,
-               nm.fan_in, nm.fan_out, nm.cohesion, nm.file_count
-        FROM nodes n JOIN node_metrics nm ON n.id = nm.node_id
-        WHERE n.kind = ? ${testFilter} ORDER BY (COALESCE(nm.fan_in, 0) + COALESCE(nm.fan_out, 0)) DESC NULLS LAST LIMIT ?`),
-    };
-
-    const stmt = HOTSPOT_QUERIES[metric] ?? HOTSPOT_QUERIES['fan-in'];
-    const rows = stmt!.all(kind, limit);
-
-    const hotspots = rows.map((r) => ({
-      name: r.name,
-      kind: r.kind,
-      lineCount: r.line_count,
-      symbolCount: r.symbol_count,
-      importCount: r.import_count,
-      exportCount: r.export_count,
-      fanIn: r.fan_in,
-      fanOut: r.fan_out,
-      cohesion: r.cohesion,
-      fileCount: r.file_count,
-      density:
-        (r.file_count ?? 0) > 0
-          ? (r.symbol_count || 0) / (r.file_count ?? 1)
-          : (r.line_count ?? 0) > 0
-            ? (r.symbol_count || 0) / (r.line_count ?? 1)
-            : 0,
-      coupling: (r.fan_in || 0) + (r.fan_out || 0),
-    }));
+    const stmt = db.prepare(buildHotspotQuery(metric, testFilter));
+    const rows = stmt.all(kind, limit) as HotspotRow[];
+    const hotspots = rows.map(mapJsHotspotRow);
 
     const base = { metric, level, limit, hotspots };
     return paginateResult(base, 'hotspots', { limit: opts.limit, offset: opts.offset });

package/src/features/structure.ts

@@ -532,6 +532,56 @@ function batchUpdateRoles(
   })();
 }
 
+interface CallableNodeRow {
+  id: number;
+  name: string;
+  kind: string;
+  file: string;
+  fan_in: number;
+  fan_out: number;
+}
+
+/** Build the activeFiles set: files with at least one callable connected to the graph. */
+function buildActiveFilesSet(rows: CallableNodeRow[]): Set<string> {
+  const activeFiles = new Set<string>();
+  for (const r of rows) {
+    if ((r.fan_in > 0 || r.fan_out > 0) && r.kind !== 'constant') {
+      activeFiles.add(r.file);
+    }
+  }
+  return activeFiles;
+}
+
+/** Map callable rows to classifier input objects, attaching exported/prod-fan-in/active-file metadata. */
+function buildClassifierInput(
+  rows: CallableNodeRow[],
+  exportedIds: Set<number>,
+  prodFanInMap: Map<number, number>,
+  activeFiles: Set<string>,
+): Array<{
+  id: string;
+  name: string;
+  kind: string;
+  file: string;
+  fanIn: number;
+  fanOut: number;
+  isExported: boolean;
+  productionFanIn: number;
+  hasActiveFileSiblings: boolean | undefined;
+}> {
+  return rows.map((r) => ({
+    id: String(r.id),
+    name: r.name,
+    kind: r.kind,
+    file: r.file,
+    fanIn: r.fan_in,
+    fanOut: r.fan_out,
+    isExported: exportedIds.has(r.id),
+    productionFanIn: prodFanInMap.get(r.id) || 0,
+    hasActiveFileSiblings: r.kind === 'constant' ? activeFiles.has(r.file) : undefined,
+  }));
+}
+
 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.
@@ -558,14 +608,7 @@ function classifyNodeRolesFull(db: BetterSqlite3Database, emptySummary: RoleSumm
       ) fo ON n.id = fo.source_id
       WHERE n.kind NOT IN ('file', 'directory', 'parameter', 'property')`,
     )
-    .all() as {
-    id: number;
-    name: string;
-    kind: string;
-    file: string;
-    fan_in: number;
-    fan_out: number;
-  }[];
+    .all() as CallableNodeRow[];
 
   if (rows.length === 0 && leafRows.length === 0) return emptySummary;
 
@@ -629,28 +672,9 @@ function classifyNodeRolesFull(db: BetterSqlite3Database, emptySummary: RoleSumm
     prodFanInMap.set(r.target_id, r.cnt);
   }
 
-  // Files with at least one callable (non-constant) connected to the graph.
-  // Constants in these files are likely consumed locally via identifier reference.
-  const activeFiles = new Set<string>();
-  for (const r of rows) {
-    if ((r.fan_in > 0 || r.fan_out > 0) && r.kind !== 'constant') {
-      activeFiles.add(r.file);
-    }
-  }
-
   // Delegate classification to the pure-logic classifier
-  const classifierInput = rows.map((r) => ({
-    id: String(r.id),
-    name: r.name,
-    kind: r.kind,
-    file: r.file,
-    fanIn: r.fan_in,
-    fanOut: r.fan_out,
-    isExported: exportedIds.has(r.id),
-    productionFanIn: prodFanInMap.get(r.id) || 0,
-    hasActiveFileSiblings: r.kind === 'constant' ? activeFiles.has(r.file) : undefined,
-  }));
-
+  const activeFiles = buildActiveFilesSet(rows);
+  const classifierInput = buildClassifierInput(rows, exportedIds, prodFanInMap, activeFiles);
   const roleMap = classifyRoles(classifierInput);
 
   const { summary, idsByRole } = buildRoleSummary(rows, leafRows, roleMap, emptySummary);
@@ -733,14 +757,7 @@ function classifyNodeRolesIncremental(
       WHERE n.kind NOT IN ('file', 'directory', 'parameter', 'property')
         AND n.file IN (${placeholders})`,
     )
-    .all(...allAffectedFiles) as {
-    id: number;
-    name: string;
-    kind: string;
-    file: string;
-    fan_in: number;
-    fan_out: number;
-  }[];
+    .all(...allAffectedFiles) as CallableNodeRow[];
 
   if (rows.length === 0 && leafRows.length === 0) return emptySummary;
 
@@ -810,25 +827,8 @@ function classifyNodeRolesIncremental(
   }
 
   // 5. Classify affected nodes using global medians
-  const activeFiles = new Set<string>();
-  for (const r of rows) {
-    if ((r.fan_in > 0 || r.fan_out > 0) && r.kind !== 'constant') {
-      activeFiles.add(r.file);
-    }
-  }
-
-  const classifierInput = rows.map((r) => ({
-    id: String(r.id),
-    name: r.name,
-    kind: r.kind,
-    file: r.file,
-    fanIn: r.fan_in,
-    fanOut: r.fan_out,
-    isExported: exportedIds.has(r.id),
-    productionFanIn: prodFanInMap.get(r.id) || 0,
-    hasActiveFileSiblings: r.kind === 'constant' ? activeFiles.has(r.file) : undefined,
-  }));
-
+  const activeFiles = buildActiveFilesSet(rows);
+  const classifierInput = buildClassifierInput(rows, exportedIds, prodFanInMap, activeFiles);
   const roleMap = classifyRoles(classifierInput, globalMedians);
 
   // 6. Build summary (only for affected nodes) and update only those nodes