@optave/codegraph 2.6.0 → 3.0.1

package/src/extractors/go.js

@@ -1,4 +1,4 @@
-import { nodeEndLine } from './helpers.js';
+import { findChild, nodeEndLine } from './helpers.js';
 
 /**
  * Extract symbols from Go files.
@@ -15,11 +15,13 @@ export function extractGoSymbols(tree, _filePath) {
       case 'function_declaration': {
         const nameNode = node.childForFieldName('name');
         if (nameNode) {
+          const params = extractGoParameters(node.childForFieldName('parameters'));
           definitions.push({
             name: nameNode.text,
             kind: 'function',
             line: node.startPosition.row + 1,
             endLine: nodeEndLine(node),
+            children: params.length > 0 ? params : undefined,
           });
         }
         break;
@@ -46,11 +48,13 @@ export function extractGoSymbols(tree, _filePath) {
             }
           }
           const fullName = receiverType ? `${receiverType}.${nameNode.text}` : nameNode.text;
+          const params = extractGoParameters(node.childForFieldName('parameters'));
           definitions.push({
             name: fullName,
             kind: 'method',
             line: node.startPosition.row + 1,
             endLine: nodeEndLine(node),
+            children: params.length > 0 ? params : undefined,
           });
         }
         break;
@@ -64,11 +68,13 @@ export function extractGoSymbols(tree, _filePath) {
           const typeNode = spec.childForFieldName('type');
           if (nameNode && typeNode) {
             if (typeNode.type === 'struct_type') {
+              const fields = extractStructFields(typeNode);
               definitions.push({
                 name: nameNode.text,
                 kind: 'struct',
                 line: node.startPosition.row + 1,
                 endLine: nodeEndLine(node),
+                children: fields.length > 0 ? fields : undefined,
               });
             } else if (typeNode.type === 'interface_type') {
               definitions.push({
@@ -145,6 +151,23 @@ export function extractGoSymbols(tree, _filePath) {
         break;
       }
 
+      case 'const_declaration': {
+        for (let i = 0; i < node.childCount; i++) {
+          const spec = node.child(i);
+          if (!spec || spec.type !== 'const_spec') continue;
+          const constName = spec.childForFieldName('name');
+          if (constName) {
+            definitions.push({
+              name: constName.text,
+              kind: 'constant',
+              line: spec.startPosition.row + 1,
+              endLine: spec.endPosition.row + 1,
+            });
+          }
+        }
+        break;
+      }
+
       case 'call_expression': {
         const fn = node.childForFieldName('function');
         if (fn) {
@@ -170,3 +193,45 @@ export function extractGoSymbols(tree, _filePath) {
   walkGoNode(tree.rootNode);
   return { definitions, calls, imports, classes, exports };
 }
+
+// ── Child extraction helpers ────────────────────────────────────────────────
+
+function extractGoParameters(paramListNode) {
+  const params = [];
+  if (!paramListNode) return params;
+  for (let i = 0; i < paramListNode.childCount; i++) {
+    const param = paramListNode.child(i);
+    if (!param || param.type !== 'parameter_declaration') continue;
+    // A parameter_declaration may have multiple identifiers (e.g., `a, b int`)
+    for (let j = 0; j < param.childCount; j++) {
+      const child = param.child(j);
+      if (child && child.type === 'identifier') {
+        params.push({ name: child.text, kind: 'parameter', line: child.startPosition.row + 1 });
+      }
+    }
+  }
+  return params;
+}
+
+function extractStructFields(structTypeNode) {
+  const fields = [];
+  const fieldList = findChild(structTypeNode, 'field_declaration_list');
+  if (!fieldList) return fields;
+  for (let i = 0; i < fieldList.childCount; i++) {
+    const field = fieldList.child(i);
+    if (!field || field.type !== 'field_declaration') continue;
+    const nameNode = field.childForFieldName('name');
+    if (nameNode) {
+      fields.push({ name: nameNode.text, kind: 'property', line: field.startPosition.row + 1 });
+    } else {
+      // Struct fields may have multiple names or use first identifier child
+      for (let j = 0; j < field.childCount; j++) {
+        const child = field.child(j);
+        if (child && child.type === 'field_identifier') {
+          fields.push({ name: child.text, kind: 'property', line: field.startPosition.row + 1 });
+        }
+      }
+    }
+  }
+  return fields;
+}

package/src/extractors/hcl.js

@@ -36,11 +36,33 @@ export function extractHCLSymbols(tree, _filePath) {
         }
 
         if (name) {
+          // Extract attributes as property children for variable/output blocks
+          let blockChildren;
+          if (blockType === 'variable' || blockType === 'output') {
+            blockChildren = [];
+            const body = children.find((c) => c.type === 'body');
+            if (body) {
+              for (let j = 0; j < body.childCount; j++) {
+                const attr = body.child(j);
+                if (attr && attr.type === 'attribute') {
+                  const key = attr.childForFieldName('key') || attr.child(0);
+                  if (key) {
+                    blockChildren.push({
+                      name: key.text,
+                      kind: 'property',
+                      line: attr.startPosition.row + 1,
+                    });
+                  }
+                }
+              }
+            }
+          }
           definitions.push({
             name,
             kind: blockType,
             line: node.startPosition.row + 1,
             endLine: nodeEndLine(node),
+            children: blockChildren?.length > 0 ? blockChildren : undefined,
           });
         }
 

package/src/extractors/java.js

@@ -1,4 +1,4 @@
-import { nodeEndLine } from './helpers.js';
+import { findChild, nodeEndLine } from './helpers.js';
 
 /**
  * Extract symbols from Java files.
@@ -31,11 +31,13 @@ export function extractJavaSymbols(tree, _filePath) {
       case 'class_declaration': {
         const nameNode = node.childForFieldName('name');
         if (nameNode) {
+          const classChildren = extractClassFields(node);
           definitions.push({
             name: nameNode.text,
             kind: 'class',
             line: node.startPosition.row + 1,
             endLine: nodeEndLine(node),
+            children: classChildren.length > 0 ? classChildren : undefined,
           });
 
           const superclass = node.childForFieldName('superclass');
@@ -139,11 +141,13 @@ export function extractJavaSymbols(tree, _filePath) {
       case 'enum_declaration': {
         const nameNode = node.childForFieldName('name');
         if (nameNode) {
+          const enumChildren = extractEnumConstants(node);
           definitions.push({
             name: nameNode.text,
             kind: 'enum',
             line: node.startPosition.row + 1,
             endLine: nodeEndLine(node),
+            children: enumChildren.length > 0 ? enumChildren : undefined,
           });
         }
         break;
@@ -154,11 +158,13 @@ export function extractJavaSymbols(tree, _filePath) {
         if (nameNode) {
           const parentClass = findJavaParentClass(node);
           const fullName = parentClass ? `${parentClass}.${nameNode.text}` : nameNode.text;
+          const params = extractJavaParameters(node.childForFieldName('parameters'));
           definitions.push({
             name: fullName,
             kind: 'method',
             line: node.startPosition.row + 1,
             endLine: nodeEndLine(node),
+            children: params.length > 0 ? params : undefined,
           });
         }
         break;
@@ -169,11 +175,13 @@ export function extractJavaSymbols(tree, _filePath) {
         if (nameNode) {
           const parentClass = findJavaParentClass(node);
           const fullName = parentClass ? `${parentClass}.${nameNode.text}` : nameNode.text;
+          const params = extractJavaParameters(node.childForFieldName('parameters'));
           definitions.push({
             name: fullName,
             kind: 'method',
             line: node.startPosition.row + 1,
             endLine: nodeEndLine(node),
+            children: params.length > 0 ? params : undefined,
           });
         }
         break;
@@ -228,3 +236,55 @@ export function extractJavaSymbols(tree, _filePath) {
   walkJavaNode(tree.rootNode);
   return { definitions, calls, imports, classes, exports };
 }
+
+// ── Child extraction helpers ────────────────────────────────────────────────
+
+function extractJavaParameters(paramListNode) {
+  const params = [];
+  if (!paramListNode) return params;
+  for (let i = 0; i < paramListNode.childCount; i++) {
+    const param = paramListNode.child(i);
+    if (!param) continue;
+    if (param.type === 'formal_parameter' || param.type === 'spread_parameter') {
+      const nameNode = param.childForFieldName('name');
+      if (nameNode) {
+        params.push({ name: nameNode.text, kind: 'parameter', line: param.startPosition.row + 1 });
+      }
+    }
+  }
+  return params;
+}
+
+function extractClassFields(classNode) {
+  const fields = [];
+  const body = classNode.childForFieldName('body') || findChild(classNode, 'class_body');
+  if (!body) return fields;
+  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 });
+      }
+    }
+  }
+  return fields;
+}
+
+function extractEnumConstants(enumNode) {
+  const constants = [];
+  const body = enumNode.childForFieldName('body') || findChild(enumNode, 'enum_body');
+  if (!body) return constants;
+  for (let i = 0; i < body.childCount; i++) {
+    const member = body.child(i);
+    if (!member || member.type !== 'enum_constant') continue;
+    const nameNode = member.childForFieldName('name');
+    if (nameNode) {
+      constants.push({ name: nameNode.text, kind: 'constant', line: member.startPosition.row + 1 });
+    }
+  }
+  return constants;
+}

package/src/extractors/javascript.js

@@ -28,31 +28,37 @@ function extractSymbolsQuery(tree, query) {
 
     if (c.fn_node) {
       // function_declaration
+      const fnChildren = extractParameters(c.fn_node);
       definitions.push({
         name: c.fn_name.text,
         kind: 'function',
         line: c.fn_node.startPosition.row + 1,
         endLine: nodeEndLine(c.fn_node),
+        children: fnChildren.length > 0 ? fnChildren : undefined,
       });
     } else if (c.varfn_name) {
       // variable_declarator with arrow_function / function_expression
       const declNode = c.varfn_name.parent?.parent;
       const line = declNode ? declNode.startPosition.row + 1 : c.varfn_name.startPosition.row + 1;
+      const varFnChildren = extractParameters(c.varfn_value);
       definitions.push({
         name: c.varfn_name.text,
         kind: 'function',
         line,
         endLine: nodeEndLine(c.varfn_value),
+        children: varFnChildren.length > 0 ? varFnChildren : undefined,
       });
     } else if (c.cls_node) {
       // class_declaration
       const className = c.cls_name.text;
       const startLine = c.cls_node.startPosition.row + 1;
+      const clsChildren = extractClassProperties(c.cls_node);
       definitions.push({
         name: className,
         kind: 'class',
         line: startLine,
         endLine: nodeEndLine(c.cls_node),
+        children: clsChildren.length > 0 ? clsChildren : undefined,
       });
       const heritage =
         c.cls_node.childForFieldName('heritage') || findChild(c.cls_node, 'class_heritage');
@@ -69,11 +75,13 @@ function extractSymbolsQuery(tree, query) {
       const methName = c.meth_name.text;
       const parentClass = findParentClass(c.meth_node);
       const fullName = parentClass ? `${parentClass}.${methName}` : methName;
+      const methChildren = extractParameters(c.meth_node);
       definitions.push({
         name: fullName,
         kind: 'method',
         line: c.meth_node.startPosition.row + 1,
         endLine: nodeEndLine(c.meth_node),
+        children: methChildren.length > 0 ? methChildren : undefined,
       });
     } else if (c.iface_node) {
       // interface_declaration (TS/TSX only)
@@ -162,9 +170,60 @@ function extractSymbolsQuery(tree, query) {
     }
   }
 
+  // Extract top-level constants via targeted walk (query patterns don't cover these)
+  extractConstantsWalk(tree.rootNode, definitions);
+
   return { definitions, calls, imports, classes, exports: exps };
 }
 
+/**
+ * Walk program-level children to extract `const x = <literal>` as constants.
+ * The query-based fast path has no pattern for lexical_declaration/variable_declaration,
+ * so constants are missed. This targeted walk fills that gap without a full tree traversal.
+ */
+function extractConstantsWalk(rootNode, definitions) {
+  for (let i = 0; i < rootNode.childCount; i++) {
+    const node = rootNode.child(i);
+    if (!node) continue;
+
+    let declNode = node;
+    // Handle `export const …` — unwrap the export_statement to its declaration child
+    if (node.type === 'export_statement') {
+      const inner = node.childForFieldName('declaration');
+      if (!inner) continue;
+      declNode = inner;
+    }
+
+    const t = declNode.type;
+    if (t !== 'lexical_declaration' && t !== 'variable_declaration') continue;
+    if (!declNode.text.startsWith('const ')) continue;
+
+    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),
+        });
+      }
+    }
+  }
+}
+
 function handleCommonJSAssignment(left, right, node, imports) {
   if (!left || !right) return;
   const leftText = left.text;
@@ -231,11 +290,13 @@ function extractSymbolsWalk(tree) {
       case 'function_declaration': {
         const nameNode = node.childForFieldName('name');
         if (nameNode) {
+          const fnChildren = extractParameters(node);
           definitions.push({
             name: nameNode.text,
             kind: 'function',
             line: node.startPosition.row + 1,
             endLine: nodeEndLine(node),
+            children: fnChildren.length > 0 ? fnChildren : undefined,
           });
         }
         break;
@@ -246,11 +307,13 @@ function extractSymbolsWalk(tree) {
         if (nameNode) {
           const className = nameNode.text;
           const startLine = node.startPosition.row + 1;
+          const clsChildren = extractClassProperties(node);
           definitions.push({
             name: className,
             kind: 'class',
             line: startLine,
             endLine: nodeEndLine(node),
+            children: clsChildren.length > 0 ? clsChildren : undefined,
           });
           const heritage = node.childForFieldName('heritage') || findChild(node, 'class_heritage');
           if (heritage) {
@@ -272,11 +335,13 @@ function extractSymbolsWalk(tree) {
         if (nameNode) {
           const parentClass = findParentClass(node);
           const fullName = parentClass ? `${parentClass}.${nameNode.text}` : nameNode.text;
+          const methChildren = extractParameters(node);
           definitions.push({
             name: fullName,
             kind: 'method',
             line: node.startPosition.row + 1,
             endLine: nodeEndLine(node),
+            children: methChildren.length > 0 ? methChildren : undefined,
           });
         }
         break;
@@ -317,6 +382,7 @@ function extractSymbolsWalk(tree) {
 
       case 'lexical_declaration':
       case 'variable_declaration': {
+        const isConst = node.text.startsWith('const ');
         for (let i = 0; i < node.childCount; i++) {
           const declarator = node.child(i);
           if (declarator && declarator.type === 'variable_declarator') {
@@ -329,15 +395,59 @@ function extractSymbolsWalk(tree) {
                 valType === 'function_expression' ||
                 valType === 'function'
               ) {
+                const varFnChildren = extractParameters(valueN);
                 definitions.push({
                   name: nameN.text,
                   kind: 'function',
                   line: node.startPosition.row + 1,
                   endLine: nodeEndLine(valueN),
+                  children: varFnChildren.length > 0 ? varFnChildren : undefined,
                 });
+              } else if (isConst && nameN.type === 'identifier' && isConstantValue(valueN)) {
+                definitions.push({
+                  name: nameN.text,
+                  kind: 'constant',
+                  line: node.startPosition.row + 1,
+                  endLine: nodeEndLine(node),
+                });
+              }
+            } else if (isConst && nameN && nameN.type === 'identifier' && !valueN) {
+              // const with no value (shouldn't happen but be safe)
+            }
+          }
+        }
+        break;
+      }
+
+      case 'enum_declaration': {
+        // TypeScript enum
+        const nameNode = node.childForFieldName('name');
+        if (nameNode) {
+          const enumChildren = [];
+          const body = node.childForFieldName('body') || findChild(node, 'enum_body');
+          if (body) {
+            for (let i = 0; i < body.childCount; i++) {
+              const member = body.child(i);
+              if (!member) continue;
+              if (member.type === 'enum_assignment' || member.type === 'property_identifier') {
+                const mName = member.childForFieldName('name') || member.child(0);
+                if (mName) {
+                  enumChildren.push({
+                    name: mName.text,
+                    kind: 'constant',
+                    line: member.startPosition.row + 1,
+                  });
+                }
               }
             }
           }
+          definitions.push({
+            name: nameNode.text,
+            kind: 'enum',
+            line: node.startPosition.row + 1,
+            endLine: nodeEndLine(node),
+            children: enumChildren.length > 0 ? enumChildren : undefined,
+          });
         }
         break;
       }
@@ -471,6 +581,89 @@ function extractSymbolsWalk(tree) {
   return { definitions, calls, imports, classes, exports };
 }
 
+// ── Child extraction helpers ────────────────────────────────────────────────
+
+function extractParameters(node) {
+  const params = [];
+  const paramsNode = node.childForFieldName('parameters') || findChild(node, 'formal_parameters');
+  if (!paramsNode) return params;
+  for (let i = 0; i < paramsNode.childCount; i++) {
+    const child = paramsNode.child(i);
+    if (!child) continue;
+    const t = child.type;
+    if (t === 'identifier') {
+      params.push({ name: child.text, kind: 'parameter', line: child.startPosition.row + 1 });
+    } else if (
+      t === 'required_parameter' ||
+      t === 'optional_parameter' ||
+      t === 'assignment_pattern'
+    ) {
+      const nameNode =
+        child.childForFieldName('pattern') || child.childForFieldName('left') || child.child(0);
+      if (
+        nameNode &&
+        (nameNode.type === 'identifier' ||
+          nameNode.type === 'shorthand_property_identifier_pattern')
+      ) {
+        params.push({ name: nameNode.text, kind: 'parameter', line: child.startPosition.row + 1 });
+      }
+    } else if (t === 'rest_pattern' || t === 'rest_element') {
+      const nameNode = child.child(1) || child.childForFieldName('name');
+      if (nameNode && nameNode.type === 'identifier') {
+        params.push({ name: nameNode.text, kind: 'parameter', line: child.startPosition.row + 1 });
+      }
+    }
+  }
+  return params;
+}
+
+function extractClassProperties(classNode) {
+  const props = [];
+  const body = classNode.childForFieldName('body') || findChild(classNode, 'class_body');
+  if (!body) return props;
+  for (let i = 0; i < body.childCount; i++) {
+    const child = body.child(i);
+    if (!child) continue;
+    if (
+      child.type === 'field_definition' ||
+      child.type === 'public_field_definition' ||
+      child.type === 'property_definition'
+    ) {
+      const nameNode =
+        child.childForFieldName('name') || child.childForFieldName('property') || child.child(0);
+      if (
+        nameNode &&
+        (nameNode.type === 'property_identifier' ||
+          nameNode.type === 'identifier' ||
+          nameNode.type === 'private_property_identifier')
+      ) {
+        props.push({ name: nameNode.text, kind: 'property', line: child.startPosition.row + 1 });
+      }
+    }
+  }
+  return props;
+}
+
+function isConstantValue(valueNode) {
+  if (!valueNode) return false;
+  const t = valueNode.type;
+  return (
+    t === 'number' ||
+    t === 'string' ||
+    t === 'template_string' ||
+    t === 'true' ||
+    t === 'false' ||
+    t === 'null' ||
+    t === 'undefined' ||
+    t === 'array' ||
+    t === 'object' ||
+    t === 'regex' ||
+    t === 'unary_expression' ||
+    t === 'binary_expression' ||
+    t === 'new_expression'
+  );
+}
+
 // ── Shared helpers ──────────────────────────────────────────────────────────
 
 function extractInterfaceMethods(bodyNode, interfaceName, definitions) {