@optave/codegraph 3.5.0 → 3.7.0

package/src/extractors/ocaml.ts

@@ -0,0 +1,259 @@
+import type {
+  Call,
+  ExtractorOutput,
+  SubDeclaration,
+  TreeSitterNode,
+  TreeSitterTree,
+} from '../types.js';
+import { findChild, nodeEndLine } from './helpers.js';
+
+/**
+ * Extract symbols from OCaml files.
+ */
+export function extractOCamlSymbols(tree: TreeSitterTree, _filePath: string): ExtractorOutput {
+  const ctx: ExtractorOutput = {
+    definitions: [],
+    calls: [],
+    imports: [],
+    classes: [],
+    exports: [],
+    typeMap: new Map(),
+  };
+
+  walkOCamlNode(tree.rootNode, ctx);
+  return ctx;
+}
+
+function walkOCamlNode(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  switch (node.type) {
+    case 'value_definition':
+      handleOCamlValueDef(node, ctx);
+      break;
+    case 'let_binding':
+      // Only handle top-level let bindings not inside value_definition
+      if (node.parent?.type !== 'value_definition') {
+        handleOCamlLetBinding(node, ctx);
+      }
+      break;
+    case 'module_definition':
+      handleOCamlModuleDef(node, ctx);
+      break;
+    case 'type_definition':
+      handleOCamlTypeDef(node, ctx);
+      break;
+    case 'class_definition':
+      handleOCamlClassDef(node, ctx);
+      break;
+    case 'open_module':
+      handleOCamlOpen(node, ctx);
+      break;
+    case 'application_expression':
+      handleOCamlApplication(node, ctx);
+      break;
+  }
+
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) walkOCamlNode(child, ctx);
+  }
+}
+
+function handleOCamlValueDef(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  // value_definition contains one or more let_bindings
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child && child.type === 'let_binding') {
+      handleOCamlLetBinding(child, ctx);
+    }
+  }
+}
+
+function handleOCamlLetBinding(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  // let_binding has a pattern (the name) and optionally a body
+  const pattern = node.childForFieldName('pattern');
+  if (!pattern) return;
+
+  // Check if this is a function (has parameter children)
+  const hasParams = hasOCamlParams(node);
+  const name = extractOCamlPatternName(pattern);
+  if (!name) return;
+
+  if (hasParams) {
+    const params = extractOCamlParams(node);
+    ctx.definitions.push({
+      name,
+      kind: 'function',
+      line: node.startPosition.row + 1,
+      endLine: nodeEndLine(node),
+      children: params.length > 0 ? params : undefined,
+    });
+  } else {
+    ctx.definitions.push({
+      name,
+      kind: 'variable',
+      line: node.startPosition.row + 1,
+      endLine: nodeEndLine(node),
+    });
+  }
+}
+
+function extractOCamlPatternName(pattern: TreeSitterNode): string | null {
+  if (pattern.type === 'value_name' || pattern.type === 'identifier') {
+    return pattern.text;
+  }
+  // Operator definitions like `let (+) a b = ...`
+  if (pattern.type === 'parenthesized_operator') {
+    return pattern.text;
+  }
+  const nameNode = findChild(pattern, 'value_name') || findChild(pattern, 'identifier');
+  return nameNode ? nameNode.text : null;
+}
+
+function hasOCamlParams(letBinding: TreeSitterNode): boolean {
+  for (let i = 0; i < letBinding.childCount; i++) {
+    const child = letBinding.child(i);
+    if (!child) continue;
+    if (child.type === 'parameter' || child.type === 'value_pattern') return true;
+  }
+  return false;
+}
+
+function extractOCamlParams(letBinding: TreeSitterNode): SubDeclaration[] {
+  const params: SubDeclaration[] = [];
+  for (let i = 0; i < letBinding.childCount; i++) {
+    const child = letBinding.child(i);
+    if (!child) continue;
+    if (child.type === 'parameter' || child.type === 'value_pattern') {
+      const name = extractOCamlPatternName(child);
+      if (name) {
+        params.push({ name, kind: 'parameter', line: child.startPosition.row + 1 });
+      }
+    }
+  }
+  return params;
+}
+
+function handleOCamlModuleDef(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const binding = findChild(node, 'module_binding');
+  if (!binding) return;
+
+  const nameNode =
+    binding.childForFieldName('name') ||
+    findChild(binding, 'module_name') ||
+    findChild(binding, 'identifier');
+  if (!nameNode) return;
+
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'module',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+  });
+}
+
+function handleOCamlTypeDef(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  // type_definition contains one or more type_bindings
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child || child.type !== 'type_binding') continue;
+
+    const nameNode =
+      child.childForFieldName('name') ||
+      findChild(child, 'type_constructor') ||
+      findChild(child, 'identifier');
+    if (!nameNode) continue;
+
+    const children: SubDeclaration[] = [];
+    extractOCamlTypeConstructors(child, children);
+
+    ctx.definitions.push({
+      name: nameNode.text,
+      kind: 'type',
+      line: child.startPosition.row + 1,
+      endLine: nodeEndLine(child),
+      children: children.length > 0 ? children : undefined,
+    });
+  }
+}
+
+function extractOCamlTypeConstructors(
+  typeBinding: TreeSitterNode,
+  children: SubDeclaration[],
+): void {
+  for (let i = 0; i < typeBinding.childCount; i++) {
+    const child = typeBinding.child(i);
+    if (!child) continue;
+    if (child.type === 'constructor_declaration') {
+      const nameNode = findChild(child, 'constructor_name') || findChild(child, 'identifier');
+      if (nameNode) {
+        children.push({ name: nameNode.text, kind: 'property', line: child.startPosition.row + 1 });
+      }
+    }
+  }
+}
+
+function handleOCamlClassDef(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const binding = findChild(node, 'class_binding');
+  if (!binding) return;
+
+  const nameNode = binding.childForFieldName('name') || findChild(binding, 'identifier');
+  if (!nameNode) return;
+
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'class',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+  });
+}
+
+function handleOCamlOpen(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  // open_module contains a module_path
+  let moduleName: string | null = null;
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    if (
+      child.type === 'module_path' ||
+      child.type === 'module_name' ||
+      child.type === 'extended_module_path' ||
+      child.type === 'constructor_name'
+    ) {
+      moduleName = child.text;
+      break;
+    }
+  }
+  if (!moduleName) return;
+
+  ctx.imports.push({
+    source: moduleName,
+    names: [moduleName.split('.').pop() || moduleName],
+    line: node.startPosition.row + 1,
+  });
+}
+
+function handleOCamlApplication(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  // application_expression: first child is the function, rest are arguments
+  const funcNode = node.child(0);
+  if (!funcNode) return;
+
+  if (
+    funcNode.type === 'value_path' ||
+    funcNode.type === 'value_name' ||
+    funcNode.type === 'identifier'
+  ) {
+    ctx.calls.push({ name: funcNode.text, line: node.startPosition.row + 1 });
+  } else if (funcNode.type === 'field_get_expression') {
+    // Module.function calls
+    const field =
+      funcNode.childForFieldName('field') ||
+      findChild(funcNode, 'value_name') ||
+      findChild(funcNode, 'identifier');
+    const record = funcNode.child(0);
+    if (field) {
+      const call: Call = { name: field.text, line: node.startPosition.row + 1 };
+      if (record && record !== field) call.receiver = record.text;
+      ctx.calls.push(call);
+    }
+  }
+}

