@optave/codegraph 3.3.1 → 3.4.0

package/src/ast-analysis/{visitor.js → visitor.ts}

@@ -9,24 +9,17 @@
  *
  * The walker maintains shared context (nestingLevel, scopeStack, currentFunction)
  * so individual visitors don't need to track traversal state themselves.
- *
- * @typedef {object} VisitorContext
- * @property {number}  nestingLevel    - Current nesting depth (for complexity)
- * @property {object}  currentFunction - Enclosing function node (or null)
- * @property {string}  langId          - Language ID
- * @property {Array}   scopeStack      - Function scope stack [{funcName, funcNode, params, locals}]
- *
- * @typedef {object} Visitor
- * @property {string}   name
- * @property {function} [init](langId, rules)         - Called once before the walk
- * @property {function} [enterNode](node, context)     - Called entering each node; return { skipChildren: true } to skip this visitor's hooks for descendants
- * @property {function} [exitNode](node, context)      - Called leaving each node
- * @property {function} [enterFunction](funcNode, funcName, context) - Called entering a function
- * @property {function} [exitFunction](funcNode, funcName, context)  - Called leaving a function
- * @property {function} [finish]()                     - Called after the walk; return collected data
- * @property {Set}      [functionNodeTypes]            - Extra function node types this visitor cares about
  */
 
+import type {
+  ScopeEntry,
+  TreeSitterNode,
+  Visitor,
+  VisitorContext,
+  WalkOptions,
+  WalkResults,
+} from '../types.js';
+
 /**
  * Walk an AST root with multiple visitors in a single DFS pass.
  *
@@ -39,10 +32,15 @@
  * @param {function} [options.getFunctionName] - (funcNode) => string|null
  * @returns {object} Map of visitor.name → finish() result
  */
