@optave/codegraph 3.7.0 → 3.8.1

package/src/extractors/javascript.ts

@@ -328,34 +328,7 @@ function extractConstantsWalk(node: TreeSitterNode, definitions: Definition[]):
       if (inner) declNode = inner;
     }
 
-    const t = declNode.type;
-    if (t === 'lexical_declaration' || t === 'variable_declaration') {
-      if (declNode.text.startsWith('const ')) {
-        for (let j = 0; j < declNode.childCount; j++) {
-          const declarator = declNode.child(j);
-          if (!declarator || declarator.type !== 'variable_declarator') continue;
-          const nameN = declarator.childForFieldName('name');
-          const valueN = declarator.childForFieldName('value');
-          if (!nameN || nameN.type !== 'identifier' || !valueN) continue;
-          // Skip functions — already captured by query patterns
-          const valType = valueN.type;
-          if (
-            valType === 'arrow_function' ||
-            valType === 'function_expression' ||
-            valType === 'function'
-          )
-            continue;
-          if (isConstantValue(valueN)) {
-            definitions.push({
-              name: nameN.text,
-              kind: 'constant',
-              line: declNode.startPosition.row + 1,
-              endLine: nodeEndLine(declNode),
-            });
-          }
-        }
-      }
-    }
+    extractConstDeclarators(declNode, definitions);
 
     // Recurse into non-function, non-export-statement children (blocks, if-statements, etc.)
     if (child.type !== 'export_statement') {
@@ -364,6 +337,33 @@ function extractConstantsWalk(node: TreeSitterNode, definitions: Definition[]):
   }
 }
 
