@optave/codegraph 3.7.0 → 3.8.1

package/src/extractors/groovy.ts

@@ -0,0 +1,332 @@
+import type {
+  Call,
+  ExtractorOutput,
+  SubDeclaration,
+  TreeSitterNode,
+  TreeSitterTree,
+} from '../types.js';
+import {
+  extractModifierVisibility,
+  findChild,
+  findParentNode,
+  lastPathSegment,
+  nodeEndLine,
+} from './helpers.js';
+
+/**
+ * Extract symbols from Groovy files.
+ *
+ * Groovy is a JVM language with Java-like class/interface/enum structures
+ * plus closures, traits, and dynamic typing. The tree-sitter-groovy grammar
+ * models classes, methods, imports, and call expressions similarly to Java.
+ */
+export function extractGroovySymbols(tree: TreeSitterTree, _filePath: string): ExtractorOutput {
+  const ctx: ExtractorOutput = {
+    definitions: [],
+    calls: [],
+    imports: [],
+    classes: [],
+    exports: [],
+    typeMap: new Map(),
+  };
+
+  walkGroovyNode(tree.rootNode, ctx);
+  return ctx;
+}
+
+function walkGroovyNode(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  switch (node.type) {
+    case 'class_definition':
+    case 'class_declaration':
+      handleGroovyClassDecl(node, ctx);
+      break;
+    case 'interface_definition':
+    case 'interface_declaration':
+      handleGroovyInterfaceDecl(node, ctx);
+      break;
+    case 'enum_definition':
+    case 'enum_declaration':
+      handleGroovyEnumDecl(node, ctx);
+      break;
+    case 'method_definition':
+    case 'method_declaration':
+      handleGroovyMethodDecl(node, ctx);
+      break;
+    case 'constructor_definition':
+    case 'constructor_declaration':
+      handleGroovyConstructorDecl(node, ctx);
+      break;
+    case 'function_definition':
+    case 'function_declaration':
+      handleGroovyFunctionDecl(node, ctx);
+      break;
+    case 'import_statement':
+    case 'import_declaration':
+      handleGroovyImport(node, ctx);
+      break;
+    case 'method_call':
+    case 'method_invocation':
+    case 'call_expression':
+    case 'function_call':
+      handleGroovyCallExpr(node, ctx);
+      break;
+    case 'object_creation_expression':
+      handleGroovyObjectCreation(node, ctx);
+      break;
+  }
+
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) walkGroovyNode(child, ctx);
+  }
+}
+
+// ── Handlers ───────────────────────────────────────────────────────────────
+
+const GROOVY_PARENT_TYPES = [
+  'class_definition',
+  'class_declaration',
+  'enum_definition',
+  'enum_declaration',
+  'interface_definition',
+  'interface_declaration',
+] as const;
+
+function handleGroovyClassDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const nameNode = node.childForFieldName('name');
+  if (!nameNode) return;
+  const name = nameNode.text;
+
+  const members = extractGroovyClassMembers(node);
+  ctx.definitions.push({
+    name,
+    kind: 'class',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+    children: members.length > 0 ? members : undefined,
+    visibility: extractModifierVisibility(node),
+  });
+
+  // Superclass
+  const superclass = node.childForFieldName('superclass');
+  if (superclass) {
+    const superName =
+      superclass.type === 'generic_type' ? superclass.child(0)?.text : superclass.text;
+    if (superName) {
+      ctx.classes.push({ name, extends: superName, line: node.startPosition.row + 1 });
+    }
+  }
+
+  // Interfaces
+  const interfaces = node.childForFieldName('interfaces');
+  if (interfaces) {
+    for (let i = 0; i < interfaces.childCount; i++) {
+      const iface = interfaces.child(i);
+      if (
+        iface &&
+        (iface.type === 'type_identifier' ||
+          iface.type === 'identifier' ||
+          iface.type === 'generic_type')
+      ) {
+        const ifaceName = iface.type === 'generic_type' ? iface.child(0)?.text : iface.text;
+        if (ifaceName) {
+          ctx.classes.push({ name, implements: ifaceName, line: node.startPosition.row + 1 });
+        }
+      }
+    }
+  }
+}
+
+function handleGroovyInterfaceDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const nameNode = node.childForFieldName('name');
+  if (!nameNode) return;
+
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'interface',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+    visibility: extractModifierVisibility(node),
+  });
+}
+
+function handleGroovyEnumDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const nameNode = node.childForFieldName('name');
+  if (!nameNode) return;
+
+  const members: SubDeclaration[] = [];
+  const body = node.childForFieldName('body') || findChild(node, 'enum_body');
+  if (body) {
+    for (let i = 0; i < body.childCount; i++) {
+      const child = body.child(i);
+      if (!child) continue;
+      if (child.type === 'enum_constant' || child.type === 'identifier') {
+        const constName = child.childForFieldName('name') || child;
+        members.push({ name: constName.text, kind: 'constant', line: child.startPosition.row + 1 });
+      }
+    }
+  }
+
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'enum',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+    children: members.length > 0 ? members : undefined,
+  });
+}
+
+function handleGroovyMethodDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const nameNode = node.childForFieldName('name');
+  if (!nameNode) return;
+  const parentClass = findParentNode(node, GROOVY_PARENT_TYPES);
+  const fullName = parentClass ? `${parentClass}.${nameNode.text}` : nameNode.text;
+
+  const params = extractGroovyParams(node);
+  ctx.definitions.push({
+    name: fullName,
+    kind: 'method',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+    children: params.length > 0 ? params : undefined,
+    visibility: extractModifierVisibility(node),
+  });
+}
+
+function handleGroovyConstructorDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const nameNode = node.childForFieldName('name');
+  if (!nameNode) return;
+  const parentClass = findParentNode(node, GROOVY_PARENT_TYPES);
+  const fullName = parentClass ? `${parentClass}.${nameNode.text}` : nameNode.text;
+
+  const params = extractGroovyParams(node);
+  ctx.definitions.push({
+    name: fullName,
+    kind: 'method',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+    children: params.length > 0 ? params : undefined,
+    visibility: extractModifierVisibility(node),
+  });
+}
+
+function handleGroovyFunctionDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const nameNode = node.childForFieldName('name');
+  if (!nameNode) return;
+
+  const params = extractGroovyParams(node);
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'function',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+    children: params.length > 0 ? params : undefined,
+  });
+}
+
+function handleGroovyImport(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  // import foo.bar.Baz or import foo.bar.*
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    if (
+      child.type === 'dotted_identifier' ||
+      child.type === 'scoped_identifier' ||
+      child.type === 'identifier' ||
+      child.type === 'qualified_name'
+    ) {
+      const fullPath = child.text;
+      const lastName = lastPathSegment(fullPath, '.');
+      ctx.imports.push({
+        source: fullPath,
+        names: [lastName],
+        line: node.startPosition.row + 1,
+        javaImport: true,
+      });
+      return;
+    }
+  }
+}
+
+function handleGroovyCallExpr(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const call: Call = { name: '', line: node.startPosition.row + 1 };
+
+  // Try standard call_expression pattern
+  const funcNode = node.childForFieldName('function') || node.childForFieldName('method');
+  if (funcNode) {
+    if (funcNode.type === 'field_expression' || funcNode.type === 'member_access') {
+      const field = funcNode.childForFieldName('field') || funcNode.childForFieldName('property');
+      const obj = funcNode.childForFieldName('argument') || funcNode.childForFieldName('object');
+      if (field) call.name = field.text;
+      if (obj) call.receiver = obj.text;
+    } else {
+      call.name = funcNode.text;
+    }
+  } else {
+    // method_call: first child is receiver/name
+    const nameNode = node.childForFieldName('name');
+    const obj = node.childForFieldName('object');
+    if (nameNode) {
+      call.name = nameNode.text;
+      if (obj) call.receiver = obj.text;
+    }
+  }
+
+  if (call.name) ctx.calls.push(call);
+}
+
+function handleGroovyObjectCreation(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const typeNode = node.childForFieldName('type');
+  if (!typeNode) return;
+  const typeName = typeNode.type === 'generic_type' ? typeNode.child(0)?.text : typeNode.text;
+  if (typeName) ctx.calls.push({ name: typeName, line: node.startPosition.row + 1 });
+}
+
+// ── Helpers ────────────────────────────────────────────────────────────────
+
+function extractGroovyParams(funcNode: TreeSitterNode): SubDeclaration[] {
+  const params: SubDeclaration[] = [];
+  const paramList =
+    funcNode.childForFieldName('parameters') || findChild(funcNode, 'formal_parameters');
+  if (!paramList) return params;
+
+  for (let i = 0; i < paramList.childCount; i++) {
+    const param = paramList.child(i);
+    if (!param) continue;
+    if (param.type === 'formal_parameter' || param.type === 'parameter') {
+      const nameNode = param.childForFieldName('name');
+      if (nameNode) {
+        params.push({ name: nameNode.text, kind: 'parameter', line: param.startPosition.row + 1 });
+      }
+    }
+  }
+  return params;
+}
+
+function extractGroovyClassMembers(classNode: TreeSitterNode): SubDeclaration[] {
+  const members: SubDeclaration[] = [];
+  const body = classNode.childForFieldName('body') || findChild(classNode, 'class_body');
+  if (!body) return members;
+
+  for (let i = 0; i < body.childCount; i++) {
+    const child = body.child(i);
+    if (!child) continue;
+    if (child.type === 'field_declaration') {
+      for (let j = 0; j < child.childCount; j++) {
+        const varDecl = child.child(j);
+        if (varDecl?.type === 'variable_declarator') {
+          const nameNode = varDecl.childForFieldName('name');
+          if (nameNode) {
+            members.push({
+              name: nameNode.text,
+              kind: 'property',
+              line: child.startPosition.row + 1,
+              visibility: extractModifierVisibility(child),
+            });
+          }
+        }
+      }
+    }
+  }
+  return members;
+}