package/src/extractors/php.ts

@@ -5,7 +5,14 @@ import type {
   TreeSitterNode,
   TreeSitterTree,
 } from '../types.js';
-import { extractModifierVisibility, findChild, MAX_WALK_DEPTH, nodeEndLine } from './helpers.js';
+import {
+  extractBodyMembers,
+  extractModifierVisibility,
+  findChild,
+  lastPathSegment,
+  MAX_WALK_DEPTH,
+  nodeEndLine,
+} from './helpers.js';
 
 function extractPhpParameters(fnNode: TreeSitterNode): SubDeclaration[] {
   const params: SubDeclaration[] = [];
@@ -25,6 +32,39 @@ function extractPhpParameters(fnNode: TreeSitterNode): SubDeclaration[] {
   return params;
 }
 
+/** Extract property declarations from a PHP class member. */
+function extractPhpProperties(member: TreeSitterNode, children: SubDeclaration[]): void {
+  for (let j = 0; j < member.childCount; j++) {
+    const el = member.child(j);
+    if (!el || el.type !== 'property_element') continue;
+    const varNode = findChild(el, 'variable_name');
+    if (varNode) {
+      children.push({
+        name: varNode.text,
+        kind: 'property',
+        line: member.startPosition.row + 1,
+        visibility: extractModifierVisibility(member),
+      });
+    }
+  }
+}
+
+/** Extract constant declarations from a PHP class member. */
+function extractPhpConstants(member: TreeSitterNode, children: SubDeclaration[]): void {
+  for (let j = 0; j < member.childCount; j++) {
+    const el = member.child(j);
+    if (!el || el.type !== 'const_element') continue;
+    const nameNode = el.childForFieldName('name') || findChild(el, 'name');
+    if (nameNode) {
+      children.push({
+        name: nameNode.text,
+        kind: 'constant',
+        line: member.startPosition.row + 1,
+      });
+    }
+  }
+}
+
 function extractPhpClassChildren(classNode: TreeSitterNode): SubDeclaration[] {
   const children: SubDeclaration[] = [];
   const body = classNode.childForFieldName('body') || findChild(classNode, 'declaration_list');
@@ -33,50 +73,16 @@ function extractPhpClassChildren(classNode: TreeSitterNode): SubDeclaration[] {
     const member = body.child(i);
     if (!member) continue;
     if (member.type === 'property_declaration') {
-      for (let j = 0; j < member.childCount; j++) {
-        const el = member.child(j);
-        if (!el || el.type !== 'property_element') continue;
-        const varNode = findChild(el, 'variable_name');
-        if (varNode) {
-          children.push({
-            name: varNode.text,
-            kind: 'property',
-            line: member.startPosition.row + 1,
-            visibility: extractModifierVisibility(member),
-          });
-        }
-      }
+      extractPhpProperties(member, children);
     } else if (member.type === 'const_declaration') {
-      for (let j = 0; j < member.childCount; j++) {
-        const el = member.child(j);
-        if (!el || el.type !== 'const_element') continue;
-        const nameNode = el.childForFieldName('name') || findChild(el, 'name');
-        if (nameNode) {
-          children.push({
-            name: nameNode.text,
-            kind: 'constant',
-            line: member.startPosition.row + 1,
-          });
-        }
-      }
+      extractPhpConstants(member, children);
     }
   }
   return 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++) {
-    const member = body.child(i);
-    if (!member || member.type !== 'enum_case') continue;
-    const nameNode = member.childForFieldName('name');
-    if (nameNode) {
-      children.push({ name: nameNode.text, kind: 'constant', line: member.startPosition.row + 1 });
-    }
-  }
-  return children;
+  return extractBodyMembers(enumNode, ['body', 'enum_declaration_list'], 'enum_case', 'constant');
 }
 
 /**
@@ -272,7 +278,7 @@ function handlePhpNamespaceUse(node: TreeSitterNode, ctx: ExtractorOutput): void
       const nameNode = findChild(child, 'qualified_name') || findChild(child, 'name');
       if (nameNode) {
         const fullPath = nameNode.text;
-        const lastName = fullPath.split('\\').pop() ?? fullPath;
+        const lastName = lastPathSegment(fullPath, '\\');
         const alias = child.childForFieldName('alias');
         ctx.imports.push({
           source: fullPath,
@@ -284,7 +290,7 @@ function handlePhpNamespaceUse(node: TreeSitterNode, ctx: ExtractorOutput): void
     }
     if (child && (child.type === 'qualified_name' || child.type === 'name')) {
       const fullPath = child.text;
-      const lastName = fullPath.split('\\').pop() ?? fullPath;
+      const lastName = lastPathSegment(fullPath, '\\');
       ctx.imports.push({
         source: fullPath,
         names: [lastName],

package/src/extractors/python.ts

@@ -4,9 +4,15 @@ import type {
   SubDeclaration,
   TreeSitterNode,
   TreeSitterTree,
-  TypeMapEntry,
 } from '../types.js';
-import { findChild, MAX_WALK_DEPTH, nodeEndLine, pythonVisibility } from './helpers.js';
+import {
+  findChild,
+  findParentNode,
+  MAX_WALK_DEPTH,
+  nodeEndLine,
+  pythonVisibility,
+  setTypeMapEntry,
+} from './helpers.js';
 
 /** Built-in globals that start with uppercase but are not user-defined types. */
 const BUILTIN_GLOBALS_PY: Set<string> = new Set([
@@ -268,6 +274,37 @@ function extractPythonParameters(fnNode: TreeSitterNode): SubDeclaration[] {
   return params;
 }
 
+/** Extract class-level assignment properties from expression statements. */
+function extractClassAssignment(
+  child: TreeSitterNode,
+  seen: Set<string>,
+  props: SubDeclaration[],
+): void {
+  const assignment = findChild(child, 'assignment');
+  if (!assignment) return;
+  const left = assignment.childForFieldName('left');
+  if (!left || left.type !== 'identifier' || seen.has(left.text)) return;
+  seen.add(left.text);
+  props.push({
+    name: left.text,
+    kind: 'property',
+    line: child.startPosition.row + 1,
+    visibility: pythonVisibility(left.text),
+  });
+}
+
+/** If node is an __init__ method, walk its body for self.x assignments. */
+function extractInitProperties(
+  node: TreeSitterNode,
+  seen: Set<string>,
+  props: SubDeclaration[],
+): void {
+  const fnName = node.childForFieldName('name');
+  if (!fnName || fnName.text !== '__init__') return;
+  const initBody = node.childForFieldName('body') || findChild(node, 'block');
+  if (initBody) walkInitBody(initBody, seen, props);
+}
+
 function extractPythonClassProperties(classNode: TreeSitterNode): SubDeclaration[] {
   const props: SubDeclaration[] = [];
   const seen = new Set<string>();
@@ -279,42 +316,14 @@ function extractPythonClassProperties(classNode: TreeSitterNode): SubDeclaration
     if (!child) continue;
 
     if (child.type === 'expression_statement') {
-      const assignment = findChild(child, 'assignment');
-      if (assignment) {
-        const left = assignment.childForFieldName('left');
-        if (left && left.type === 'identifier' && !seen.has(left.text)) {
-          seen.add(left.text);
-          props.push({
-            name: left.text,
-            kind: 'property',
-            line: child.startPosition.row + 1,
-            visibility: pythonVisibility(left.text),
-          });
-        }
-      }
-    }
-
-    if (child.type === 'function_definition') {
-      const fnName = child.childForFieldName('name');
-      if (fnName && fnName.text === '__init__') {
-        const initBody = child.childForFieldName('body') || findChild(child, 'block');
-        if (initBody) {
-          walkInitBody(initBody, seen, props);
-        }
-      }
-    }
-
-    if (child.type === 'decorated_definition') {
+      extractClassAssignment(child, seen, props);
+    } else if (child.type === 'function_definition') {
+      extractInitProperties(child, seen, props);
+    } else if (child.type === 'decorated_definition') {
       for (let j = 0; j < child.childCount; j++) {
         const inner = child.child(j);
         if (inner && inner.type === 'function_definition') {
-          const fnName = inner.childForFieldName('name');
-          if (fnName && fnName.text === '__init__') {
-            const initBody = inner.childForFieldName('body') || findChild(inner, 'block');
-            if (initBody) {
-              walkInitBody(initBody, seen, props);
-            }
-          }
+          extractInitProperties(inner, seen, props);
         }
       }
     }
@@ -348,15 +357,37 @@ function extractPythonTypeMap(node: TreeSitterNode, ctx: ExtractorOutput): void
   extractPythonTypeMapDepth(node, ctx, 0);
 }
 
-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 });
+/** Handle typed_parameter or typed_default_parameter for type map. */
+function handlePyTypedParam(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const isDefault = node.type === 'typed_default_parameter';
+  const nameNode = isDefault ? node.childForFieldName('name') : node.child(0);
+  const typeNode = node.childForFieldName('type');
+  if (!nameNode || nameNode.type !== 'identifier' || !typeNode) return;
+  if (nameNode.text === 'self' || nameNode.text === 'cls') return;
+  const typeName = extractPythonTypeName(typeNode);
+  if (typeName && ctx.typeMap) setTypeMapEntry(ctx.typeMap, nameNode.text, typeName, 0.9);
+}
+
+/** Handle assignment for constructor/factory type inference. */
+function handlePyAssignmentType(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const left = node.childForFieldName('left');
+  const right = node.childForFieldName('right');
+  if (!left || left.type !== 'identifier' || !right || right.type !== 'call') return;
+
+  const fn = right.childForFieldName('function');
+  if (!fn) return;
+  if (fn.type === 'identifier') {
+    const name = fn.text;
+    if (name[0] && name[0] !== name[0].toLowerCase()) {
+      if (ctx.typeMap) setTypeMapEntry(ctx.typeMap, left.text, name, 1.0);
+    }
+  } else if (fn.type === 'attribute') {
+    const obj = fn.childForFieldName('object');
+    if (!obj || obj.type !== 'identifier') return;
+    const objName = obj.text;
+    if (objName[0] && objName[0] !== objName[0].toLowerCase() && !BUILTIN_GLOBALS_PY.has(objName)) {
+      if (ctx.typeMap) setTypeMapEntry(ctx.typeMap, left.text, objName, 0.7);
+    }
   }
 }
 