+/** Extract constant definitions from a `const` declaration node. */
+function extractConstDeclarators(declNode: TreeSitterNode, definitions: Definition[]): void {
+  const t = declNode.type;
+  if (t !== 'lexical_declaration' && t !== 'variable_declaration') return;
+  if (!declNode.text.startsWith('const ')) return;
+
+  for (let j = 0; j < declNode.childCount; j++) {
+    const declarator = declNode.child(j);
+    if (!declarator || declarator.type !== 'variable_declarator') continue;
+    const nameN = declarator.childForFieldName('name');
+    const valueN = declarator.childForFieldName('value');
+    if (!nameN || nameN.type !== 'identifier' || !valueN) continue;
+    // Skip functions — already captured by query patterns
+    const valType = valueN.type;
+    if (valType === 'arrow_function' || valType === 'function_expression' || valType === 'function')
+      continue;
+    if (isConstantValue(valueN)) {
+      definitions.push({
+        name: nameN.text,
+        kind: 'constant',
+        line: declNode.startPosition.row + 1,
+        endLine: nodeEndLine(declNode),
+      });
+    }
+  }
+}
+
 /**
  * Recursive walk to find dynamic import() calls.
  * Query patterns match call_expression with identifier/member_expression/subscript_expression
@@ -678,24 +678,7 @@ function handleCallExpr(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const fn = node.childForFieldName('function');
   if (!fn) return;
   if (fn.type === 'import') {
-    const args = node.childForFieldName('arguments') || findChild(node, 'arguments');
-    if (args) {
-      const strArg = findChild(args, 'string');
-      if (strArg) {
-        const modPath = strArg.text.replace(/['"]/g, '');
-        const names = extractDynamicImportNames(node);
-        ctx.imports.push({
-          source: modPath,
-          names,
-          line: node.startPosition.row + 1,
-          dynamicImport: true,
-        });
-      } else {
-        debug(
-          `Skipping non-static dynamic import() at line ${node.startPosition.row + 1} (template literal or variable)`,
-        );
-      }
-    }
+    handleDynamicImportCall(node, ctx.imports);
   } else {
     const callInfo = extractCallInfo(fn, node);
     if (callInfo) ctx.calls.push(callInfo);
@@ -706,6 +689,22 @@ function handleCallExpr(node: TreeSitterNode, ctx: ExtractorOutput): void {
   }
 }
 
+/** Handle a dynamic import() call expression and add to imports if static. */
+function handleDynamicImportCall(node: TreeSitterNode, imports: Import[]): void {
+  const args = node.childForFieldName('arguments') || findChild(node, 'arguments');
+  if (!args) return;
+  const strArg = findChild(args, 'string');
+  if (strArg) {
+    const modPath = strArg.text.replace(/['"]/g, '');
+    const names = extractDynamicImportNames(node);
+    imports.push({ source: modPath, names, line: node.startPosition.row + 1, dynamicImport: true });
+  } else {
+    debug(
+      `Skipping non-static dynamic import() at line ${node.startPosition.row + 1} (template literal or variable)`,
+    );
+  }
+}
+
 function handleImportStmt(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const isTypeOnly = node.text.startsWith('import type');
   const source = node.childForFieldName('source') || findChild(node, 'string');

package/src/extractors/julia.ts

@@ -0,0 +1,318 @@
+import type { ExtractorOutput, SubDeclaration, TreeSitterNode, TreeSitterTree } from '../types.js';
+import { findChild, nodeEndLine } from './helpers.js';
+
+/**
+ * Extract symbols from Julia files.
+ *
+ * tree-sitter-julia grammar notes:
+ * - function_definition: `function name(params)...end`
+ * - assignment: `name(params) = expr` (short form), LHS is call_expression
+ * - struct_definition: `struct TypeHead...end`, name is in type_head
+ * - module_definition: `module Name...end`
+ * - import_statement / using_statement
+ * - macro_definition: `macro name(params)...end`
+ * - abstract_definition: `abstract type Name end`
+ * - call_expression: function calls
+ */
+export function extractJuliaSymbols(tree: TreeSitterTree, _filePath: string): ExtractorOutput {
+  const ctx: ExtractorOutput = {
+    definitions: [],
+    calls: [],
+    imports: [],
+    classes: [],
+    exports: [],
+    typeMap: new Map(),
+  };
+
+  walkJuliaNode(tree.rootNode, ctx, null);
+  return ctx;
+}
+
+function walkJuliaNode(
+  node: TreeSitterNode,
+  ctx: ExtractorOutput,
+  currentModule: string | null,
+): void {
+  let nextModule = currentModule;
+
+  switch (node.type) {
+    case 'module_definition':
+      nextModule = handleModuleDef(node, ctx);
+      break;
+    case 'function_definition':
+      handleFunctionDef(node, ctx, currentModule);
+      break;
+    case 'assignment':
+      handleAssignment(node, ctx, currentModule);
+      break;
+    case 'struct_definition':
+      handleStructDef(node, ctx);
+      break;
+    case 'abstract_definition':
+      handleAbstractDef(node, ctx);
+      break;
+    case 'macro_definition':
+      handleMacroDef(node, ctx, currentModule);
+      break;
+    case 'import_statement':
+    case 'using_statement':
+      handleImport(node, ctx);
+      break;
+    case 'call_expression':
+      handleCall(node, ctx);
+      break;
+  }
+
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) walkJuliaNode(child, ctx, nextModule);
+  }
+}
+
+function handleModuleDef(node: TreeSitterNode, ctx: ExtractorOutput): string | null {
+  const nameNode = node.childForFieldName('name') || findChild(node, 'identifier');
+  if (!nameNode) return null;
+
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'module',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+  });
+
+  return nameNode.text;
+}
+
+function handleFunctionDef(
+  node: TreeSitterNode,
+  ctx: ExtractorOutput,
+  currentModule: string | null,
+): void {
+  // function_definition may have a call_expression child as the signature
+  const callSig = findChild(node, 'call_expression');
+  if (callSig) {
+    const funcNameNode = callSig.child(0);
+    if (funcNameNode) {
+      const name = currentModule ? `${currentModule}.${funcNameNode.text}` : funcNameNode.text;
+      const params = extractJuliaParams(callSig);
+      ctx.definitions.push({
+        name,
+        kind: 'function',
+        line: node.startPosition.row + 1,
+        endLine: nodeEndLine(node),
+        children: params.length > 0 ? params : undefined,
+      });
+      return;
+    }
+  }
+
+  // Fallback: look for identifier directly
+  const nameNode = node.childForFieldName('name') || findChild(node, 'identifier');
+  if (!nameNode) return;
+
+  const name = currentModule ? `${currentModule}.${nameNode.text}` : nameNode.text;
+  ctx.definitions.push({
+    name,
+    kind: 'function',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+  });
+}
+
+function handleAssignment(
+  node: TreeSitterNode,
+  ctx: ExtractorOutput,
+  currentModule: string | null,
+): void {
+  // assignment: LHS operator RHS
+  // Short function form: add(x, y) = x + y → LHS is call_expression
+  const lhs = node.child(0);
+  if (!lhs) return;
+
+  if (lhs.type === 'call_expression') {
+    const funcNameNode = lhs.child(0);
+    if (!funcNameNode) return;
+
+    const name = currentModule ? `${currentModule}.${funcNameNode.text}` : funcNameNode.text;
+    const params = extractJuliaParams(lhs);
+
+    ctx.definitions.push({
+      name,
+      kind: 'function',
+      line: node.startPosition.row + 1,
+      endLine: nodeEndLine(node),
+      children: params.length > 0 ? params : undefined,
+    });
+  }
+}
+
+function handleStructDef(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  // struct_definition: struct type_head fields... end
+  const typeHead = findChild(node, 'type_head');
+  const nameNode = typeHead
+    ? (findChild(typeHead, 'identifier') ?? typeHead)
+    : findChild(node, 'identifier');
+  if (!nameNode) return;
+
+  const children: SubDeclaration[] = [];
+  // Fields are typed_expression children of struct_definition
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    if (child.type === 'typed_expression') {
+      const fieldName = findChild(child, 'identifier');
+      if (fieldName) {
+        children.push({
+          name: fieldName.text,
+          kind: 'property',
+          line: child.startPosition.row + 1,
+        });
+      }
+    }
+    // Plain identifier fields (no type annotation)
+    if (child.type === 'identifier' && child !== nameNode && typeHead && child !== typeHead) {
+      children.push({ name: child.text, kind: 'property', line: child.startPosition.row + 1 });
+    }
+  }
+
+  // Check for supertype in type_head (Point <: AbstractPoint)
+  if (typeHead) {
+    const subtypeExpr = findChild(typeHead, 'subtype_expression');
+    if (subtypeExpr) {
+      // Find the supertype identifier
+      for (let i = 0; i < subtypeExpr.childCount; i++) {
+        const child = subtypeExpr.child(i);
+        if (child?.type === 'identifier' && i > 0) {
+          ctx.classes.push({
+            name: nameNode.text,
+            extends: child.text,
+            line: node.startPosition.row + 1,
+          });
+        }
+      }
+    }
+  }
+
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'struct',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+    children: children.length > 0 ? children : undefined,
+  });
+}
+
+function handleAbstractDef(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const nameNode = node.childForFieldName('name') || findChild(node, 'identifier');
+  if (!nameNode) return;
+
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'type',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+  });
+}
+
+function handleMacroDef(
+  node: TreeSitterNode,
+  ctx: ExtractorOutput,
+  currentModule: string | null,
+): void {
+  const nameNode = node.childForFieldName('name') || findChild(node, 'identifier');
+  if (!nameNode) return;
+
+  const name = currentModule ? `${currentModule}.@${nameNode.text}` : `@${nameNode.text}`;
+  ctx.definitions.push({
+    name,
+    kind: 'function',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+  });
+}
+
+function handleImport(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const names: string[] = [];
+  let source = '';
+
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    if (
+      child.type === 'identifier' ||
+      child.type === 'scoped_identifier' ||
+      child.type === 'selected_import'
+    ) {
+      if (!source) source = child.text;
+      names.push(child.text.split('.').pop() || child.text);
+    }
+  }
+
+  if (source) {
+    ctx.imports.push({
+      source,
+      names: names.length > 0 ? names : [source],
+      line: node.startPosition.row + 1,
+    });
+  }
+}
+
+function handleCall(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  // Don't record if parent is assignment LHS (that's a function definition)
+  if (node.parent?.type === 'assignment' && node === node.parent.child(0)) return;
+  // Don't record if parent is function_definition (that's a signature)
+  if (node.parent?.type === 'function_definition') return;
+
+  const funcNode = node.child(0);
+  if (!funcNode) return;
+
+  if (funcNode.type === 'identifier') {
+    ctx.calls.push({ name: funcNode.text, line: node.startPosition.row + 1 });
+  } else if (funcNode.type === 'field_expression' || funcNode.type === 'scoped_identifier') {
+    const parts = funcNode.text.split('.');
+    if (parts.length >= 2) {
+      ctx.calls.push({
+        name: parts[parts.length - 1]!,
+        receiver: parts.slice(0, -1).join('.'),
+        line: node.startPosition.row + 1,
+      });
+    } else {
+      ctx.calls.push({ name: funcNode.text, line: node.startPosition.row + 1 });
+    }
+  }
+}
+
+function extractJuliaParams(callExpr: TreeSitterNode): SubDeclaration[] {
+  const params: SubDeclaration[] = [];
+  const argList = findChild(callExpr, 'argument_list') || findChild(callExpr, 'tuple_expression');
+  if (!argList) return params;
+
+  for (let i = 0; i < argList.childCount; i++) {
+    const child = argList.child(i);
+    if (!child) continue;
+    if (child.type === 'identifier') {
+      params.push({ name: child.text, kind: 'parameter', line: child.startPosition.row + 1 });
+    }
+    if (child.type === 'typed_parameter' || child.type === 'typed_expression') {
+      const nameNode = findChild(child, 'identifier');
+      if (nameNode) {
+        params.push({
+          name: nameNode.text,
+          kind: 'parameter',
+          line: child.startPosition.row + 1,
+        });
+      }
+    }
+    if (child.type === 'optional_parameter' || child.type === 'default_parameter') {
+      const nameNode = findChild(child, 'identifier');
+      if (nameNode) {
+        params.push({
+          name: nameNode.text,
+          kind: 'parameter',
+          line: child.startPosition.row + 1,
+        });
+      }
+    }
+  }
+  return params;
+}

