@optave/codegraph 3.11.0 → 3.11.2

package/src/ast-analysis/visitors/dataflow-visitor.ts

@@ -405,6 +405,79 @@ function handleReturn(
   }
 }
 
+/** Collect parameter entries for a function and push a new scope onto the stack. */
+function enterFunctionScope(
+  funcNode: TreeSitterNode,
+  rules: AnyRules,
+  scopeStack: ScopeEntry[],
+  parameters: DataflowParam[],
+): void {
+  const name = functionName(funcNode, rules);
+  const paramsNode = funcNode.childForFieldName(rules.paramListField);
+  const paramList = extractParams(paramsNode, rules);
+  const paramMap = new Map<string, number>();
+  for (const p of paramList) {
+    paramMap.set(p.name, p.index);
+    if (name) {
+      parameters.push({
+        funcName: name,
+        paramName: p.name,
+        paramIndex: p.index,
+        line: (paramsNode?.startPosition?.row ?? funcNode.startPosition.row) + 1,
+      });
+    }
+  }
+  scopeStack.push({ funcName: name, funcNode, params: paramMap, locals: new Map() });
+}
+
+interface DataflowDispatchCtx {
+  rules: AnyRules;
+  scopeStack: ScopeEntry[];
+  returns: DataflowReturnEntry[];
+  assignments: DataflowAssignment[];
+  argFlows: DataflowArgFlow[];
+  mutations: DataflowMutation[];
+  isCallNode: (t: string) => boolean;
+}
+
+/**
+ * Route a node to the appropriate dataflow handler based on its type.
+ * Function-definition nodes are short-circuited with an early return.
+ */
+function dispatchDataflowNode(ctx: DataflowDispatchCtx, node: TreeSitterNode): void {
+  const { rules } = ctx;
+  const t = node.type;
+
+  if (rules.functionNodes.has(t)) return;
+
+  if (rules.returnNode && t === rules.returnNode) {
+    handleReturn(node, rules, ctx.scopeStack, ctx.returns);
+    return;
+  }
+
+  if (
+    (rules.varDeclaratorNode && t === rules.varDeclaratorNode) ||
+    rules.varDeclaratorNodes?.has(t)
+  ) {
+    handleVarDeclarator(node, rules, ctx.scopeStack, ctx.assignments, ctx.isCallNode);
+    return;
+  }
+
+  if (ctx.isCallNode(t)) {
+    handleCallExpr(node, rules, ctx.scopeStack, ctx.argFlows);
+    return;
+  }
+
+  if (rules.assignmentNode && t === rules.assignmentNode) {
+    handleAssignment(node, rules, ctx.scopeStack, ctx.assignments, ctx.mutations, ctx.isCallNode);
+    return;
+  }
+
+  if (rules.expressionStmtNode && t === rules.expressionStmtNode) {
+    handleExprStmtMutation(node, rules, ctx.scopeStack, ctx.mutations, ctx.isCallNode);
+  }
+}
+
 export function createDataflowVisitor(rules: AnyRules): Visitor {
   const isCallNode: (t: string) => boolean = rules.callNodes
     ? (t: string) => rules.callNodes.has(t)
@@ -417,6 +490,16 @@ export function createDataflowVisitor(rules: AnyRules): Visitor {
   const mutations: DataflowMutation[] = [];
   const scopeStack: ScopeEntry[] = [];
 
+  const dispatchCtx: DataflowDispatchCtx = {
+    rules,
+    scopeStack,
+    returns,
+    assignments,
+    argFlows,
+    mutations,
+    isCallNode,
+  };
+
   return {
     name: 'dataflow',
     functionNodeTypes: rules.functionNodes,
@@ -426,22 +509,7 @@ export function createDataflowVisitor(rules: AnyRules): Visitor {
       _funcName: string | null,
       _context: VisitorContext,
     ): void {
-      const name = functionName(funcNode, rules);
-      const paramsNode = funcNode.childForFieldName(rules.paramListField);
-      const paramList = extractParams(paramsNode, rules);
-      const paramMap = new Map<string, number>();
-      for (const p of paramList) {
-        paramMap.set(p.name, p.index);
-        if (name) {
-          parameters.push({
-            funcName: name,
-            paramName: p.name,
-            paramIndex: p.index,
-            line: (paramsNode?.startPosition?.row ?? funcNode.startPosition.row) + 1,
-          });
-        }
-      }
-      scopeStack.push({ funcName: name, funcNode, params: paramMap, locals: new Map() });
+      enterFunctionScope(funcNode, rules, scopeStack, parameters);
     },
 
     exitFunction(
@@ -453,37 +521,8 @@ export function createDataflowVisitor(rules: AnyRules): Visitor {
     },
 
     enterNode(node: TreeSitterNode, _context: VisitorContext): EnterNodeResult | undefined {
-      const t = node.type;
-
-      if (rules.functionNodes.has(t)) return;
-
-      if (rules.returnNode && t === rules.returnNode) {
-        handleReturn(node, rules, scopeStack, returns);
-        return;
-      }
-
-      if (rules.varDeclaratorNode && t === rules.varDeclaratorNode) {
-        handleVarDeclarator(node, rules, scopeStack, assignments, isCallNode);
-        return;
-      }
-      if (rules.varDeclaratorNodes?.has(t)) {
-        handleVarDeclarator(node, rules, scopeStack, assignments, isCallNode);
-        return;
-      }
-
-      if (isCallNode(t)) {
-        handleCallExpr(node, rules, scopeStack, argFlows);
-        return;
-      }
-
-      if (rules.assignmentNode && t === rules.assignmentNode) {
-        handleAssignment(node, rules, scopeStack, assignments, mutations, isCallNode);
-        return;
-      }
-
-      if (rules.expressionStmtNode && t === rules.expressionStmtNode) {
-        handleExprStmtMutation(node, rules, scopeStack, mutations, isCallNode);
-      }
+      dispatchDataflowNode(dispatchCtx, node);
+      return undefined;
     },
 
     finish(): DataflowResultInternal {

package/src/cli/commands/embed.ts

@@ -1,7 +1,37 @@
 import path from 'node:path';
-import { buildEmbeddings, DEFAULT_MODEL, EMBEDDING_STRATEGIES } from '../../domain/search/index.js';
+import { openReadonlyOrFail } from '../../db/index.js';
+import { getEmbeddingMeta } from '../../db/repository/embeddings.js';
+import {
+  buildEmbeddings,
+  DEFAULT_MODEL,
+  EMBEDDING_STRATEGIES,
+  MODELS,
+} from '../../domain/search/index.js';
+import { info, warn } from '../../infrastructure/logger.js';
 import type { CommandDefinition } from '../types.js';
 
+function resolveStickyModel(dbPath: string | undefined): string | null {
+  try {
+    const db = openReadonlyOrFail(dbPath);
+    try {
+      const storedName = getEmbeddingMeta(db, 'model');
+      if (!storedName) return null;
+      for (const [key, cfg] of Object.entries(MODELS)) {
+        if (cfg.name === storedName) return key;
+      }
+      warn(
+        `Stored embedding model "${storedName}" is no longer recognised — falling back to default. ` +
+          'Embeddings will be rebuilt with the new model.',
+      );
+      return null;
+    } finally {
+      db.close();
+    }
+  } catch {
+    return null;
+  }
+}
+
 export const command: CommandDefinition = {
   name: 'embed [dir]',
   description:
@@ -9,7 +39,7 @@ export const command: CommandDefinition = {
   options: [
     [
       '-m, --model <name>',
-      'Embedding model (default from config or minilm). Run `codegraph models` for details',
+      'Embedding model. Defaults to config, then the model used by existing embeddings, then the built-in default. Run `codegraph models` for options',
     ],
     [
       '-s, --strategy <name>',
@@ -25,8 +55,28 @@ export const command: CommandDefinition = {
   },
   async execute([dir], opts, ctx) {
     const root = path.resolve(dir || '.');
+    const dbPath = opts.db as string | undefined;
     const embeddingsConfig = ctx.config.embeddings;
-    const model = (opts.model as string) || (embeddingsConfig?.model as string) || DEFAULT_MODEL;
-    await buildEmbeddings(root, model, opts.db as string | undefined, { strategy: opts.strategy });
+    const flagModel = opts.model as string | undefined;
+    const configModel = (embeddingsConfig?.model as string | null | undefined) ?? null;
+
+    let model: string;
+    if (flagModel) {
+      model = flagModel;
+    } else if (configModel) {
+      model = configModel;
+    } else {
+      const sticky = resolveStickyModel(dbPath);
+      if (sticky) {
+        info(
+          `Reusing previously-stored embedding model "${sticky}". Pass --model to switch, or set embeddings.model in your config.`,
+        );
+        model = sticky;
+      } else {
+        model = DEFAULT_MODEL;
+      }
+    }
+
+    await buildEmbeddings(root, model, dbPath, { strategy: opts.strategy });
   },
 };

package/src/domain/analysis/dependencies.ts

@@ -58,9 +58,32 @@ export function fileDepsData(
  *
  * Uses Repository.findCallers() so it works with both native and WASM engines.
  */
+type CallerRow = { id: number; name: string; kind: string; file: string; line: number };
+
+/** Compute the next BFS frontier from a batched upstream-callers lookup. */
+function buildNextCallerFrontier(
+  unvisited: CallerRow[],
+  batchCallers: Map<number, CallerRow[]>,
+  visited: Set<number>,
+  noTests: boolean,
+): CallerRow[] {
+  const nextFrontier: CallerRow[] = [];
+  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) || nextFrontierIds.has(u.id)) continue;
+      nextFrontierIds.add(u.id);
+      nextFrontier.push(u);
+    }
+  }
+  return nextFrontier;
+}
+
 function buildTransitiveCallers(
   repo: InstanceType<typeof Repository>,
-  callers: Array<{ id: number; name: string; kind: string; file: string; line: number }>,
+  callers: CallerRow[],
   nodeId: number,
   depth: number,
   noTests: boolean,
@@ -81,18 +104,8 @@ function buildTransitiveCallers(
     if (unvisited.length === 0) break;
 
     const batchCallers = repo.findCallersBatch(unvisited.map((f) => f.id));
-    const nextFrontier: typeof frontier = [];
-    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) && !nextFrontierIds.has(u.id)) {
-          nextFrontierIds.add(u.id);
-          nextFrontier.push(u);
-        }
-      }
-    }
+    const nextFrontier = buildNextCallerFrontier(unvisited, batchCallers, visited, noTests);
+
     if (nextFrontier.length > 0) {
       transitiveCallers[d] = nextFrontier.map((n) => ({
         name: n.name,
@@ -258,22 +271,30 @@ function resolveEndpoints(
   };
 }
 
-/**
- * BFS from sourceId toward targetId.
- * Returns { found, parent, alternateCount, foundDepth }.
- * `parent` maps nodeId -> { parentId, edgeKind }.
- */
-function bfsShortestPath(
+type NeighborRow = {
+  id: number;
+  name: string;
+  kind: string;
+  file: string;
+  line: number;
+  edge_kind: string;
+};
+
+type BfsShortestState = {
+  visited: Set<number>;
+  parent: Map<number, { parentId: number; edgeKind: string }>;
+  found: boolean;
+  foundDepth: number;
+  alternateCount: number;
+};
+
+/** Build the SQL statement that yields neighbors of a node id in the requested direction. */
+function buildNeighborStmt(
   db: BetterSqlite3Database,
-  sourceId: number,
-  targetId: number,
   edgeKinds: string[],
   reverse: boolean,
-  maxDepth: number,
-  noTests: boolean,
-) {
+): ReturnType<BetterSqlite3Database['prepare']> {
   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)
   const neighborQuery = reverse
@@ -283,50 +304,78 @@ function bfsShortestPath(
     : `SELECT n.id, n.name, n.kind, n.file, n.line, e.kind AS edge_kind
        FROM edges e JOIN nodes n ON e.target_id = n.id
        WHERE e.source_id = ? AND e.kind IN (${kindPlaceholders})`;
-  const neighborStmt = db.prepare(neighborQuery);
+  return db.prepare(neighborQuery);
+}
+
+/** Process a single neighbor row during BFS; returns true once the target has been reached. */
+function visitNeighbor(
+  n: NeighborRow,
+  currentId: number,
+  depth: number,
+  targetId: number,
+  state: BfsShortestState,
+  nextQueue: number[],
+  noTests: boolean,
+): void {
+  if (noTests && isTestFile(n.file)) return;
+  if (n.id === targetId) {
+    if (!state.found) {
+      state.found = true;
+      state.foundDepth = depth;
+      state.parent.set(n.id, { parentId: currentId, edgeKind: n.edge_kind });
+    }
+    state.alternateCount++;
+    return;
+  }
+  if (state.visited.has(n.id)) return;
+  state.visited.add(n.id);
+  state.parent.set(n.id, { parentId: currentId, edgeKind: n.edge_kind });
+  nextQueue.push(n.id);
+}
 
-  const visited = new Set([sourceId]);
-  const parent = new Map<number, { parentId: number; edgeKind: string }>();
+/**
+ * BFS from sourceId toward targetId.
+ * Returns { found, parent, alternateCount, foundDepth }.
+ * `parent` maps nodeId -> { parentId, edgeKind }.
+ */
+function bfsShortestPath(
+  db: BetterSqlite3Database,
+  sourceId: number,
+  targetId: number,
+  edgeKinds: string[],
+  reverse: boolean,
+  maxDepth: number,
+  noTests: boolean,
+) {
+  const neighborStmt = buildNeighborStmt(db, edgeKinds, reverse);
+  const state: BfsShortestState = {
+    visited: new Set([sourceId]),
+    parent: new Map(),
+    found: false,
+    foundDepth: -1,
+    alternateCount: 0,
+  };
   let queue = [sourceId];
-  let found = false;
-  let alternateCount = 0;
-  let foundDepth = -1;
 
   for (let depth = 1; depth <= maxDepth; depth++) {
     const nextQueue: number[] = [];
     for (const currentId of queue) {
-      const neighbors = neighborStmt.all(currentId, ...edgeKinds) as Array<{
-        id: number;
-        name: string;
-        kind: string;
-        file: string;
-        line: number;
-        edge_kind: string;
-      }>;
+      const neighbors = neighborStmt.all(currentId, ...edgeKinds) as NeighborRow[];
       for (const n of neighbors) {
-        if (noTests && isTestFile(n.file)) continue;
-        if (n.id === targetId) {
-          if (!found) {
-            found = true;
-            foundDepth = depth;
-            parent.set(n.id, { parentId: currentId, edgeKind: n.edge_kind });
-          }
-          alternateCount++;
-          continue;
-        }
-        if (!visited.has(n.id)) {
-          visited.add(n.id);
-          parent.set(n.id, { parentId: currentId, edgeKind: n.edge_kind });
-          nextQueue.push(n.id);
-        }
+        visitNeighbor(n, currentId, depth, targetId, state, nextQueue, noTests);
       }
     }
-    if (found) break;
+    if (state.found) break;
     queue = nextQueue;
     if (queue.length === 0) break;
   }
 
-  return { found, parent, alternateCount, foundDepth };
+  return {
+    found: state.found,
+    parent: state.parent,
+    alternateCount: state.alternateCount,
+    foundDepth: state.foundDepth,
+  };
 }
 
 /**
@@ -474,6 +523,53 @@ export function pathData(
 
 // ── File-level shortest path ────────────────────────────────────────────
 
+type FileBfsState = {
+  visited: Set<string>;
+  parentMap: Map<string, string>;
+  found: boolean;
+  alternateCount: number;
+};
+
+/** Process a neighbor file during file-level BFS; updates state in place. */
+function visitFileNeighbor(
+  neighborFile: string,
+  currentFile: string,
+  targetFile: string,
+  state: FileBfsState,
+  nextQueue: string[],
+  noTests: boolean,
+): void {
+  if (noTests && isTestFile(neighborFile)) return;
+  if (neighborFile === targetFile) {
+    if (!state.found) {
+      state.found = true;
+      state.parentMap.set(neighborFile, currentFile);
+    }
+    state.alternateCount++;
+    return;
+  }
+  if (state.visited.has(neighborFile)) return;
+  state.visited.add(neighborFile);
+  state.parentMap.set(neighborFile, currentFile);
+  nextQueue.push(neighborFile);
+}
+
+/** Reconstruct file path from target back to source using parent links. */
+function reconstructFilePath(
+  parentMap: Map<string, string>,
+  sourceFile: string,
+  targetFile: string,
+): string[] {
+  const filePath: string[] = [targetFile];
+  let cur = targetFile;
+  while (cur !== sourceFile) {
+    cur = parentMap.get(cur)!;
+    filePath.push(cur);
+  }
+  filePath.reverse();
+  return filePath;
+}
+
 /** BFS over file adjacency graph to find shortest path. */
 function bfsFilePath(
   neighborStmt: ReturnType<BetterSqlite3Database['prepare']>,
@@ -483,11 +579,13 @@ function bfsFilePath(
   maxDepth: number,
   noTests: boolean,
 ): { found: boolean; path: string[]; alternateCount: number } {
-  const visited = new Set([sourceFile]);
-  const parentMap = new Map<string, string>();
+  const state: FileBfsState = {
+    visited: new Set([sourceFile]),
+    parentMap: new Map<string, string>(),
+    found: false,
+    alternateCount: 0,
+  };
   let queue = [sourceFile];
-  let found = false;
-  let alternateCount = 0;
 
   for (let depth = 1; depth <= maxDepth; depth++) {
     const nextQueue: string[] = [];
@@ -496,38 +594,21 @@ function bfsFilePath(
         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);
-        }
+        visitFileNeighbor(n.neighbor_file, currentFile, targetFile, state, nextQueue, noTests);
       }
     }
-    if (found) break;
+    if (state.found) break;
     queue = nextQueue;
     if (queue.length === 0) break;
   }
 
-  if (!found) return { found: false, path: [], alternateCount: 0 };
+  if (!state.found) return { found: false, path: [], alternateCount: 0 };
 
-  // Reconstruct path
-  const filePath: string[] = [targetFile];
-  let cur = targetFile;
-  while (cur !== sourceFile) {
-    cur = parentMap.get(cur)!;
-    filePath.push(cur);
-  }
-  filePath.reverse();
-  return { found: true, path: filePath, alternateCount: Math.max(0, alternateCount - 1) };
+  return {
+    found: true,
+    path: reconstructFilePath(state.parentMap, sourceFile, targetFile),
+    alternateCount: Math.max(0, state.alternateCount - 1),
+  };
 }
 
 /**