package/src/extractors/helpers.ts

@@ -110,6 +110,20 @@ export function findParentNode(
   return null;
 }
 
+/**
+ * Resolve a container's body node by trying each field name in order.
+ */
+function resolveBodyNode(
+  containerNode: TreeSitterNode,
+  bodyFields: readonly string[],
+): TreeSitterNode | null {
+  for (const field of bodyFields) {
+    const body = containerNode.childForFieldName(field) || findChild(containerNode, field);
+    if (body) return body;
+  }
+  return null;
+}
+
 /**
  * Extract child declarations from a container node's body.
  * Finds the body via `bodyFields` (tries childForFieldName then findChild for each),
@@ -126,22 +140,17 @@ export function extractBodyMembers(
   nameField: string = 'name',
   visibility?: (member: TreeSitterNode) => SubDeclaration['visibility'],
 ): SubDeclaration[] {
+  const body = resolveBodyNode(containerNode, bodyFields);
+  if (!body) return [];
   const members: SubDeclaration[] = [];
-  let body: TreeSitterNode | null = null;
-  for (const field of bodyFields) {
-    body = containerNode.childForFieldName(field) || findChild(containerNode, field);
-    if (body) break;
-  }
-  if (!body) return members;
   for (let i = 0; i < body.childCount; i++) {
     const member = body.child(i);
     if (!member || member.type !== memberType) continue;
     const nn = member.childForFieldName(nameField);
-    if (nn) {
-      const entry: SubDeclaration = { name: nn.text, kind, line: member.startPosition.row + 1 };
-      if (visibility) entry.visibility = visibility(member);
-      members.push(entry);
-    }
+    if (!nn) continue;
+    const entry: SubDeclaration = { name: nn.text, kind, line: member.startPosition.row + 1 };
+    if (visibility) entry.visibility = visibility(member);
+    members.push(entry);
   }
   return members;
 }
@@ -162,24 +171,29 @@ export function lastPathSegment(path: string, separator: string = '/'): string {
   return path.split(separator).pop() ?? path;
 }
 
+/**
+ * Parse visibility from a modifier node's text content.
+ */
+function parseModifierText(text: string): 'public' | 'private' | 'protected' | undefined {
+  if (VISIBILITY_KEYWORDS.has(text)) return text as 'public' | 'private' | 'protected';
+  // C# 'private protected' — accessible to derived types in same assembly → protected
+  if (text === 'private protected') return 'protected';
+  // Compound modifiers node (Java: "public static") — scan its text for a keyword
+  for (const kw of VISIBILITY_KEYWORDS) {
+    if (text.includes(kw)) return kw as 'public' | 'private' | 'protected';
+  }
+  return undefined;
+}
+
 export function extractModifierVisibility(
   node: TreeSitterNode,
   modifierTypes: Set<string> = DEFAULT_MODIFIER_TYPES,
 ): 'public' | 'private' | 'protected' | undefined {
   for (let i = 0; i < node.childCount; i++) {
     const child = node.child(i);
-    if (!child) continue;
-    // Direct keyword match (e.g., PHP visibility_modifier = "public")
-    if (modifierTypes.has(child.type)) {
-      const text = child.text;
-      if (VISIBILITY_KEYWORDS.has(text)) return text as 'public' | 'private' | 'protected';
-      // C# 'private protected' — accessible to derived types in same assembly → protected
-      if (text === 'private protected') return 'protected';
-      // Compound modifiers node (Java: "public static") — scan its text for a keyword
-      for (const kw of VISIBILITY_KEYWORDS) {
-        if (text.includes(kw)) return kw as 'public' | 'private' | 'protected';
-      }
-    }
+    if (!child || !modifierTypes.has(child.type)) continue;
+    const result = parseModifierText(child.text);
+    if (result) return result;
   }
   return undefined;
 }

