@optave/codegraph 3.8.0 → 3.8.1

package/src/ast-analysis/visitor.ts

@@ -20,6 +20,127 @@ import type {
   WalkResults,
 } from '../types.js';
 
+/** Merge each visitor's custom functionNodeTypes into the master set. */
+function mergeFunctionNodeTypes(visitors: Visitor[], base: Set<string>): Set<string> {
+  const merged = new Set(base);
+  for (const v of visitors) {
+    if (v.functionNodeTypes) {
+      for (const t of v.functionNodeTypes) merged.add(t);
+    }
+  }
+  return merged;
+}
+
+/** Initialize all visitors for a given language. */
+function initVisitors(visitors: Visitor[], langId: string): void {
+  for (const v of visitors) {
+    if (v.init) v.init(langId);
+  }
+}
+
+/** Check whether a visitor should be skipped at the current depth. */
+function isSkipped(
+  skipDepths: Map<number, number>,
+  visitorIndex: number,
+  currentDepth: number,
+): boolean {
+  const skipAt = skipDepths.get(visitorIndex);
+  // Skipped if skip was requested at a shallower (or equal) depth
+  // We skip descendants, not the node itself, so skip when currentDepth > skipAt
+  return skipAt !== undefined && currentDepth > skipAt;
+}
+
+/** Dispatch enterFunction hooks to all non-skipped visitors. */
+function dispatchEnterFunction(
+  visitors: Visitor[],
+  skipDepths: Map<number, number>,
+  node: TreeSitterNode,
+  funcName: string | null,
+  context: VisitorContext,
+  depth: number,
+): void {
+  for (let i = 0; i < visitors.length; i++) {
+    const v = visitors[i]!;
+    if (v.enterFunction && !isSkipped(skipDepths, i, depth)) {
+      v.enterFunction(node, funcName, context);
+    }
+  }
+}
+
+/** Dispatch enterNode hooks and track skipChildren requests. */
+function dispatchEnterNode(
+  visitors: Visitor[],
+  skipDepths: Map<number, number>,
+  node: TreeSitterNode,
+  context: VisitorContext,
+  depth: number,
+): void {
+  for (let i = 0; i < visitors.length; i++) {
+    const v = visitors[i]!;
+    if (v.enterNode && !isSkipped(skipDepths, i, depth)) {
+      const result = v.enterNode(node, context);
+      if (result?.skipChildren) {
+        skipDepths.set(i, depth);
+      }
+    }
+  }
+}
+
+/** Dispatch exitNode hooks to all non-skipped visitors. */
+function dispatchExitNode(
+  visitors: Visitor[],
+  skipDepths: Map<number, number>,
+  node: TreeSitterNode,
+  context: VisitorContext,
+  depth: number,
+): void {
+  for (let i = 0; i < visitors.length; i++) {
+    const v = visitors[i]!;
+    if (v.exitNode && !isSkipped(skipDepths, i, depth)) {
+      v.exitNode(node, context);
+    }
+  }
+}
+
+/** Clear skip flags for visitors that started skipping at this depth. */
+function clearSkipFlags(
+  skipDepths: Map<number, number>,
+  visitorCount: number,
+  depth: number,
+): void {
+  for (let i = 0; i < visitorCount; i++) {
+    if (skipDepths.get(i) === depth) {
+      skipDepths.delete(i);
+    }
+  }
+}
+
+/** Dispatch exitFunction hooks to all non-skipped visitors. */
+function dispatchExitFunction(
+  visitors: Visitor[],
+  skipDepths: Map<number, number>,
+  node: TreeSitterNode,
+  funcName: string | null,
+  context: VisitorContext,
+  depth: number,
+): void {
+  for (let i = 0; i < visitors.length; i++) {
+    const v = visitors[i]!;
+    if (v.exitFunction && !isSkipped(skipDepths, i, depth)) {
+      v.exitFunction(node, funcName, context);
+    }
+  }
+}
+
+/** Collect finish() results from all visitors into a name-keyed map. */
+function collectResults(visitors: Visitor[]): WalkResults {
+  const results: WalkResults = {};
+  for (const v of visitors) {
+    results[v.name] = v.finish ? v.finish() : undefined;
+  }
+  return results;
+}
+
 /**
  * Walk an AST root with multiple visitors in a single DFS pass.
  *
@@ -44,18 +165,8 @@ export function walkWithVisitors(
     getFunctionName = () => null,
   } = options;
 
-  // Merge all visitors' functionNodeTypes into the master set
-  const allFuncTypes = new Set(functionNodeTypes);
-  for (const v of visitors) {
-    if (v.functionNodeTypes) {
-      for (const t of v.functionNodeTypes) allFuncTypes.add(t);
-    }
-  }
-
-  // Initialize visitors
-  for (const v of visitors) {
-    if (v.init) v.init(langId);
-  }
+  const allFuncTypes = mergeFunctionNodeTypes(visitors, functionNodeTypes);
+  initVisitors(visitors, langId);
 
   // Shared context object (mutated during walk)
   const scopeStack: ScopeEntry[] = [];
@@ -66,95 +177,45 @@ export function walkWithVisitors(
     scopeStack,
   };
 
-  // Track which visitors have requested skipChildren at each depth
-  // Key: visitor index, Value: depth at which skip was requested
   const skipDepths = new Map<number, number>();
 
   function walk(node: TreeSitterNode | null, depth: number): void {
     if (!node) return;
 
     const type = node.type;
-    const isFunction = allFuncTypes.has(type);
+    const isFuncBoundary = allFuncTypes.has(type);
     let funcName: string | null = null;
 
-    // Function boundary: enter
-    if (isFunction) {
+    if (isFuncBoundary) {
       funcName = getFunctionName(node);
       context.currentFunction = node;
       scopeStack.push({ funcName, funcNode: node, params: new Map(), locals: new Map() });
-      for (let i = 0; i < visitors.length; i++) {
-        const v = visitors[i]!;
-        if (v.enterFunction && !isSkipped(i, depth)) {
-          v.enterFunction(node, funcName, context);
-        }
-      }
+      dispatchEnterFunction(visitors, skipDepths, node, funcName, context, depth);
     }
 
-    // enterNode hooks
-    for (let i = 0; i < visitors.length; i++) {
-      const v = visitors[i]!;
-      if (v.enterNode && !isSkipped(i, depth)) {
-        const result = v.enterNode(node, context);
-        if (result?.skipChildren) {
-          skipDepths.set(i, depth);
-        }
-      }
-    }
+    dispatchEnterNode(visitors, skipDepths, node, context, depth);
 
-    // Nesting tracking
     const addsNesting = nestingNodeTypes.has(type);
     if (addsNesting) context.nestingLevel++;
 
-    // Recurse children using node.child(i) (all children, not just named)
     for (let i = 0; i < node.childCount; i++) {
       walk(node.child(i), depth + 1);
     }
 
-    // Undo nesting
     if (addsNesting) context.nestingLevel--;
 
-    // exitNode hooks
-    for (let i = 0; i < visitors.length; i++) {
-      const v = visitors[i]!;
-      if (v.exitNode && !isSkipped(i, depth)) {
-        v.exitNode(node, context);
-      }
-    }
-
-    // Clear skip for any visitor that started skipping at this depth
-    for (let i = 0; i < visitors.length; i++) {
-      if (skipDepths.get(i) === depth) {
-        skipDepths.delete(i);
-      }
-    }
+    dispatchExitNode(visitors, skipDepths, node, context, depth);
+    clearSkipFlags(skipDepths, visitors.length, depth);
 
-    // Function boundary: exit
-    if (isFunction) {
-      for (let i = 0; i < visitors.length; i++) {
-        const v = visitors[i]!;
-        if (v.exitFunction && !isSkipped(i, depth)) {
-          v.exitFunction(node, funcName, context);
-        }
-      }
+    if (isFuncBoundary) {
+      dispatchExitFunction(visitors, skipDepths, node, funcName, context, depth);
       scopeStack.pop();
       context.currentFunction =
         scopeStack.length > 0 ? scopeStack[scopeStack.length - 1]!.funcNode : null;
     }
   }
 
-  function isSkipped(visitorIndex: number, currentDepth: number): boolean {
-    const skipAt = skipDepths.get(visitorIndex);
-    // Skipped if skip was requested at a shallower (or equal) depth
-    // We skip descendants, not the node itself, so skip when currentDepth > skipAt
-    return skipAt !== undefined && currentDepth > skipAt;
-  }
-
   walk(rootNode, 0);
 
-  // Collect results
-  const results: WalkResults = {};
-  for (const v of visitors) {
-    results[v.name] = v.finish ? v.finish() : undefined;
-  }
-  return results;
+  return collectResults(visitors);
 }

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

@@ -44,33 +44,33 @@ function extractExpressionText(node: TreeSitterNode): string | null {
   return truncate(node.text);
 }
 
-function extractName(kind: string, node: TreeSitterNode): string | null {
-  if (kind === 'throw') {
-    for (let i = 0; i < node.childCount; i++) {
-      const child = node.child(i);
-      if (!child) continue;
-      if (child.type === 'new_expression') return extractNewName(child);
-      if (child.type === 'call_expression') {
-        const fn = child.childForFieldName('function');
-        return fn ? fn.text : child.text?.split('(')[0] || '?';
-      }
-      if (child.type === 'identifier') return child.text;
+/** Extract the name from a throw statement's child nodes. */
+function extractThrowName(node: TreeSitterNode): string | null {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    if (child.type === 'new_expression') return extractNewName(child);
+    if (child.type === 'call_expression') {
+      const fn = child.childForFieldName('function');
+      return fn ? fn.text : child.text?.split('(')[0] || '?';
     }
-    return truncate(node.text);
+    if (child.type === 'identifier') return child.text;
   }