package/src/extractors/kotlin.ts

@@ -81,48 +81,7 @@ function handleKotlinClassDecl(node: TreeSitterNode, ctx: ExtractorOutput): void
 
   const kind = isInterface ? 'interface' : isEnum ? 'enum' : 'class';
 
-  const children: SubDeclaration[] = [];
-  if (isEnum) {
-    // Enum entries are inside class_body
-    const body = findChild(node, 'class_body');
-    if (body) {
-      for (let i = 0; i < body.childCount; i++) {
-        const child = body.child(i);
-        if (child && child.type === 'enum_entry') {
-          const entryName = findChild(child, 'simple_identifier');
-          if (entryName) {
-            children.push({
-              name: entryName.text,
-              kind: 'constant',
-              line: child.startPosition.row + 1,
-            });
-          }
-        }
-      }
-    }
-  } else {
-    // Extract properties from class_body
-    const body = findChild(node, 'class_body');
-    if (body) {
-      for (let i = 0; i < body.childCount; i++) {
-        const child = body.child(i);
-        if (child && child.type === 'property_declaration') {
-          const propName = findChild(child, 'variable_declaration');
-          if (propName) {
-            const id = findChild(propName, 'simple_identifier');
-            if (id) {
-              children.push({
-                name: id.text,
-                kind: 'property',
-                line: child.startPosition.row + 1,
-                visibility: extractModifierVisibility(child),
-              });
-            }
-          }
-        }
-      }
-    }
-  }
+  const children = isEnum ? collectKotlinEnumEntries(node) : collectKotlinProperties(node);
 
   ctx.definitions.push({
     name,
@@ -132,27 +91,79 @@ function handleKotlinClassDecl(node: TreeSitterNode, ctx: ExtractorOutput): void
     children: children.length > 0 ? children : undefined,
   });
 