package/src/extractors/index.ts

@@ -1,21 +1,32 @@
 export { extractBashSymbols } from './bash.js';
 export { extractCSymbols } from './c.js';
+export { extractClojureSymbols } from './clojure.js';
 export { extractCppSymbols } from './cpp.js';
 export { extractCSharpSymbols } from './csharp.js';
+export { extractCudaSymbols } from './cuda.js';
 export { extractDartSymbols } from './dart.js';
 export { extractElixirSymbols } from './elixir.js';
+export { extractErlangSymbols } from './erlang.js';
+export { extractFSharpSymbols } from './fsharp.js';
+export { extractGleamSymbols } from './gleam.js';
 export { extractGoSymbols } from './go.js';
+export { extractGroovySymbols } from './groovy.js';
 export { extractHaskellSymbols } from './haskell.js';
 export { extractHCLSymbols } from './hcl.js';
 export { extractJavaSymbols } from './java.js';
 export { extractSymbols } from './javascript.js';
+export { extractJuliaSymbols } from './julia.js';
 export { extractKotlinSymbols } from './kotlin.js';
 export { extractLuaSymbols } from './lua.js';
+export { extractObjCSymbols } from './objc.js';
 export { extractOCamlSymbols } from './ocaml.js';
 export { extractPHPSymbols } from './php.js';
 export { extractPythonSymbols } from './python.js';