@@ -367,57 +398,10 @@ function extractPythonTypeMapDepth(
 ): void {
   if (depth >= MAX_WALK_DEPTH) 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') {
-        if (ctx.typeMap) 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') {
-        if (ctx.typeMap) 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] !== 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] !== objName[0].toLowerCase() &&
-            !BUILTIN_GLOBALS_PY.has(objName)
-          ) {
-            if (ctx.typeMap) setIfHigherPy(ctx.typeMap, left.text, objName, 0.7);
-          }
-        }
-      }
-    }
+  if (node.type === 'typed_parameter' || node.type === 'typed_default_parameter') {
+    handlePyTypedParam(node, ctx);
+  } else if (node.type === 'assignment') {
+    handlePyAssignmentType(node, ctx);
   }
 
   for (let i = 0; i < node.childCount; i++) {
@@ -441,14 +425,7 @@ function extractPythonTypeName(typeNode: TreeSitterNode): string | null {
   return null;
 }
 
+const PY_CLASS_TYPES = ['class_definition'] as const;
 function findPythonParentClass(node: TreeSitterNode): string | null {
-  let current = node.parent;
-  while (current) {
-    if (current.type === 'class_definition') {
-      const nameNode = current.childForFieldName('name');
-      return nameNode ? nameNode.text : null;
-    }
-    current = current.parent;
-  }
-  return null;
+  return findParentNode(node, PY_CLASS_TYPES);
 }

package/src/extractors/ruby.ts

@@ -5,7 +5,7 @@ import type {
   TreeSitterNode,
   TreeSitterTree,
 } from '../types.js';
-import { findChild, nodeEndLine } from './helpers.js';
+import { findChild, findParentNode, lastPathSegment, nodeEndLine, stripQuotes } from './helpers.js';
 
 /**
  * Extract symbols from Ruby files.
@@ -176,10 +176,10 @@ function handleRubyRequire(node: TreeSitterNode, ctx: ExtractorOutput): void {
   for (let i = 0; i < args.childCount; i++) {
     const arg = args.child(i);
     if (arg && (arg.type === 'string' || arg.type === 'string_content')) {
-      const strContent = arg.text.replace(/^['"]|['"]$/g, '');
+      const strContent = stripQuotes(arg.text);
       ctx.imports.push({
         source: strContent,
-        names: [strContent.split('/').pop() ?? strContent],
+        names: [lastPathSegment(strContent)],
         line: node.startPosition.row + 1,
         rubyRequire: true,
       });
@@ -190,7 +190,7 @@ function handleRubyRequire(node: TreeSitterNode, ctx: ExtractorOutput): void {
       if (content) {
         ctx.imports.push({
           source: content.text,
-          names: [content.text.split('/').pop() ?? content.text],
+          names: [lastPathSegment(content.text)],
           line: node.startPosition.row + 1,
           rubyRequire: true,
         });
@@ -221,16 +221,9 @@ function handleRubyModuleInclusion(
   }
 }
 
+const RUBY_PARENT_TYPES = ['class', 'module'] as const;
 function findRubyParentClass(node: TreeSitterNode): string | null {
-  let current = node.parent;
-  while (current) {
-    if (current.type === 'class' || current.type === 'module') {
-      const nameNode = current.childForFieldName('name');
-      return nameNode ? nameNode.text : null;
-    }
-    current = current.parent;
-  }
-  return null;
+  return findParentNode(node, RUBY_PARENT_TYPES);
 }
 
 // ── Child extraction helpers ────────────────────────────────────────────────