-  // Methods inside class_body
+  collectKotlinMethods(node, name, ctx);
+  collectKotlinInheritance(node, name, ctx);
+}
+
+/** Collect enum constant entries from a class_body. */
+function collectKotlinEnumEntries(node: TreeSitterNode): SubDeclaration[] {
+  const entries: SubDeclaration[] = [];
   const body = findChild(node, 'class_body');
-  if (body) {
-    for (let i = 0; i < body.childCount; i++) {
-      const child = body.child(i);
-      if (child && child.type === 'function_declaration') {
-        const methName = findChild(child, 'simple_identifier');
-        if (methName) {
-          ctx.definitions.push({
-            name: `${name}.${methName.text}`,
-            kind: 'method',
-            line: child.startPosition.row + 1,
-            endLine: child.endPosition.row + 1,
-            visibility: extractModifierVisibility(child),
-          });
-        }
-      }
+  if (!body) return entries;
+  for (let i = 0; i < body.childCount; i++) {
+    const child = body.child(i);
+    if (!child || child.type !== 'enum_entry') continue;
+    const entryName = findChild(child, 'simple_identifier');
+    if (entryName) {
+      entries.push({
+        name: entryName.text,
+        kind: 'constant',
+        line: child.startPosition.row + 1,
+      });
     }
   }
+  return entries;
+}
+
+/** Collect property declarations from a class_body. */
+function collectKotlinProperties(node: TreeSitterNode): SubDeclaration[] {
+  const props: SubDeclaration[] = [];
+  const body = findChild(node, 'class_body');
+  if (!body) return props;
+  for (let i = 0; i < body.childCount; i++) {
+    const child = body.child(i);
+    if (!child || child.type !== 'property_declaration') continue;
+    const varDecl = findChild(child, 'variable_declaration');
+    if (!varDecl) continue;
+    const id = findChild(varDecl, 'simple_identifier');
+    if (id) {
+      props.push({
+        name: id.text,
+        kind: 'property',
+        line: child.startPosition.row + 1,
+        visibility: extractModifierVisibility(child),
+      });
+    }
+  }
+  return props;
+}
+
+/** Collect method declarations from a class_body. */
+function collectKotlinMethods(node: TreeSitterNode, className: string, ctx: ExtractorOutput): void {
+  const body = findChild(node, 'class_body');
+  if (!body) return;
+  for (let i = 0; i < body.childCount; i++) {
+    const child = body.child(i);
+    if (!child || child.type !== 'function_declaration') continue;
+    const methName = findChild(child, 'simple_identifier');
+    if (methName) {
+      ctx.definitions.push({
+        name: `${className}.${methName.text}`,
+        kind: 'method',
+        line: child.startPosition.row + 1,
+        endLine: child.endPosition.row + 1,
+        visibility: extractModifierVisibility(child),
+      });
+    }
+  }
+}
 
-  // Inheritance: delegation_specifier nodes are DIRECT children
+/** Collect inheritance relationships from delegation_specifier children. */
+function collectKotlinInheritance(
+  node: TreeSitterNode,
+  className: string,
+  ctx: ExtractorOutput,
+): void {
   for (let i = 0; i < node.childCount; i++) {
     const child = node.child(i);
     if (!child || child.type !== 'delegation_specifier') continue;
@@ -161,30 +172,26 @@ function handleKotlinClassDecl(node: TreeSitterNode, ctx: ExtractorOutput): void
     const ctorInvocation = findChild(child, 'constructor_invocation');
     if (ctorInvocation) {
       const userType = findChild(ctorInvocation, 'user_type');
-      if (userType) {
-        const typeId = findChild(userType, 'type_identifier');
-        if (typeId) {
-          ctx.classes.push({
-            name,
-            extends: typeId.text,
-            line: node.startPosition.row + 1,
-          });
-        }
+      const typeId = userType ? findChild(userType, 'type_identifier') : null;
+      if (typeId) {
+        ctx.classes.push({
+          name: className,
+          extends: typeId.text,
+          line: node.startPosition.row + 1,
+        });
       }
       continue;
     }
 
     // user_type > type_identifier (implements)
     const userType = findChild(child, 'user_type');
-    if (userType) {
-      const typeId = findChild(userType, 'type_identifier');
-      if (typeId) {
-        ctx.classes.push({
-          name,
-          implements: typeId.text,
-          line: node.startPosition.row + 1,
-        });
-      }
+    const typeId = userType ? findChild(userType, 'type_identifier') : null;
+    if (typeId) {
+      ctx.classes.push({
+        name: className,
+        implements: typeId.text,
+        line: node.startPosition.row + 1,
+      });
     }
   }
 }