+export { extractRSymbols } from './r.js';
 export { extractRubySymbols } from './ruby.js';
 export { extractRustSymbols } from './rust.js';
 export { extractScalaSymbols } from './scala.js';
+export { extractSoliditySymbols } from './solidity.js';
 export { extractSwiftSymbols } from './swift.js';
+export { extractVerilogSymbols } from './verilog.js';
 export { extractZigSymbols } from './zig.js';

package/src/extractors/java.ts

@@ -83,27 +83,7 @@ function handleJavaClassDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
     children: classChildren.length > 0 ? classChildren : undefined,
   });
 
-  const superclass = node.childForFieldName('superclass');
-  if (superclass) {
-    for (let i = 0; i < superclass.childCount; i++) {
-      const child = superclass.child(i);
-      if (
-        child &&
-        (child.type === 'type_identifier' ||
-          child.type === 'identifier' ||
-          child.type === 'generic_type')
-      ) {
-        const superName = child.type === 'generic_type' ? child.child(0)?.text : child.text;
-        if (superName)
-          ctx.classes.push({
-            name: nameNode.text,
-            extends: superName,
-            line: node.startPosition.row + 1,
-          });
-        break;
-      }
-    }
-  }
+  extractJavaSuperclass(node, nameNode.text, ctx);
 
   const interfaces = node.childForFieldName('interfaces');
   if (interfaces) {
@@ -111,6 +91,32 @@ function handleJavaClassDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
   }
 }
 
