@optave/codegraph 3.3.1 → 3.4.1

package/src/extractors/{ruby.js → ruby.ts}

@@ -1,22 +1,30 @@
+import type {
+  Call,
+  ExtractorOutput,
+  SubDeclaration,
+  TreeSitterNode,
+  TreeSitterTree,
+} from '../types.js';
 import { findChild, nodeEndLine } from './helpers.js';
 
 /**
  * Extract symbols from Ruby files.
  */
-export function extractRubySymbols(tree, _filePath) {
-  const ctx = {
+export function extractRubySymbols(tree: TreeSitterTree, _filePath: string): ExtractorOutput {
+  const ctx: ExtractorOutput = {
     definitions: [],
     calls: [],
     imports: [],
     classes: [],
     exports: [],
-  };
+    typeMap: new Map(),
+  } as ExtractorOutput;
 
   walkRubyNode(tree.rootNode, ctx);
   return ctx;
 }
 
-function walkRubyNode(node, ctx) {
+function walkRubyNode(node: TreeSitterNode, ctx: ExtractorOutput): void {
   switch (node.type) {
     case 'class':
       handleRubyClass(node, ctx);
@@ -38,12 +46,15 @@ function walkRubyNode(node, ctx) {
       break;
   }
 
-  for (let i = 0; i < node.childCount; i++) walkRubyNode(node.child(i), ctx);
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) walkRubyNode(child, ctx);
+  }
 }
 
 // ── Walk-path per-node-type handlers ────────────────────────────────────────
 
-function handleRubyClass(node, ctx) {
+function handleRubyClass(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const nameNode = node.childForFieldName('name');
   if (!nameNode) return;
   const classChildren = extractRubyClassChildren(node);
@@ -83,7 +94,7 @@ function handleRubyClass(node, ctx) {
   }
 }
 
-function handleRubyModule(node, ctx) {
+function handleRubyModule(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const nameNode = node.childForFieldName('name');
   if (!nameNode) return;
   const moduleChildren = extractRubyBodyConstants(node);
@@ -96,7 +107,7 @@ function handleRubyModule(node, ctx) {
   });
 }
 
-function handleRubyMethod(node, ctx) {
+function handleRubyMethod(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const nameNode = node.childForFieldName('name');
   if (!nameNode) return;
   const parentClass = findRubyParentClass(node);
@@ -111,7 +122,7 @@ function handleRubyMethod(node, ctx) {
   });
 }
 
-function handleRubySingletonMethod(node, ctx) {
+function handleRubySingletonMethod(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const nameNode = node.childForFieldName('name');
   if (!nameNode) return;
   const parentClass = findRubyParentClass(node);
@@ -126,7 +137,7 @@ function handleRubySingletonMethod(node, ctx) {
   });
 }
 
-function handleRubyAssignment(node, ctx) {
+function handleRubyAssignment(node: TreeSitterNode, ctx: ExtractorOutput): void {
   if (node.parent && node.parent.type === 'program') {
     const left = node.childForFieldName('left');
     if (left && left.type === 'constant') {
@@ -140,7 +151,7 @@ function handleRubyAssignment(node, ctx) {
   }
 }
 
-function handleRubyCall(node, ctx) {
+function handleRubyCall(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const methodNode = node.childForFieldName('method');
   if (!methodNode) return;
   if (methodNode.text === 'require' || methodNode.text === 'require_relative') {
@@ -153,13 +164,13 @@ function handleRubyCall(node, ctx) {
     handleRubyModuleInclusion(node, methodNode, ctx);
   } else {
     const recv = node.childForFieldName('receiver');
-    const call = { name: methodNode.text, line: node.startPosition.row + 1 };
+    const call: Call = { name: methodNode.text, line: node.startPosition.row + 1 };
     if (recv) call.receiver = recv.text;
     ctx.calls.push(call);
   }
 }
 
-function handleRubyRequire(node, ctx) {
+function handleRubyRequire(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const args = node.childForFieldName('arguments');
   if (!args) return;
   for (let i = 0; i < args.childCount; i++) {
@@ -168,7 +179,7 @@ function handleRubyRequire(node, ctx) {
       const strContent = arg.text.replace(/^['"]|['"]$/g, '');
       ctx.imports.push({
         source: strContent,
-        names: [strContent.split('/').pop()],
+        names: [strContent.split('/').pop() ?? strContent],
         line: node.startPosition.row + 1,
         rubyRequire: true,
       });
@@ -179,7 +190,7 @@ function handleRubyRequire(node, ctx) {
       if (content) {
         ctx.imports.push({
           source: content.text,
-          names: [content.text.split('/').pop()],
+          names: [content.text.split('/').pop() ?? content.text],
           line: node.startPosition.row + 1,
           rubyRequire: true,
         });
@@ -189,7 +200,11 @@ function handleRubyRequire(node, ctx) {
   }
 }
 
-function handleRubyModuleInclusion(node, _methodNode, ctx) {
+function handleRubyModuleInclusion(
+  node: TreeSitterNode,
+  _methodNode: TreeSitterNode,
+  ctx: ExtractorOutput,
+): void {
   const parentClass = findRubyParentClass(node);
   if (!parentClass) return;
   const args = node.childForFieldName('arguments');
@@ -206,7 +221,7 @@ function handleRubyModuleInclusion(node, _methodNode, ctx) {
   }
 }
 
-function findRubyParentClass(node) {
+function findRubyParentClass(node: TreeSitterNode): string | null {
   let current = node.parent;
   while (current) {
     if (current.type === 'class' || current.type === 'module') {
@@ -220,7 +235,7 @@ function findRubyParentClass(node) {
 
 // ── Child extraction helpers ────────────────────────────────────────────────
 
-const RUBY_PARAM_TYPES = new Set([
+const RUBY_PARAM_TYPES: Set<string> = new Set([
   'identifier',
   'optional_parameter',
   'splat_parameter',
@@ -229,15 +244,15 @@ const RUBY_PARAM_TYPES = new Set([
   'keyword_parameter',
 ]);
 
-function extractRubyParameters(methodNode) {
-  const params = [];
+function extractRubyParameters(methodNode: TreeSitterNode): SubDeclaration[] {
+  const params: SubDeclaration[] = [];
   const paramList =
     methodNode.childForFieldName('parameters') || findChild(methodNode, 'method_parameters');
   if (!paramList) return params;
   for (let i = 0; i < paramList.childCount; i++) {
     const param = paramList.child(i);
     if (!param || !RUBY_PARAM_TYPES.has(param.type)) continue;
-    let name;
+    let name: string;
     if (param.type === 'identifier') {
       name = param.text;
     } else {
@@ -250,8 +265,8 @@ function extractRubyParameters(methodNode) {
   return params;
 }
 
-function extractRubyBodyConstants(containerNode) {
-  const children = [];
+function extractRubyBodyConstants(containerNode: TreeSitterNode): SubDeclaration[] {
+  const children: SubDeclaration[] = [];
   const body = containerNode.childForFieldName('body') || findChild(containerNode, 'body');
   if (!body) return children;
   for (let i = 0; i < body.childCount; i++) {
@@ -265,8 +280,8 @@ function extractRubyBodyConstants(containerNode) {
   return children;
 }
 
-function extractRubyClassChildren(classNode) {
-  const children = [];
+function extractRubyClassChildren(classNode: TreeSitterNode): SubDeclaration[] {
+  const children: SubDeclaration[] = [];
   const body = classNode.childForFieldName('body') || findChild(classNode, 'body');
   if (!body) return children;
   for (let i = 0; i < body.childCount; i++) {

package/src/extractors/{rust.js → rust.ts}

@@ -1,10 +1,17 @@
-import { findChild, nodeEndLine, rustVisibility } from './helpers.js';
+import type {
+  Call,
+  ExtractorOutput,
+  SubDeclaration,
+  TreeSitterNode,
+  TreeSitterTree,
+} from '../types.js';
+import { findChild, MAX_WALK_DEPTH, nodeEndLine, rustVisibility } from './helpers.js';
 
 /**
  * Extract symbols from Rust files.
  */
-export function extractRustSymbols(tree, _filePath) {
-  const ctx = {
+export function extractRustSymbols(tree: TreeSitterTree, _filePath: string): ExtractorOutput {
+  const ctx: ExtractorOutput = {
     definitions: [],
     calls: [],
     imports: [],
@@ -18,7 +25,7 @@ export function extractRustSymbols(tree, _filePath) {
   return ctx;
 }
 
-function walkRustNode(node, ctx) {
+function walkRustNode(node: TreeSitterNode, ctx: ExtractorOutput): void {
   switch (node.type) {
     case 'function_item':
       handleRustFuncItem(node, ctx);
@@ -49,12 +56,15 @@ function walkRustNode(node, ctx) {
       break;
   }
 
-  for (let i = 0; i < node.childCount; i++) walkRustNode(node.child(i), ctx);
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) walkRustNode(child, ctx);
+  }
 }
 
 // ── Walk-path per-node-type handlers ────────────────────────────────────────
 
-function handleRustFuncItem(node, ctx) {
+function handleRustFuncItem(node: TreeSitterNode, ctx: ExtractorOutput): void {
   // Skip default-impl functions already emitted by handleRustTraitItem
   if (node.parent?.parent?.type === 'trait_item') return;
   const nameNode = node.childForFieldName('name');
@@ -73,7 +83,7 @@ function handleRustFuncItem(node, ctx) {
   });
 }
 
-function handleRustStructItem(node, ctx) {
+function handleRustStructItem(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const nameNode = node.childForFieldName('name');
   if (!nameNode) return;
   const fields = extractStructFields(node);
@@ -87,7 +97,7 @@ function handleRustStructItem(node, ctx) {
   });
 }
 
-function handleRustEnumItem(node, ctx) {
+function handleRustEnumItem(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const nameNode = node.childForFieldName('name');
   if (!nameNode) return;
   const variants = extractEnumVariants(node);
@@ -100,7 +110,7 @@ function handleRustEnumItem(node, ctx) {
   });
 }
 
-function handleRustConstItem(node, ctx) {
+function handleRustConstItem(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const nameNode = node.childForFieldName('name');
   if (!nameNode) return;
   ctx.definitions.push({
@@ -111,7 +121,7 @@ function handleRustConstItem(node, ctx) {
   });
 }
 
-function handleRustTraitItem(node, ctx) {
+function handleRustTraitItem(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const nameNode = node.childForFieldName('name');
   if (!nameNode) return;
   ctx.definitions.push({
@@ -139,7 +149,7 @@ function handleRustTraitItem(node, ctx) {
   }
 }
 
-function handleRustImplItem(node, ctx) {
+function handleRustImplItem(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const typeNode = node.childForFieldName('type');
   const traitNode = node.childForFieldName('trait');
   if (typeNode && traitNode) {
@@ -151,7 +161,7 @@ function handleRustImplItem(node, ctx) {
   }
 }
 
-function handleRustUseDecl(node, ctx) {
+function handleRustUseDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const argNode = node.child(1);
   if (!argNode) return;
   const usePaths = extractRustUsePath(argNode);
@@ -165,7 +175,7 @@ function handleRustUseDecl(node, ctx) {
   }
 }
 
-function handleRustCallExpr(node, ctx) {
+function handleRustCallExpr(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const fn = node.childForFieldName('function');
   if (!fn) return;
   if (fn.type === 'identifier') {
@@ -174,7 +184,7 @@ function handleRustCallExpr(node, ctx) {
     const field = fn.childForFieldName('field');
     if (field) {
       const value = fn.childForFieldName('value');
-      const call = { name: field.text, line: node.startPosition.row + 1 };
+      const call: Call = { name: field.text, line: node.startPosition.row + 1 };
       if (value) call.receiver = value.text;
       ctx.calls.push(call);
     }
@@ -182,21 +192,21 @@ function handleRustCallExpr(node, ctx) {
     const name = fn.childForFieldName('name');
     if (name) {
       const path = fn.childForFieldName('path');
-      const call = { name: name.text, line: node.startPosition.row + 1 };
+      const call: Call = { name: name.text, line: node.startPosition.row + 1 };
       if (path) call.receiver = path.text;
       ctx.calls.push(call);
     }
   }
 }
 
-function handleRustMacroInvocation(node, ctx) {
+function handleRustMacroInvocation(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const macroNode = node.child(0);
   if (macroNode) {
     ctx.calls.push({ name: `${macroNode.text}!`, line: node.startPosition.row + 1 });
   }
 }
 
-function findCurrentImpl(node) {
+function findCurrentImpl(node: TreeSitterNode): string | null {
   let current = node.parent;
   while (current) {
     if (current.type === 'impl_item') {
@@ -210,8 +220,8 @@ function findCurrentImpl(node) {
 
 // ── Child extraction helpers ────────────────────────────────────────────────
 
-function extractRustParameters(paramListNode) {
-  const params = [];
+function extractRustParameters(paramListNode: TreeSitterNode | null): SubDeclaration[] {
+  const params: SubDeclaration[] = [];
   if (!paramListNode) return params;
   for (let i = 0; i < paramListNode.childCount; i++) {
     const param = paramListNode.child(i);
@@ -228,8 +238,8 @@ function extractRustParameters(paramListNode) {
   return params;
 }
 
-function extractStructFields(structNode) {
-  const fields = [];
+function extractStructFields(structNode: TreeSitterNode): SubDeclaration[] {
+  const fields: SubDeclaration[] = [];
   const fieldList =
     structNode.childForFieldName('body') || findChild(structNode, 'field_declaration_list');
   if (!fieldList) return fields;
@@ -244,8 +254,8 @@ function extractStructFields(structNode) {
   return fields;
 }
 
-function extractEnumVariants(enumNode) {
-  const variants = [];
+function extractEnumVariants(enumNode: TreeSitterNode): SubDeclaration[] {
+  const variants: SubDeclaration[] = [];
   const body = enumNode.childForFieldName('body') || findChild(enumNode, 'enum_variant_list');
   if (!body) return variants;
   for (let i = 0; i < body.childCount; i++) {
@@ -259,12 +269,12 @@ function extractEnumVariants(enumNode) {
   return variants;
 }
 
-function extractRustTypeMap(node, ctx) {
+function extractRustTypeMap(node: TreeSitterNode, ctx: ExtractorOutput): void {
   extractRustTypeMapDepth(node, ctx, 0);
 }
 
-function extractRustTypeMapDepth(node, ctx, depth) {
-  if (depth >= 200) return;
+function extractRustTypeMapDepth(node: TreeSitterNode, ctx: ExtractorOutput, depth: number): void {
+  if (depth >= MAX_WALK_DEPTH) return;
 
   // let x: MyType = ...
   if (node.type === 'let_declaration') {
@@ -272,7 +282,7 @@ function extractRustTypeMapDepth(node, ctx, depth) {
     const typeNode = node.childForFieldName('type');
     if (pattern && pattern.type === 'identifier' && typeNode) {
       const typeName = extractRustTypeName(typeNode);
-      if (typeName) ctx.typeMap.set(pattern.text, { type: typeName, confidence: 0.9 });
+      if (typeName) ctx.typeMap?.set(pattern.text, { type: typeName, confidence: 0.9 });
     }
   }
 
@@ -284,7 +294,7 @@ function extractRustTypeMapDepth(node, ctx, depth) {
       const name = pattern.type === 'identifier' ? pattern.text : null;
       if (name && name !== 'self' && name !== '&self' && name !== '&mut self') {
         const typeName = extractRustTypeName(typeNode);
-        if (typeName) ctx.typeMap.set(name, { type: typeName, confidence: 0.9 });
+        if (typeName) ctx.typeMap?.set(name, { type: typeName, confidence: 0.9 });
       }
     }
   }
@@ -295,7 +305,7 @@ function extractRustTypeMapDepth(node, ctx, depth) {
   }
 }
 
-function extractRustTypeName(typeNode) {
+function extractRustTypeName(typeNode: TreeSitterNode): string | null {
   if (!typeNode) return null;
   const t = typeNode.type;
   if (t === 'type_identifier' || t === 'identifier') return typeNode.text;
@@ -317,11 +327,11 @@ function extractRustTypeName(typeNode) {
   return null;
 }
 
-function extractRustUsePath(node) {
+function extractRustUsePath(node: TreeSitterNode | null): { source: string; names: string[] }[] {
   if (!node) return [];
 
   if (node.type === 'use_list') {
-    const results = [];
+    const results: { source: string; names: string[] }[] = [];
     for (let i = 0; i < node.childCount; i++) {
       results.push(...extractRustUsePath(node.child(i)));
     }
@@ -333,7 +343,7 @@ function extractRustUsePath(node) {
     const listNode = node.childForFieldName('list');
     const prefix = pathNode ? pathNode.text : '';
     if (listNode) {
-      const names = [];
+      const names: string[] = [];
       for (let i = 0; i < listNode.childCount; i++) {
         const child = listNode.child(i);
         if (
@@ -364,7 +374,7 @@ function extractRustUsePath(node) {
 
   if (node.type === 'scoped_identifier' || node.type === 'identifier') {
     const text = node.text;
-    const lastName = text.split('::').pop();
+    const lastName = text.split('::').pop() ?? text;
     return [{ source: text, names: [lastName] }];
   }