-  if (kind === 'await') {
-    for (let i = 0; i < node.childCount; i++) {
-      const child = node.child(i);
-      if (!child) continue;
-      if (child.type === 'call_expression') {
-        const fn = child.childForFieldName('function');
-        return fn ? fn.text : child.text?.split('(')[0] || '?';
-      }
-      if (child.type === 'identifier' || child.type === 'member_expression') {
-        return child.text;
-      }
+  return truncate(node.text);
+}
+
+/** Extract the name from an await expression's child nodes. */
+function extractAwaitName(node: TreeSitterNode): string | null {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    if (child.type === 'call_expression') {
+      const fn = child.childForFieldName('function');
+      return fn ? fn.text : child.text?.split('(')[0] || '?';
+    }
+    if (child.type === 'identifier' || child.type === 'member_expression') {
+      return child.text;
     }
-    return truncate(node.text);
   }
   return truncate(node.text);
 }
@@ -102,40 +102,43 @@ export function createAstStoreVisitor(
     return nodeIdMap.get(`${parentDef.name}|${parentDef.kind}|${parentDef.line}`) || null;
   }
 
+  function resolveNameAndText(
+    node: TreeSitterNode,
+    kind: string,
+  ): { name: string | null | undefined; text: string | null; skip?: boolean } {
+    switch (kind) {
+      case 'new':
+        return { name: extractNewName(node), text: truncate(node.text) };
+      case 'throw':
+        return { name: extractThrowName(node), text: extractExpressionText(node) };
+      case 'await':
+        return { name: extractAwaitName(node), text: extractExpressionText(node) };
+      case 'string': {
+        const content = node.text?.replace(/^['"`]|['"`]$/g, '') || '';
+        if (content.length < 2) return { name: null, text: null, skip: true };
+        return { name: truncate(content, 100), text: truncate(node.text) };
+      }
+      case 'regex':
+        return { name: node.text || '?', text: truncate(node.text) };
+      default:
+        return { name: undefined, text: null };
+    }
+  }
+
   function collectNode(node: TreeSitterNode, kind: string): void {
     if (matched.has(node.id)) return;
 
-    const line = node.startPosition.row + 1;
-    let name: string | null | undefined;
-    let text: string | null = null;
-
-    if (kind === 'new') {
-      name = extractNewName(node);
-      text = truncate(node.text);
-    } else if (kind === 'throw') {
-      name = extractName('throw', node);
-      text = extractExpressionText(node);
-    } else if (kind === 'await') {
-      name = extractName('await', node);
-      text = extractExpressionText(node);
-    } else if (kind === 'string') {
-      const content = node.text?.replace(/^['"`]|['"`]$/g, '') || '';
-      if (content.length < 2) return;
-      name = truncate(content, 100);
-      text = truncate(node.text);
-    } else if (kind === 'regex') {
-      name = node.text || '?';
-      text = truncate(node.text);
-    }
+    const resolved = resolveNameAndText(node, kind);
+    if (resolved.skip) return;
 
     rows.push({
       file: relPath,
-      line,
+      line: node.startPosition.row + 1,
       kind,
-      name,
-      text,
+      name: resolved.name,
+      text: resolved.text,
       receiver: null,
-      parentNodeId: resolveParentNodeId(line),
+      parentNodeId: resolveParentNodeId(node.startPosition.row + 1),
     });
 
     matched.add(node.id);

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

@@ -156,6 +156,27 @@ function resetAccumulators(hRules: AnyRules | null | undefined): ComplexityAcc {
   };
 }
 
+/** Classify a single node for all complexity metrics (Halstead, branching, logical ops, etc.). */
+function classifyNode(
+  node: TreeSitterNode,
+  nestingLevel: number,
+  cRules: AnyRules,
+  hRules: AnyRules | null | undefined,
+  acc: ComplexityAcc,
+): void {
+  const type = node.type;
+
+  if (hRules) classifyHalstead(node, hRules, acc);
+  if (nestingLevel > acc.maxNesting) acc.maxNesting = nestingLevel;
+  if (type === cRules.logicalNodeType) classifyLogicalOp(node, cRules, acc);
+  if (type === cRules.optionalChainType) acc.cyclomatic++;
+  if (cRules.branchNodes.has(type) && node.childCount > 0) {
+    classifyBranchNode(node, type, nestingLevel, cRules, acc);
+  }
+  classifyPlainElse(node, type, cRules, acc);
+  if (cRules.caseNodes.has(type) && node.childCount > 0) acc.cyclomatic++;
+}
+
 export function createComplexityVisitor(
   cRules: AnyRules,
   hRules?: AnyRules | null,
@@ -178,15 +199,11 @@ export function createComplexityVisitor(
       funcName: string | null,
       _context: VisitorContext,
     ): void {
-      if (fileLevelWalk) {
-        if (!activeFuncNode) {
-          acc = resetAccumulators(hRules);
-          activeFuncNode = funcNode;
-          activeFuncName = funcName;
-          funcDepth = 0;
-        } else {
-          funcDepth++;
-        }
+      if (fileLevelWalk && !activeFuncNode) {
+        acc = resetAccumulators(hRules);
+        activeFuncNode = funcNode;
+        activeFuncName = funcName;
+        funcDepth = 0;
       } else {
         funcDepth++;
       }
@@ -197,18 +214,14 @@ export function createComplexityVisitor(
       _funcName: string | null,
       _context: VisitorContext,
     ): void {
-      if (fileLevelWalk) {
-        if (funcNode === activeFuncNode) {
-          results.push({
-            funcNode,
-            funcName: activeFuncName,
-            metrics: collectResult(funcNode, acc, hRules, langId),
-          });
-          activeFuncNode = null;
-          activeFuncName = null;
-        } else {
-          funcDepth--;
-        }
+      if (fileLevelWalk && funcNode === activeFuncNode) {
+        results.push({
+          funcNode,
+          funcName: activeFuncName,
+          metrics: collectResult(funcNode, acc, hRules, langId),
+        });
+        activeFuncNode = null;
+        activeFuncName = null;
       } else {
         funcDepth--;
       }
@@ -217,26 +230,8 @@ export function createComplexityVisitor(
     enterNode(node: TreeSitterNode, context: VisitorContext): EnterNodeResult | undefined {
       if (fileLevelWalk && !activeFuncNode) return;
 
-      const type = node.type;
       const nestingLevel = fileLevelWalk ? context.nestingLevel + funcDepth : context.nestingLevel;
-
-      if (hRules) classifyHalstead(node, hRules, acc);
-
-      if (nestingLevel > acc.maxNesting) acc.maxNesting = nestingLevel;
-
-      if (type === cRules.logicalNodeType) {
-        classifyLogicalOp(node, cRules, acc);
-      }
-
-      if (type === cRules.optionalChainType) acc.cyclomatic++;
-
-      if (cRules.branchNodes.has(type) && node.childCount > 0) {
-        classifyBranchNode(node, type, nestingLevel, cRules, acc);
-      }
-
-      classifyPlainElse(node, type, cRules, acc);
-
-      if (cRules.caseNodes.has(type) && node.childCount > 0) acc.cyclomatic++;
+      classifyNode(node, nestingLevel, cRules, hRules, acc);
     },
 
     exitNode(node: TreeSitterNode): void {

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

@@ -116,14 +116,13 @@ function isCall(node: TreeSitterNode | null, isCallNode: (t: string) => boolean)
   return node != null && isCallNode(node.type);
 }
 
-function handleVarDeclarator(
+/** Resolve the value node from a variable declarator, trying multiple strategies. */
+function resolveValueNode(
   node: TreeSitterNode,
+  nameNode: TreeSitterNode | null,
   rules: AnyRules,
-  scopeStack: ScopeEntry[],
-  assignments: DataflowAssignment[],
   isCallNode: (t: string) => boolean,
-): void {
-  let nameNode = node.childForFieldName(rules.varNameField);
+): TreeSitterNode | null {
   let valueNode: TreeSitterNode | null = rules.varValueField
     ? node.childForFieldName(rules.varValueField)
     : null;
@@ -146,52 +145,97 @@ function handleVarDeclarator(
     }
   }
 
-  if (rules.expressionListType) {
-    if (nameNode && nameNode.type === rules.expressionListType)
-      nameNode = nameNode.namedChildren[0] ?? null;
-    if (valueNode && valueNode.type === rules.expressionListType)
-      valueNode = valueNode.namedChildren[0] ?? null;
+  return valueNode;
+}
+
+/** Unwrap expression-list wrappers from name/value nodes. */
+function unwrapExpressionList(
+  nameNode: TreeSitterNode | null,
+  valueNode: TreeSitterNode | null,
+  rules: AnyRules,
+): { name: TreeSitterNode | null; value: TreeSitterNode | null } {
+  if (!rules.expressionListType) return { name: nameNode, value: valueNode };
+  const name =
+    nameNode && nameNode.type === rules.expressionListType
+      ? (nameNode.namedChildren[0] ?? null)
+      : nameNode;
+  const value =
+    valueNode && valueNode.type === rules.expressionListType
+      ? (valueNode.namedChildren[0] ?? null)
+      : valueNode;
+  return { name, value };
+}
+
+/** Record a destructured call assignment (object or array destructuring). */
+function recordDestructuredAssignment(
+  nameNode: TreeSitterNode,
+  node: TreeSitterNode,
+  callee: string,
+  scope: ScopeEntry,
+  assignments: DataflowAssignment[],
+  rules: AnyRules,
+): void {
+  const names = extractParamNames(nameNode, rules);
+  for (const n of names) {
+    assignments.push({
+      varName: n,
+      callerFunc: scope.funcName!,
+      sourceCallName: callee,
+      expression: truncate(node.text),
+      line: node.startPosition.row + 1,
+    });
+    scope.locals.set(n, { type: 'destructured', callee });
   }
+}
+
+/** Record a simple (non-destructured) call assignment. */
+function recordSimpleAssignment(
+  nameNode: TreeSitterNode,
+  node: TreeSitterNode,
+  callee: string,
+  scope: ScopeEntry,
+  assignments: DataflowAssignment[],
+): void {
+  const varName = nameNode.text;
+  assignments.push({
+    varName,
+    callerFunc: scope.funcName!,
+    sourceCallName: callee,
+    expression: truncate(node.text),
+    line: node.startPosition.row + 1,
+  });
+  scope.locals.set(varName, { type: 'call_return', callee });
+}
+
+function handleVarDeclarator(
+  node: TreeSitterNode,
+  rules: AnyRules,
+  scopeStack: ScopeEntry[],
+  assignments: DataflowAssignment[],
+  isCallNode: (t: string) => boolean,
+): void {
+  const rawName = node.childForFieldName(rules.varNameField);
+  const rawValue = resolveValueNode(node, rawName, rules, isCallNode);
+  const { name: nameNode, value: valueNode } = unwrapExpressionList(rawName, rawValue, rules);
 
   const scope = currentScope(scopeStack);
   if (!nameNode || !valueNode || !scope) return;
 
   const unwrapped = unwrapAwait(valueNode, rules);
   const callExpr = isCall(unwrapped, isCallNode) ? unwrapped : null;
+  if (!callExpr) return;
 
-  if (callExpr) {
-    const callee = resolveCalleeName(callExpr, rules);
-    if (callee && scope.funcName) {
-      if (
-        (rules.objectDestructType && nameNode.type === rules.objectDestructType) ||
-        (rules.arrayDestructType && nameNode.type === rules.arrayDestructType)
-      ) {
-        const names = extractParamNames(nameNode, rules);
-        for (const n of names) {
-          assignments.push({
-            varName: n,
-            callerFunc: scope.funcName,
-            sourceCallName: callee,
-            expression: truncate(node.text),
-            line: node.startPosition.row + 1,
-          });
-          scope.locals.set(n, { type: 'destructured', callee });
-        }
-      } else {
-        const varName =
-          nameNode.type === 'identifier' || nameNode.type === rules.paramIdentifier
-            ? nameNode.text
-            : nameNode.text;
-        assignments.push({
-          varName,
-          callerFunc: scope.funcName,
-          sourceCallName: callee,
-          expression: truncate(node.text),
-          line: node.startPosition.row + 1,
-        });
-        scope.locals.set(varName, { type: 'call_return', callee });
-      }
-    }
+  const callee = resolveCalleeName(callExpr, rules);
+  if (!callee || !scope.funcName) return;
+
+  const isDestructured =
+    (rules.objectDestructType && nameNode.type === rules.objectDestructType) ||
+    (rules.arrayDestructType && nameNode.type === rules.arrayDestructType);
+
+  if (isDestructured) {
+    recordDestructuredAssignment(nameNode, node, callee, scope, assignments, rules);
+  } else {
+    recordSimpleAssignment(nameNode, node, callee, scope, assignments);
   }
 }
 

package/src/cli/commands/watch.ts

@@ -5,9 +5,23 @@ import type { CommandDefinition } from '../types.js';
 export const command: CommandDefinition = {
   name: 'watch [dir]',
   description: 'Watch project for file changes and incrementally update the graph',
-  async execute([dir], _opts, ctx) {
+  options: [
+    ['--poll', 'Use stat-based polling (default on Windows to avoid ReFS/Dev Drive crashes)'],
+    ['--native', 'Force native OS file watchers instead of polling'],
+    ['--poll-interval <ms>', 'Polling interval in milliseconds (default: 2000)'],
+  ],
+  async execute([dir], opts, ctx) {
     const root = path.resolve(dir || '.');
     const engine = ctx.program.opts().engine;
-    await watchProject(root, { engine });
+    if (opts.poll && opts.native) {
+      ctx.program.error('--poll and --native are mutually exclusive');
+    }
+    // Explicit --poll or --native wins; otherwise let watcher auto-detect by platform
+    const poll = opts.poll ? true : opts.native ? false : undefined;
+    await watchProject(root, {
+      engine,
+      poll,
+      pollInterval: opts.pollInterval ? Number(opts.pollInterval) : undefined,
+    });
   },
 };