-export function walkWithVisitors(rootNode, visitors, langId, options = {}) {
+export function walkWithVisitors(
+  rootNode: TreeSitterNode,
+  visitors: Visitor[],
+  langId: string,
+  options: WalkOptions = {},
+): WalkResults {
   const {
-    functionNodeTypes = new Set(),
-    nestingNodeTypes = new Set(),
+    functionNodeTypes = new Set<string>(),
+    nestingNodeTypes = new Set<string>(),
     getFunctionName = () => null,
   } = options;
 
@@ -60,8 +58,8 @@ export function walkWithVisitors(rootNode, visitors, langId, options = {}) {
   }
 
   // Shared context object (mutated during walk)
-  const scopeStack = [];
-  const context = {
+  const scopeStack: ScopeEntry[] = [];
+  const context: VisitorContext = {
     nestingLevel: 0,
     currentFunction: null,
     langId,
@@ -70,14 +68,14 @@ export function walkWithVisitors(rootNode, visitors, langId, options = {}) {
 
   // Track which visitors have requested skipChildren at each depth
   // Key: visitor index, Value: depth at which skip was requested
-  const skipDepths = new Map();
+  const skipDepths = new Map<number, number>();
 
-  function walk(node, depth) {
+  function walk(node: TreeSitterNode | null, depth: number): void {
     if (!node) return;
 
     const type = node.type;
     const isFunction = allFuncTypes.has(type);
-    let funcName = null;
+    let funcName: string | null = null;
 
     // Function boundary: enter
     if (isFunction) {
@@ -85,7 +83,7 @@ export function walkWithVisitors(rootNode, visitors, langId, options = {}) {
       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];
+        const v = visitors[i]!;
         if (v.enterFunction && !isSkipped(i, depth)) {
           v.enterFunction(node, funcName, context);
         }
@@ -94,7 +92,7 @@ export function walkWithVisitors(rootNode, visitors, langId, options = {}) {
 
     // enterNode hooks
     for (let i = 0; i < visitors.length; i++) {
-      const v = visitors[i];
+      const v = visitors[i]!;
       if (v.enterNode && !isSkipped(i, depth)) {
         const result = v.enterNode(node, context);
         if (result?.skipChildren) {
@@ -117,7 +115,7 @@ export function walkWithVisitors(rootNode, visitors, langId, options = {}) {
 
     // exitNode hooks
     for (let i = 0; i < visitors.length; i++) {
-      const v = visitors[i];
+      const v = visitors[i]!;
       if (v.exitNode && !isSkipped(i, depth)) {
         v.exitNode(node, context);
       }
@@ -133,18 +131,18 @@ export function walkWithVisitors(rootNode, visitors, langId, options = {}) {
     // Function boundary: exit
     if (isFunction) {
       for (let i = 0; i < visitors.length; i++) {
-        const v = visitors[i];
+        const v = visitors[i]!;
         if (v.exitFunction && !isSkipped(i, depth)) {
           v.exitFunction(node, funcName, context);
         }
       }
       scopeStack.pop();
       context.currentFunction =
-        scopeStack.length > 0 ? scopeStack[scopeStack.length - 1].funcNode : null;
+        scopeStack.length > 0 ? scopeStack[scopeStack.length - 1]!.funcNode : null;
     }
   }
 
-  function isSkipped(visitorIndex, currentDepth) {
+  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
@@ -154,7 +152,7 @@ export function walkWithVisitors(rootNode, visitors, langId, options = {}) {
   walk(rootNode, 0);
 
   // Collect results
-  const results = {};
+  const results: WalkResults = {};
   for (const v of visitors) {
     results[v.name] = v.finish ? v.finish() : undefined;
   }

package/src/ast-analysis/visitors/{ast-store-visitor.js → ast-store-visitor.ts}

@@ -1,30 +1,42 @@
-/**
- * Visitor: Extract new/throw/await/string/regex AST nodes during a shared walk.
- *
- * Replaces the standalone walkAst() DFS in ast.js with a visitor that plugs
- * into the unified walkWithVisitors framework.
- */
-
-/** Max length for the `text` column. */
+import type {
+  Definition,
+  EnterNodeResult,
+  TreeSitterNode,
+  Visitor,
+  VisitorContext,
+} from '../../types.js';
+
 const TEXT_MAX = 200;
 
-function truncate(s, max = TEXT_MAX) {
+interface AstStoreRow {
+  file: string;
+  line: number;
+  kind: string;
+  name: string | null | undefined;
+  text: string | null;
+  receiver: null;
+  parentNodeId: number | null;
+}
+
+function truncate(s: string | null | undefined, max: number = TEXT_MAX): string | null {
   if (!s) return null;
   return s.length <= max ? s : `${s.slice(0, max - 1)}\u2026`;
 }
 
-function extractNewName(node) {
+function extractNewName(node: TreeSitterNode): string {
   for (let i = 0; i < node.childCount; i++) {
     const child = node.child(i);
+    if (!child) continue;
     if (child.type === 'identifier') return child.text;
     if (child.type === 'member_expression') return child.text;
   }
   return node.text?.split('(')[0]?.replace('new ', '').trim() || '?';
 }
 
-function extractExpressionText(node) {
+function extractExpressionText(node: TreeSitterNode): string | null {
   for (let i = 0; i < node.childCount; i++) {
     const child = node.child(i);
+    if (!child) continue;
     if (child.type !== 'throw' && child.type !== 'await') {
       return truncate(child.text);
     }
@@ -32,10 +44,11 @@ function extractExpressionText(node) {
   return truncate(node.text);
 }
 
-function extractName(kind, node) {
+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');
@@ -48,6 +61,7 @@ function extractName(kind, node) {
   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] || '?';
@@ -61,25 +75,20 @@ function extractName(kind, node) {
   return truncate(node.text);
 }
 
-/**
- * Create an AST-store visitor for use with walkWithVisitors.
- *
- * @param {object} astTypeMap - node type → kind mapping (e.g. JS_TS_AST_TYPES)
- * @param {object[]} defs     - symbol definitions for parent lookup
- * @param {string} relPath    - relative file path
- * @param {Map} nodeIdMap     - def key → node ID mapping
- * @returns {Visitor}
- */
-export function createAstStoreVisitor(astTypeMap, defs, relPath, nodeIdMap) {
-  const rows = [];
-  // Track which nodes we've already matched to avoid duplicates in recursive walk
-  const matched = new Set();
-
-  function findParentDef(line) {
-    let best = null;
+export function createAstStoreVisitor(
+  astTypeMap: Record<string, string>,
+  defs: Definition[],
+  relPath: string,
+  nodeIdMap: Map<string, number>,
+): Visitor {
+  const rows: AstStoreRow[] = [];
+  const matched = new Set<number>();
+
+  function findParentDef(line: number): Definition | null {
+    let best: Definition | null = null;
     for (const def of defs) {
       if (def.line <= line && (def.endLine == null || def.endLine >= line)) {
-        if (!best || def.endLine - def.line < best.endLine - best.line) {
+        if (!best || (def.endLine ?? 0) - def.line < (best.endLine ?? 0) - best.line) {
           best = def;
         }
       }
@@ -87,7 +96,7 @@ export function createAstStoreVisitor(astTypeMap, defs, relPath, nodeIdMap) {
     return best;
   }
 
-  function resolveParentNodeId(line) {
+  function resolveParentNodeId(line: number): number | null {
     const parentDef = findParentDef(line);
     if (!parentDef) return null;
     return nodeIdMap.get(`${parentDef.name}|${parentDef.kind}|${parentDef.line}`) || null;
@@ -96,15 +105,15 @@ export function createAstStoreVisitor(astTypeMap, defs, relPath, nodeIdMap) {
   return {
     name: 'ast-store',
 
-    enterNode(node, _context) {
+    enterNode(node: TreeSitterNode, _context: VisitorContext): EnterNodeResult | undefined {
       if (matched.has(node.id)) return;
 
       const kind = astTypeMap[node.type];
       if (!kind) return;
 
       const line = node.startPosition.row + 1;
-      let name;
-      let text = null;
+      let name: string | null | undefined;
+      let text: string | null = null;
 
       if (kind === 'new') {
         name = extractNewName(node);
@@ -117,7 +126,7 @@ export function createAstStoreVisitor(astTypeMap, defs, relPath, nodeIdMap) {
         text = extractExpressionText(node);
       } else if (kind === 'string') {
         const content = node.text?.replace(/^['"`]|['"`]$/g, '') || '';
-        if (content.length < 2) return; // skip trivial strings, walker still descends
+        if (content.length < 2) return;
         name = truncate(content, 100);
         text = truncate(node.text);
       } else if (kind === 'regex') {
@@ -137,13 +146,12 @@ export function createAstStoreVisitor(astTypeMap, defs, relPath, nodeIdMap) {
 
       matched.add(node.id);
 
-      // Don't recurse into children for new/throw/await (same as original walkAst)
       if (kind !== 'string' && kind !== 'regex') {
         return { skipChildren: true };
       }
     },
 
-    finish() {
+    finish(): AstStoreRow[] {
       return rows;
     },
   };