@optave/codegraph 3.2.0 → 3.3.0

package/src/extractors/go.js

@@ -10,9 +10,11 @@ export function extractGoSymbols(tree, _filePath) {
     imports: [],
     classes: [],
     exports: [],
+    typeMap: new Map(),
   };
 
   walkGoNode(tree.rootNode, ctx);
+  extractGoTypeMap(tree.rootNode, ctx);
   return ctx;
 }
 
@@ -200,6 +202,145 @@ function handleGoCallExpr(node, ctx) {
   }
 }
 
+// ── Type map extraction ─────────────────────────────────────────────────────
+
+function extractGoTypeMap(node, ctx) {
+  extractGoTypeMapDepth(node, ctx, 0);
+}
+
+function setIfHigher(typeMap, name, type, confidence) {
+  const existing = typeMap.get(name);
+  if (!existing || confidence > existing.confidence) {
+    typeMap.set(name, { type, confidence });
+  }
+}
+
+function extractGoTypeMapDepth(node, ctx, depth) {
+  if (depth >= 200) return;
+
+  // var x MyType = ... or var x, y MyType → var_declaration > var_spec (confidence 0.9)
+  if (node.type === 'var_spec') {
+    const typeNode = node.childForFieldName('type');
+    if (typeNode) {
+      const typeName = extractGoTypeName(typeNode);
+      if (typeName) {
+        for (let i = 0; i < node.childCount; i++) {
+          const child = node.child(i);
+          if (child && child.type === 'identifier') {
+            setIfHigher(ctx.typeMap, child.text, typeName, 0.9);
+          }
+        }
+      }
+    }
+  }
+
+  // Function/method parameter types: parameter_declaration (confidence 0.9)
+  if (node.type === 'parameter_declaration') {
+    const typeNode = node.childForFieldName('type');
+    if (typeNode) {
+      const typeName = extractGoTypeName(typeNode);
+      if (typeName) {
+        for (let i = 0; i < node.childCount; i++) {
+          const child = node.child(i);
+          if (child && child.type === 'identifier') {
+            setIfHigher(ctx.typeMap, child.text, typeName, 0.9);
+          }
+        }
+      }
+    }
+  }
+
+  // short_var_declaration: x := Struct{}, x := &Struct{}, x := NewFoo()
+  // Handles multi-variable forms: x, y := A{}, B{}
+  if (node.type === 'short_var_declaration') {
+    const left = node.childForFieldName('left');
+    const right = node.childForFieldName('right');
+    if (left && right) {
+      const lefts =
+        left.type === 'expression_list'
+          ? Array.from({ length: left.childCount }, (_, i) => left.child(i)).filter(
+              (c) => c?.type === 'identifier',
+            )
+          : left.type === 'identifier'
+            ? [left]
+            : [];
+      const rights =
+        right.type === 'expression_list'
+          ? Array.from({ length: right.childCount }, (_, i) => right.child(i)).filter(
+              (c) => c?.isNamed,
+            )
+          : [right];
+
+      for (let idx = 0; idx < lefts.length; idx++) {
+        const varNode = lefts[idx];
+        const rhs = rights[idx];
+        if (!varNode || !rhs) continue;
+
+        // x := Struct{...} — composite literal (confidence 1.0)
+        if (rhs.type === 'composite_literal') {
+          const typeNode = rhs.childForFieldName('type');
+          if (typeNode) {
+            const typeName = extractGoTypeName(typeNode);
+            if (typeName) setIfHigher(ctx.typeMap, varNode.text, typeName, 1.0);
+          }
+        }
+        // x := &Struct{...} — address-of composite literal (confidence 1.0)
+        if (rhs.type === 'unary_expression') {
+          const operand = rhs.childForFieldName('operand');
+          if (operand && operand.type === 'composite_literal') {
+            const typeNode = operand.childForFieldName('type');
+            if (typeNode) {
+              const typeName = extractGoTypeName(typeNode);
+              if (typeName) setIfHigher(ctx.typeMap, varNode.text, typeName, 1.0);
+            }
+          }
+        }
+        // x := NewFoo() or x := pkg.NewFoo() — factory function (confidence 0.7)
+        if (rhs.type === 'call_expression') {
+          const fn = rhs.childForFieldName('function');
+          if (fn && fn.type === 'selector_expression') {
+            const field = fn.childForFieldName('field');
+            if (field?.text.startsWith('New')) {
+              const typeName = field.text.slice(3);
+              if (typeName) setIfHigher(ctx.typeMap, varNode.text, typeName, 0.7);
+            }
+          } else if (fn && fn.type === 'identifier' && fn.text.startsWith('New')) {
+            const typeName = fn.text.slice(3);
+            if (typeName) setIfHigher(ctx.typeMap, varNode.text, typeName, 0.7);
+          }
+        }
+      }
+    }
+  }
+
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) extractGoTypeMapDepth(child, ctx, depth + 1);
+  }
+}
+
+function extractGoTypeName(typeNode) {
+  if (!typeNode) return null;
+  const t = typeNode.type;
+  if (t === 'type_identifier' || t === 'identifier') return typeNode.text;
+  if (t === 'qualified_type') return typeNode.text;
+  // pointer type: *MyType → MyType
+  if (t === 'pointer_type') {
+    for (let i = 0; i < typeNode.childCount; i++) {
+      const child = typeNode.child(i);
+      if (child && (child.type === 'type_identifier' || child.type === 'identifier')) {
+        return child.text;
+      }
+    }
+  }
+  // generic type: MyType[T] → MyType
+  if (t === 'generic_type') {
+    const first = typeNode.child(0);
+    return first ? first.text : null;
+  }
+  return null;
+}
+
 // ── Child extraction helpers ────────────────────────────────────────────────
 
 function extractGoParameters(paramListNode) {

package/src/extractors/java.js

@@ -10,6 +10,7 @@ export function extractJavaSymbols(tree, _filePath) {
     imports: [],
     classes: [],
     exports: [],
+    typeMap: new Map(),
   };
 
   walkJavaNode(tree.rootNode, ctx);
@@ -42,6 +43,9 @@ function walkJavaNode(node, ctx) {
     case 'object_creation_expression':
       handleJavaObjectCreation(node, ctx);
       break;
+    case 'local_variable_declaration':
+      handleJavaLocalVarDecl(node, ctx);
+      break;
   }
 
   for (let i = 0; i < node.childCount; i++) walkJavaNode(node.child(i), ctx);
@@ -166,7 +170,7 @@ function handleJavaMethodDecl(node, ctx) {
   if (!nameNode) return;
   const parentClass = findJavaParentClass(node);
   const fullName = parentClass ? `${parentClass}.${nameNode.text}` : nameNode.text;
-  const params = extractJavaParameters(node.childForFieldName('parameters'));
+  const params = extractJavaParameters(node.childForFieldName('parameters'), ctx.typeMap);
   ctx.definitions.push({
     name: fullName,
     kind: 'method',
@@ -182,7 +186,7 @@ function handleJavaConstructorDecl(node, ctx) {
   if (!nameNode) return;
   const parentClass = findJavaParentClass(node);
   const fullName = parentClass ? `${parentClass}.${nameNode.text}` : nameNode.text;
-  const params = extractJavaParameters(node.childForFieldName('parameters'));
+  const params = extractJavaParameters(node.childForFieldName('parameters'), ctx.typeMap);
   ctx.definitions.push({
     name: fullName,
     kind: 'method',
@@ -222,6 +226,20 @@ function handleJavaMethodInvocation(node, ctx) {
   ctx.calls.push(call);
 }
 
+function handleJavaLocalVarDecl(node, ctx) {
+  const typeNode = node.childForFieldName('type');
+  if (!typeNode) return;
+  const typeName = typeNode.type === 'generic_type' ? typeNode.child(0)?.text : typeNode.text;
+  if (!typeName) return;
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child?.type === 'variable_declarator') {
+      const nameNode = child.childForFieldName('name');
+      if (nameNode) ctx.typeMap.set(nameNode.text, { type: typeName, confidence: 0.9 });
+    }
+  }
+}
+
 function handleJavaObjectCreation(node, ctx) {
   const typeNode = node.childForFieldName('type');
   if (!typeNode) return;
@@ -247,7 +265,7 @@ function findJavaParentClass(node) {
 
 // ── Child extraction helpers ────────────────────────────────────────────────
 
-function extractJavaParameters(paramListNode) {
+function extractJavaParameters(paramListNode, typeMap) {
   const params = [];
   if (!paramListNode) return params;
   for (let i = 0; i < paramListNode.childCount; i++) {
@@ -257,6 +275,14 @@ function extractJavaParameters(paramListNode) {
       const nameNode = param.childForFieldName('name');
       if (nameNode) {
         params.push({ name: nameNode.text, kind: 'parameter', line: param.startPosition.row + 1 });
+        if (typeMap) {
+          const typeNode = param.childForFieldName('type');
+          if (typeNode) {
+            const typeName =
+              typeNode.type === 'generic_type' ? typeNode.child(0)?.text : typeNode.text;
+            if (typeName) typeMap.set(nameNode.text, { type: typeName, confidence: 0.9 });
+          }
+        }
       }
     }
   }

package/src/extractors/javascript.js

@@ -1,6 +1,63 @@
 import { debug } from '../infrastructure/logger.js';
 import { findChild, nodeEndLine } from './helpers.js';
 
+/** Built-in globals that start with uppercase but are not user-defined types. */
+const BUILTIN_GLOBALS = new Set([
+  'Math',
+  'JSON',
+  'Promise',
+  'Array',
+  'Object',
+  'Date',
+  'Error',
+  'Symbol',
+  'Map',
+  'Set',
+  'RegExp',
+  'Number',
+  'String',
+  'Boolean',
+  'WeakMap',
+  'WeakSet',
+  'WeakRef',
+  'Proxy',
+  'Reflect',
+  'Intl',
+  'ArrayBuffer',
+  'SharedArrayBuffer',
+  'DataView',
+  'Atomics',
+  'BigInt',
+  'Float32Array',
+  'Float64Array',
+  'Int8Array',
+  'Int16Array',
+  'Int32Array',
+  'Uint8Array',
+  'Uint16Array',
+  'Uint32Array',
+  'Uint8ClampedArray',
+  'URL',
+  'URLSearchParams',
+  'TextEncoder',
+  'TextDecoder',
+  'AbortController',
+  'AbortSignal',
+  'Headers',
+  'Request',
+  'Response',
+  'FormData',
+  'Blob',
+  'File',
+  'ReadableStream',
+  'WritableStream',
+  'TransformStream',
+  'console',
+  'Buffer',
+  'EventEmitter',
+  'Stream',
+]);
+
 /**
  * Extract symbols from a JS/TS parsed AST.
  * When a compiled tree-sitter Query is provided (from parser.js),
@@ -19,6 +76,7 @@ function extractSymbolsQuery(tree, query) {
   const imports = [];
   const classes = [];
   const exps = [];
+  const typeMap = new Map();
 
   const matches = query.matches(tree.rootNode);
 
@@ -179,7 +237,10 @@ function extractSymbolsQuery(tree, query) {
   // Extract dynamic import() calls via targeted walk (query patterns don't match `import` function type)
   extractDynamicImportsWalk(tree.rootNode, imports);
 
-  return { definitions, calls, imports, classes, exports: exps };
+  // Extract typeMap from type annotations and new expressions
+  extractTypeMapWalk(tree.rootNode, typeMap);
+
+  return { definitions, calls, imports, classes, exports: exps, typeMap };
 }
 
 /**
@@ -326,9 +387,12 @@ function extractSymbolsWalk(tree) {
     imports: [],
     classes: [],
     exports: [],
+    typeMap: new Map(),
   };
 
   walkJavaScriptNode(tree.rootNode, ctx);
+  // Populate typeMap for variables and parameter type annotations
+  extractTypeMapWalk(tree.rootNode, ctx.typeMap);
   return ctx;
 }
 
@@ -472,6 +536,7 @@ function handleVariableDecl(node, ctx) {
     if (declarator && declarator.type === 'variable_declarator') {
       const nameN = declarator.childForFieldName('name');
       const valueN = declarator.childForFieldName('value');
+
       if (nameN && valueN) {
         const valType = valueN.type;
         if (
@@ -788,6 +853,103 @@ function extractImplementsFromNode(node) {
   return result;
 }
 
+// ── Type inference helpers ───────────────────────────────────────────────
+
+function extractSimpleTypeName(typeAnnotationNode) {
+  if (!typeAnnotationNode) return null;
+  for (let i = 0; i < typeAnnotationNode.childCount; i++) {
+    const child = typeAnnotationNode.child(i);
+    if (!child) continue;
+    const t = child.type;
+    if (t === 'type_identifier' || t === 'identifier') return child.text;
+    if (t === 'generic_type') return child.child(0)?.text || null;
+    if (t === 'parenthesized_type') return extractSimpleTypeName(child);
+    // Skip union, intersection, and array types — too ambiguous
+  }
+  return null;
+}
+
+function extractNewExprTypeName(newExprNode) {
+  if (!newExprNode || newExprNode.type !== 'new_expression') return null;
+  const ctor = newExprNode.childForFieldName('constructor') || newExprNode.child(1);
+  if (!ctor) return null;
+  if (ctor.type === 'identifier') return ctor.text;
+  if (ctor.type === 'member_expression') {
+    const prop = ctor.childForFieldName('property');
+    return prop ? prop.text : null;
+  }
+  return null;
+}
+
+/**
+ * Extract variable-to-type assignments into a per-file type map.
+ *
+ * Values are `{ type: string, confidence: number }`:
+ *   - 1.0: explicit constructor (`new Foo()`)
+ *   - 0.9: type annotation (`: Foo`) or typed parameter
+ *   - 0.7: factory method call (`Foo.create()` — uppercase-first heuristic)
+ *
+ * Higher-confidence entries take priority when the same variable is seen twice.
+ */
+function extractTypeMapWalk(rootNode, typeMap) {
+  function setIfHigher(name, type, confidence) {
+    const existing = typeMap.get(name);
+    if (!existing || confidence > existing.confidence) {
+      typeMap.set(name, { type, confidence });
+    }
+  }
+
+  function walk(node, depth) {
+    if (depth >= 200) return;
+    const t = node.type;
+    if (t === 'variable_declarator') {
+      const nameN = node.childForFieldName('name');
+      if (nameN && nameN.type === 'identifier') {
+        const typeAnno = findChild(node, 'type_annotation');
+        if (typeAnno) {
+          const typeName = extractSimpleTypeName(typeAnno);
+          if (typeName) setIfHigher(nameN.text, typeName, 0.9);
+        }
+        const valueN = node.childForFieldName('value');
+        if (valueN) {
+          // Constructor: const x = new Foo() → confidence 1.0
+          if (valueN.type === 'new_expression') {
+            const ctorType = extractNewExprTypeName(valueN);
+            if (ctorType) setIfHigher(nameN.text, ctorType, 1.0);
+          }
+          // Factory method: const x = Foo.create() → confidence 0.7
+          else if (valueN.type === 'call_expression') {
+            const fn = valueN.childForFieldName('function');
+            if (fn && fn.type === 'member_expression') {
+              const obj = fn.childForFieldName('object');
+              if (obj && obj.type === 'identifier') {
+                const objName = obj.text;
+                if (objName[0] !== objName[0].toLowerCase() && !BUILTIN_GLOBALS.has(objName)) {
+                  setIfHigher(nameN.text, objName, 0.7);
+                }
+              }
+            }
+          }
+        }
+      }
+    } else if (t === 'required_parameter' || t === 'optional_parameter') {
+      const nameNode =
+        node.childForFieldName('pattern') || node.childForFieldName('left') || node.child(0);
+      if (nameNode && nameNode.type === 'identifier') {
+        const typeAnno = findChild(node, 'type_annotation');
+        if (typeAnno) {
+          const typeName = extractSimpleTypeName(typeAnno);
+          if (typeName) setIfHigher(nameNode.text, typeName, 0.9);
+        }
+      }
+    }
+    for (let i = 0; i < node.childCount; i++) {
+      walk(node.child(i), depth + 1);
+    }
+  }
+  walk(rootNode, 0);
+}
+
 function extractReceiverName(objNode) {
   if (!objNode) return undefined;
   const t = objNode.type;

package/src/extractors/php.js

@@ -82,9 +82,11 @@ export function extractPHPSymbols(tree, _filePath) {
     imports: [],
     classes: [],
     exports: [],
+    typeMap: new Map(),
   };
 
   walkPhpNode(tree.rootNode, ctx);
+  extractPhpTypeMap(tree.rootNode, ctx);
   return ctx;
 }
 
@@ -320,6 +322,47 @@ function handlePhpObjectCreation(node, ctx) {
   }
 }
 
+function extractPhpTypeMap(node, ctx) {
+  extractPhpTypeMapDepth(node, ctx, 0);
+}
+
+function extractPhpTypeMapDepth(node, ctx, depth) {
+  if (depth >= 200) return;
+
+  // Function/method parameters with type hints
+  if (
+    node.type === 'simple_parameter' ||
+    node.type === 'variadic_parameter' ||
+    node.type === 'property_promotion_parameter'
+  ) {
+    const typeNode = node.childForFieldName('type');
+    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 });
+    }
+  }
+
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) extractPhpTypeMapDepth(child, ctx, depth + 1);
+  }
+}
+
+function extractPhpTypeName(typeNode) {
+  if (!typeNode) return null;
+  const t = typeNode.type;
+  if (t === 'named_type' || t === 'name' || t === 'qualified_name') return typeNode.text;
+  // Nullable: ?MyType
+  if (t === 'optional_type') {
+    const inner = typeNode.child(1) || typeNode.child(0);
+    return inner ? extractPhpTypeName(inner) : null;
+  }
+  // Skip union types (too ambiguous)
+  if (t === 'union_type' || t === 'intersection_type') return null;
+  return null;
+}
+
 function findPHPParentClass(node) {
   let current = node.parent;
   while (current) {

package/src/extractors/python.js

@@ -1,5 +1,49 @@
 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([
+  // Uppercase builtins that would false-positive on the factory heuristic
+  'Exception',
+  'BaseException',
+  'ValueError',
+  'TypeError',
+  'KeyError',
+  'IndexError',
+  'AttributeError',
+  'RuntimeError',
+  'OSError',
+  'IOError',
+  'FileNotFoundError',
+  'PermissionError',
+  'NotImplementedError',
+  'StopIteration',
+  'GeneratorExit',
+  'SystemExit',
+  'KeyboardInterrupt',
+  'ArithmeticError',
+  'LookupError',
+  'UnicodeError',
+  'UnicodeDecodeError',
+  'UnicodeEncodeError',
+  'ImportError',
+  'ModuleNotFoundError',
+  'ConnectionError',
+  'TimeoutError',
+  'OverflowError',
+  'ZeroDivisionError',
+  'NameError',
+  'SyntaxError',
+  'RecursionError',
+  'MemoryError',
+  // Common standard library uppercase classes
+  'Path',
+  'PurePath',
+  'OrderedDict',
+  'Counter',
+  'Decimal',
+  'Fraction',
+]);
+
 /**
  * Extract symbols from Python files.
  */
@@ -10,9 +54,11 @@ export function extractPythonSymbols(tree, _filePath) {
     imports: [],
     classes: [],
     exports: [],
+    typeMap: new Map(),
   };
 
   walkPythonNode(tree.rootNode, ctx);
+  extractPythonTypeMap(tree.rootNode, ctx);
   return ctx;
 }
 
@@ -284,6 +330,90 @@ function walkInitBody(bodyNode, seen, props) {
   }
 }
 
+function extractPythonTypeMap(node, ctx) {
+  extractPythonTypeMapDepth(node, ctx, 0);
+}
+
+function setIfHigherPy(typeMap, name, type, confidence) {
+  const existing = typeMap.get(name);
+  if (!existing || confidence > existing.confidence) {
+    typeMap.set(name, { type, confidence });
+  }
+}
+
+function extractPythonTypeMapDepth(node, ctx, depth) {
+  if (depth >= 200) return;
+
+  // typed_parameter: identifier : type (confidence 0.9)
+  if (node.type === 'typed_parameter') {
+    const nameNode = node.child(0);
+    const typeNode = node.childForFieldName('type');
+    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);
+      }
+    }
+  }
+
+  // typed_default_parameter: name : type = default (confidence 0.9)
+  if (node.type === 'typed_default_parameter') {
+    const nameNode = node.childForFieldName('name');
+    const typeNode = node.childForFieldName('type');
+    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);
+      }
+    }
+  }
+
+  // assignment: x = SomeClass(...) → constructor (confidence 1.0)
+  //             x = SomeClass.create(...) → factory (confidence 0.7)
+  if (node.type === 'assignment') {
+    const left = node.childForFieldName('left');
+    const right = node.childForFieldName('right');
+    if (left && left.type === 'identifier' && right && right.type === 'call') {
+      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 (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);
+          }
+        }
+      }
+    }
+  }
+
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) extractPythonTypeMapDepth(child, ctx, depth + 1);
+  }
+}
+
+function extractPythonTypeName(typeNode) {
+  if (!typeNode) return null;
+  const t = typeNode.type;
+  if (t === 'identifier') return typeNode.text;
+  if (t === 'attribute') return typeNode.text; // module.Type
+  // Generic: List[int] → subscript → value is identifier
+  if (t === 'subscript') {
+    const value = typeNode.childForFieldName('value');
+    return value ? value.text : null;
+  }
+  // None type, string, etc → skip
+  if (t === 'none' || t === 'string') return null;
+  return null;
+}
+
 function findPythonParentClass(node) {
   let current = node.parent;
   while (current) {