+/** Extract the superclass (extends) relationship from a Java class declaration. */
+function extractJavaSuperclass(
+  node: TreeSitterNode,
+  className: string,
+  ctx: ExtractorOutput,
+): void {
+  const superclass = node.childForFieldName('superclass');
+  if (!superclass) return;
+  const superName = findJavaSuperTypeName(superclass);
+  if (superName) {
+    ctx.classes.push({ name: className, extends: superName, line: node.startPosition.row + 1 });
+  }
+}
+
+/** Find the type name from a superclass node (handles generic_type unwrapping). */
+function findJavaSuperTypeName(superclass: TreeSitterNode): string | undefined {
+  for (let i = 0; i < superclass.childCount; i++) {
+    const child = superclass.child(i);
+    if (!child) continue;
+    if (JAVA_TYPE_NODE_TYPES.has(child.type)) {
+      return resolveJavaIfaceName(child);
+    }
+  }
+  return undefined;
+}
+
 const JAVA_TYPE_NODE_TYPES = new Set(['type_identifier', 'identifier', 'generic_type']);
 
 /** Resolve interface name from a type node (handles generic_type unwrapping). */
@@ -161,19 +167,26 @@ function handleJavaInterfaceDecl(node: TreeSitterNode, ctx: ExtractorOutput): vo
     endLine: nodeEndLine(node),
   });
   const body = node.childForFieldName('body');
-  if (body) {
-    for (let i = 0; i < body.childCount; i++) {
-      const child = body.child(i);
-      if (child && child.type === 'method_declaration') {
-        const methName = child.childForFieldName('name');
-        if (methName) {
-          ctx.definitions.push({
-            name: `${nameNode.text}.${methName.text}`,
-            kind: 'method',
-            line: child.startPosition.row + 1,
-            endLine: child.endPosition.row + 1,
-          });
-        }
+  if (body) extractJavaInterfaceMethods(body, nameNode.text, ctx);
+}
+
+/** Extract method declarations from a Java interface body. */
+function extractJavaInterfaceMethods(
+  body: TreeSitterNode,
+  ifaceName: string,
+  ctx: ExtractorOutput,
+): void {
+  for (let i = 0; i < body.childCount; i++) {
+    const child = body.child(i);
+    if (child && child.type === 'method_declaration') {
+      const methName = child.childForFieldName('name');
+      if (methName) {
+        ctx.definitions.push({
+          name: `${ifaceName}.${methName.text}`,
+          kind: 'method',
+          line: child.startPosition.row + 1,
+          endLine: child.endPosition.row + 1,
+        });
       }
     }
   }
@@ -321,23 +334,29 @@ function extractClassFields(classNode: TreeSitterNode): SubDeclaration[] {
   for (let i = 0; i < body.childCount; i++) {
     const member = body.child(i);
     if (!member || member.type !== 'field_declaration') continue;
-    for (let j = 0; j < member.childCount; j++) {
-      const child = member.child(j);
-      if (!child || child.type !== 'variable_declarator') continue;
-      const nameNode = child.childForFieldName('name');
-      if (nameNode) {
-        fields.push({
-          name: nameNode.text,
-          kind: 'property',
-          line: member.startPosition.row + 1,
-          visibility: extractModifierVisibility(member),
-        });
-      }
-    }
+    extractFieldDeclarators(member, fields);
   }
   return fields;
 }
 
+/** Extract variable_declarator names from a field_declaration node. */
+function extractFieldDeclarators(member: TreeSitterNode, fields: SubDeclaration[]): void {
+  const vis = extractModifierVisibility(member);
+  for (let j = 0; j < member.childCount; j++) {
+    const child = member.child(j);
+    if (!child || child.type !== 'variable_declarator') continue;
+    const nameNode = child.childForFieldName('name');
+    if (nameNode) {
+      fields.push({
+        name: nameNode.text,
+        kind: 'property',
+        line: member.startPosition.row + 1,
+        visibility: vis,
+      });
+    }
+  }
+}
+
 function extractEnumConstants(enumNode: TreeSitterNode): SubDeclaration[] {
   return extractBodyMembers(enumNode, ['body', 'enum_body'], 'enum_constant', 'constant');
 }