@optave/codegraph 3.3.0 → 3.4.0

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

@@ -1,7 +1,14 @@
+import type {
+  Call,
+  ExtractorOutput,
+  SubDeclaration,
+  TreeSitterNode,
+  TreeSitterTree,
+} from '../types.js';
 import { extractModifierVisibility, findChild, nodeEndLine } from './helpers.js';
 
-function extractPhpParameters(fnNode) {
-  const params = [];
+function extractPhpParameters(fnNode: TreeSitterNode): SubDeclaration[] {
+  const params: SubDeclaration[] = [];
   const paramsNode =
     fnNode.childForFieldName('parameters') || findChild(fnNode, 'formal_parameters');
   if (!paramsNode) return params;
@@ -18,8 +25,8 @@ function extractPhpParameters(fnNode) {
   return params;
 }
 
-function extractPhpClassChildren(classNode) {
-  const children = [];
+function extractPhpClassChildren(classNode: TreeSitterNode): SubDeclaration[] {
+  const children: SubDeclaration[] = [];
   const body = classNode.childForFieldName('body') || findChild(classNode, 'declaration_list');
   if (!body) return children;
   for (let i = 0; i < body.childCount; i++) {
@@ -57,8 +64,8 @@ function extractPhpClassChildren(classNode) {
   return children;
 }
 
-function extractPhpEnumCases(enumNode) {
-  const children = [];
+function extractPhpEnumCases(enumNode: TreeSitterNode): SubDeclaration[] {
+  const children: SubDeclaration[] = [];
   const body = enumNode.childForFieldName('body') || findChild(enumNode, 'enum_declaration_list');
   if (!body) return children;
   for (let i = 0; i < body.childCount; i++) {
@@ -75,8 +82,8 @@ function extractPhpEnumCases(enumNode) {
 /**
  * Extract symbols from PHP files.
  */
-export function extractPHPSymbols(tree, _filePath) {
-  const ctx = {
+export function extractPHPSymbols(tree: TreeSitterTree, _filePath: string): ExtractorOutput {
+  const ctx: ExtractorOutput = {
     definitions: [],
     calls: [],
     imports: [],
@@ -90,7 +97,7 @@ export function extractPHPSymbols(tree, _filePath) {
   return ctx;
 }
 
-function walkPhpNode(node, ctx) {
+function walkPhpNode(node: TreeSitterNode, ctx: ExtractorOutput): void {
   switch (node.type) {
     case 'function_definition':
       handlePhpFuncDef(node, ctx);
@@ -127,12 +134,15 @@ function walkPhpNode(node, ctx) {
       break;
   }
 
-  for (let i = 0; i < node.childCount; i++) walkPhpNode(node.child(i), ctx);
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) walkPhpNode(child, ctx);
+  }
 }
 
 // ── Walk-path per-node-type handlers ────────────────────────────────────────
 
-function handlePhpFuncDef(node, ctx) {
+function handlePhpFuncDef(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const nameNode = node.childForFieldName('name');
   if (!nameNode) return;
   const params = extractPhpParameters(node);
@@ -145,7 +155,7 @@ function handlePhpFuncDef(node, ctx) {
   });
 }
 
-function handlePhpClassDecl(node, ctx) {
+function handlePhpClassDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const nameNode = node.childForFieldName('name');
   if (!nameNode) return;
   const classChildren = extractPhpClassChildren(node);
@@ -185,7 +195,7 @@ function handlePhpClassDecl(node, ctx) {
   }
 }
 
-function handlePhpInterfaceDecl(node, ctx) {
+function handlePhpInterfaceDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const nameNode = node.childForFieldName('name');
   if (!nameNode) return;
   ctx.definitions.push({
@@ -213,7 +223,7 @@ function handlePhpInterfaceDecl(node, ctx) {
   }
 }
 
-function handlePhpTraitDecl(node, ctx) {
+function handlePhpTraitDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const nameNode = node.childForFieldName('name');
   if (!nameNode) return;
   ctx.definitions.push({
@@ -224,7 +234,7 @@ function handlePhpTraitDecl(node, ctx) {
   });
 }
 
-function handlePhpEnumDecl(node, ctx) {
+function handlePhpEnumDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const nameNode = node.childForFieldName('name');
   if (!nameNode) return;
   const enumChildren = extractPhpEnumCases(node);
@@ -237,7 +247,7 @@ function handlePhpEnumDecl(node, ctx) {
   });
 }
 
-function handlePhpMethodDecl(node, ctx) {
+function handlePhpMethodDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
   // Skip interface methods already emitted by handlePhpInterfaceDecl
   if (node.parent?.parent?.type === 'interface_declaration') return;
   const nameNode = node.childForFieldName('name');
@@ -255,14 +265,14 @@ function handlePhpMethodDecl(node, ctx) {
   });
 }
 
-function handlePhpNamespaceUse(node, ctx) {
+function handlePhpNamespaceUse(node: TreeSitterNode, ctx: ExtractorOutput): void {
   for (let i = 0; i < node.childCount; i++) {
     const child = node.child(i);
     if (child && child.type === 'namespace_use_clause') {
       const nameNode = findChild(child, 'qualified_name') || findChild(child, 'name');
       if (nameNode) {
         const fullPath = nameNode.text;
-        const lastName = fullPath.split('\\').pop();
+        const lastName = fullPath.split('\\').pop() ?? fullPath;
         const alias = child.childForFieldName('alias');
         ctx.imports.push({
           source: fullPath,
@@ -274,7 +284,7 @@ function handlePhpNamespaceUse(node, ctx) {
     }
     if (child && (child.type === 'qualified_name' || child.type === 'name')) {
       const fullPath = child.text;
-      const lastName = fullPath.split('\\').pop();
+      const lastName = fullPath.split('\\').pop() ?? fullPath;
       ctx.imports.push({
         source: fullPath,
         names: [lastName],
@@ -285,48 +295,51 @@ function handlePhpNamespaceUse(node, ctx) {
   }
 }
 
-function handlePhpFuncCall(node, ctx) {
+function handlePhpFuncCall(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const fn = node.childForFieldName('function') || node.child(0);
   if (!fn) return;
   if (fn.type === 'name' || fn.type === 'identifier') {
     ctx.calls.push({ name: fn.text, line: node.startPosition.row + 1 });
   } else if (fn.type === 'qualified_name') {
     const parts = fn.text.split('\\');
-    ctx.calls.push({ name: parts[parts.length - 1], line: node.startPosition.row + 1 });
+    ctx.calls.push({ name: parts[parts.length - 1] ?? fn.text, line: node.startPosition.row + 1 });
   }
 }
 
-function handlePhpMemberCall(node, ctx) {
+function handlePhpMemberCall(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const name = node.childForFieldName('name');
   if (!name) return;
   const obj = node.childForFieldName('object');
-  const call = { name: name.text, line: node.startPosition.row + 1 };
+  const call: Call = { name: name.text, line: node.startPosition.row + 1 };
   if (obj) call.receiver = obj.text;
   ctx.calls.push(call);
 }
 
-function handlePhpScopedCall(node, ctx) {
+function handlePhpScopedCall(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const name = node.childForFieldName('name');
   if (!name) return;
   const scope = node.childForFieldName('scope');
-  const call = { name: name.text, line: node.startPosition.row + 1 };
+  const call: Call = { name: name.text, line: node.startPosition.row + 1 };
   if (scope) call.receiver = scope.text;
   ctx.calls.push(call);
 }
 
-function handlePhpObjectCreation(node, ctx) {
+function handlePhpObjectCreation(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const classNode = node.child(1);
   if (classNode && (classNode.type === 'name' || classNode.type === 'qualified_name')) {
     const parts = classNode.text.split('\\');
-    ctx.calls.push({ name: parts[parts.length - 1], line: node.startPosition.row + 1 });
+    ctx.calls.push({
+      name: parts[parts.length - 1] ?? classNode.text,
+      line: node.startPosition.row + 1,
+    });
   }
 }
 
-function extractPhpTypeMap(node, ctx) {
+function extractPhpTypeMap(node: TreeSitterNode, ctx: ExtractorOutput): void {
   extractPhpTypeMapDepth(node, ctx, 0);
 }
 
-function extractPhpTypeMapDepth(node, ctx, depth) {
+function extractPhpTypeMapDepth(node: TreeSitterNode, ctx: ExtractorOutput, depth: number): void {
   if (depth >= 200) return;
 
   // Function/method parameters with type hints
@@ -339,7 +352,7 @@ function extractPhpTypeMapDepth(node, ctx, depth) {
     const nameNode = node.childForFieldName('name') || findChild(node, 'variable_name');
     if (typeNode && nameNode) {
       const typeName = extractPhpTypeName(typeNode);
-      if (typeName) ctx.typeMap.set(nameNode.text, { type: typeName, confidence: 0.9 });
+      if (typeName) ctx.typeMap?.set(nameNode.text, { type: typeName, confidence: 0.9 });
     }
   }
 
@@ -349,7 +362,7 @@ function extractPhpTypeMapDepth(node, ctx, depth) {
   }
 }
 
-function extractPhpTypeName(typeNode) {
+function extractPhpTypeName(typeNode: TreeSitterNode): string | null {
   if (!typeNode) return null;
   const t = typeNode.type;
   if (t === 'named_type' || t === 'name' || t === 'qualified_name') return typeNode.text;
@@ -363,7 +376,7 @@ function extractPhpTypeName(typeNode) {
   return null;
 }
 
-function findPHPParentClass(node) {
+function findPHPParentClass(node: TreeSitterNode): string | null {
   let current = node.parent;
   while (current) {
     if (

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

@@ -1,7 +1,15 @@
+import type {
+  Call,
+  ExtractorOutput,
+  SubDeclaration,
+  TreeSitterNode,
+  TreeSitterTree,
+  TypeMapEntry,
+} from '../types.js';
 import { findChild, nodeEndLine, pythonVisibility } from './helpers.js';
 
 /** Built-in globals that start with uppercase but are not user-defined types. */
-const BUILTIN_GLOBALS_PY = new Set([
+const BUILTIN_GLOBALS_PY: Set<string> = new Set([
   // Uppercase builtins that would false-positive on the factory heuristic
   'Exception',
   'BaseException',
@@ -47,8 +55,8 @@ const BUILTIN_GLOBALS_PY = new Set([
 /**
  * Extract symbols from Python files.
  */
-export function extractPythonSymbols(tree, _filePath) {
-  const ctx = {
+export function extractPythonSymbols(tree: TreeSitterTree, _filePath: string): ExtractorOutput {
+  const ctx: ExtractorOutput = {
     definitions: [],
     calls: [],
     imports: [],
@@ -62,7 +70,7 @@ export function extractPythonSymbols(tree, _filePath) {
   return ctx;
 }
 
-function walkPythonNode(node, ctx) {
+function walkPythonNode(node: TreeSitterNode, ctx: ExtractorOutput): void {
   switch (node.type) {
     case 'function_definition':
       handlePyFunctionDef(node, ctx);
@@ -71,7 +79,10 @@ function walkPythonNode(node, ctx) {
       handlePyClassDef(node, ctx);
       break;
     case 'decorated_definition':
-      for (let i = 0; i < node.childCount; i++) walkPythonNode(node.child(i), ctx);
+      for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (child) walkPythonNode(child, ctx);
+      }
       return;
     case 'call':
       handlePyCall(node, ctx);
@@ -87,15 +98,18 @@ function walkPythonNode(node, ctx) {
       break;
   }
 
-  for (let i = 0; i < node.childCount; i++) walkPythonNode(node.child(i), ctx);
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) walkPythonNode(child, ctx);
+  }
 }
 
 // ── Walk-path per-node-type handlers ────────────────────────────────────────
 
-function handlePyFunctionDef(node, ctx) {
+function handlePyFunctionDef(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const nameNode = node.childForFieldName('name');
   if (!nameNode) return;
-  const decorators = [];
+  const decorators: string[] = [];
   if (node.previousSibling && node.previousSibling.type === 'decorator') {
     decorators.push(node.previousSibling.text);
   }
@@ -114,7 +128,7 @@ function handlePyFunctionDef(node, ctx) {
   });
 }
 
-function handlePyClassDef(node, ctx) {
+function handlePyClassDef(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const nameNode = node.childForFieldName('name');
   if (!nameNode) return;
   const clsChildren = extractPythonClassProperties(node);
@@ -140,11 +154,11 @@ function handlePyClassDef(node, ctx) {
   }
 }
 
-function handlePyCall(node, ctx) {
+function handlePyCall(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const fn = node.childForFieldName('function');
   if (!fn) return;
-  let callName = null;
-  let receiver;
+  let callName: string | null = null;
+  let receiver: string | undefined;
   if (fn.type === 'identifier') callName = fn.text;
   else if (fn.type === 'attribute') {
     const attr = fn.childForFieldName('attribute');
@@ -153,14 +167,14 @@ function handlePyCall(node, ctx) {
     if (obj) receiver = obj.text;
   }
   if (callName) {
-    const call = { name: callName, line: node.startPosition.row + 1 };
+    const call: Call = { name: callName, line: node.startPosition.row + 1 };
     if (receiver) call.receiver = receiver;
     ctx.calls.push(call);
   }
 }
 
-function handlePyImport(node, ctx) {
-  const names = [];
+function handlePyImport(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const names: string[] = [];
   for (let i = 0; i < node.childCount; i++) {
     const child = node.child(i);
     if (child && (child.type === 'dotted_name' || child.type === 'aliased_import')) {
@@ -173,14 +187,14 @@ function handlePyImport(node, ctx) {
   }
   if (names.length > 0)
     ctx.imports.push({
-      source: names[0],
+      source: names[0] ?? '',
       names,
       line: node.startPosition.row + 1,
       pythonImport: true,
     });
 }
 
-function handlePyExpressionStmt(node, ctx) {
+function handlePyExpressionStmt(node: TreeSitterNode, ctx: ExtractorOutput): void {
   if (node.parent && node.parent.type === 'module') {
     const assignment = findChild(node, 'assignment');
     if (assignment) {
@@ -196,9 +210,9 @@ function handlePyExpressionStmt(node, ctx) {
   }
 }
 
-function handlePyImportFrom(node, ctx) {
+function handlePyImportFrom(node: TreeSitterNode, ctx: ExtractorOutput): void {
   let source = '';
-  const names = [];
+  const names: string[] = [];
   for (let i = 0; i < node.childCount; i++) {
     const child = node.child(i);
     if (!child) continue;
@@ -218,8 +232,8 @@ function handlePyImportFrom(node, ctx) {
 
 // ── Python-specific helpers ─────────────────────────────────────────────────
 
-function extractPythonParameters(fnNode) {
-  const params = [];
+function extractPythonParameters(fnNode: TreeSitterNode): SubDeclaration[] {
+  const params: SubDeclaration[] = [];
   const paramsNode = fnNode.childForFieldName('parameters') || findChild(fnNode, 'parameters');
   if (!paramsNode) return params;
   for (let i = 0; i < paramsNode.childCount; i++) {
@@ -254,9 +268,9 @@ function extractPythonParameters(fnNode) {
   return params;
 }
 
-function extractPythonClassProperties(classNode) {
-  const props = [];
-  const seen = new Set();
+function extractPythonClassProperties(classNode: TreeSitterNode): SubDeclaration[] {
+  const props: SubDeclaration[] = [];
+  const seen = new Set<string>();
   const body = classNode.childForFieldName('body') || findChild(classNode, 'block');
   if (!body) return props;
 
@@ -308,7 +322,7 @@ function extractPythonClassProperties(classNode) {
   return props;
 }
 
-function walkInitBody(bodyNode, seen, props) {
+function walkInitBody(bodyNode: TreeSitterNode, seen: Set<string>, props: SubDeclaration[]): void {
   for (let i = 0; i < bodyNode.childCount; i++) {
     const stmt = bodyNode.child(i);
     if (!stmt || stmt.type !== 'expression_statement') continue;
@@ -330,18 +344,27 @@ function walkInitBody(bodyNode, seen, props) {
   }
 }
 
-function extractPythonTypeMap(node, ctx) {
+function extractPythonTypeMap(node: TreeSitterNode, ctx: ExtractorOutput): void {
   extractPythonTypeMapDepth(node, ctx, 0);
 }
 
-function setIfHigherPy(typeMap, name, type, confidence) {
+function setIfHigherPy(
+  typeMap: Map<string, TypeMapEntry>,
+  name: string,
+  type: string,
+  confidence: number,
+): void {
   const existing = typeMap.get(name);
   if (!existing || confidence > existing.confidence) {
     typeMap.set(name, { type, confidence });
   }
 }
 
-function extractPythonTypeMapDepth(node, ctx, depth) {
+function extractPythonTypeMapDepth(
+  node: TreeSitterNode,
+  ctx: ExtractorOutput,
+  depth: number,
+): void {
   if (depth >= 200) return;
 
   // typed_parameter: identifier : type (confidence 0.9)
@@ -351,7 +374,7 @@ function extractPythonTypeMapDepth(node, ctx, depth) {
     if (nameNode && nameNode.type === 'identifier' && typeNode) {
       const typeName = extractPythonTypeName(typeNode);
       if (typeName && nameNode.text !== 'self' && nameNode.text !== 'cls') {
-        setIfHigherPy(ctx.typeMap, nameNode.text, typeName, 0.9);
+        if (ctx.typeMap) setIfHigherPy(ctx.typeMap, nameNode.text, typeName, 0.9);
       }
     }
   }
@@ -363,7 +386,7 @@ function extractPythonTypeMapDepth(node, ctx, depth) {
     if (nameNode && nameNode.type === 'identifier' && typeNode) {
       const typeName = extractPythonTypeName(typeNode);
       if (typeName && nameNode.text !== 'self' && nameNode.text !== 'cls') {
-        setIfHigherPy(ctx.typeMap, nameNode.text, typeName, 0.9);
+        if (ctx.typeMap) setIfHigherPy(ctx.typeMap, nameNode.text, typeName, 0.9);
       }
     }
   }
@@ -377,16 +400,20 @@ function extractPythonTypeMapDepth(node, ctx, depth) {
       const fn = right.childForFieldName('function');
       if (fn && fn.type === 'identifier') {
         const name = fn.text;
-        if (name[0] !== name[0].toLowerCase()) {
-          setIfHigherPy(ctx.typeMap, left.text, name, 1.0);
+        if (name[0] && name[0] !== name[0].toLowerCase()) {
+          if (ctx.typeMap) setIfHigherPy(ctx.typeMap, left.text, name, 1.0);
         }
       }
       if (fn && fn.type === 'attribute') {
         const obj = fn.childForFieldName('object');
         if (obj && obj.type === 'identifier') {
           const objName = obj.text;
-          if (objName[0] !== objName[0].toLowerCase() && !BUILTIN_GLOBALS_PY.has(objName)) {
-            setIfHigherPy(ctx.typeMap, left.text, objName, 0.7);
+          if (
+            objName[0] &&
+            objName[0] !== objName[0].toLowerCase() &&
+            !BUILTIN_GLOBALS_PY.has(objName)
+          ) {
+            if (ctx.typeMap) setIfHigherPy(ctx.typeMap, left.text, objName, 0.7);
           }
         }
       }
@@ -399,7 +426,7 @@ function extractPythonTypeMapDepth(node, ctx, depth) {
   }
 }
 
-function extractPythonTypeName(typeNode) {
+function extractPythonTypeName(typeNode: TreeSitterNode): string | null {
   if (!typeNode) return null;
   const t = typeNode.type;
   if (t === 'identifier') return typeNode.text;
@@ -414,7 +441,7 @@ function extractPythonTypeName(typeNode) {
   return null;
 }
 
-function findPythonParentClass(node) {
+function findPythonParentClass(node: TreeSitterNode): string | null {
   let current = node.parent;
   while (current) {
     if (current.type === 'class_definition') {