@optave/codegraph 3.1.4 → 3.2.0

package/src/extractors/go.js

@@ -4,196 +4,200 @@ import { findChild, goVisibility, nodeEndLine } from './helpers.js';
  * Extract symbols from Go files.
  */
 export function extractGoSymbols(tree, _filePath) {
-  const definitions = [];
-  const calls = [];
-  const imports = [];
-  const classes = [];
-  const exports = [];
+  const ctx = {
+    definitions: [],
+    calls: [],
+    imports: [],
+    classes: [],
+    exports: [],
+  };
 
-  function walkGoNode(node) {
-    switch (node.type) {
-      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,
-            visibility: goVisibility(nameNode.text),
-          });
-        }
-        break;
-      }
+  walkGoNode(tree.rootNode, ctx);
+  return ctx;
+}
 
-      case 'method_declaration': {
-        const nameNode = node.childForFieldName('name');
-        const receiver = node.childForFieldName('receiver');
-        if (nameNode) {
-          let receiverType = null;
-          if (receiver) {
-            // receiver is a parameter_list like (r *Foo) or (r Foo)
-            for (let i = 0; i < receiver.childCount; i++) {
-              const param = receiver.child(i);
-              if (!param) continue;
-              const typeNode = param.childForFieldName('type');
-              if (typeNode) {
-                receiverType =
-                  typeNode.type === 'pointer_type'
-                    ? typeNode.text.replace(/^\*/, '')
-                    : typeNode.text;
-                break;
-              }
-            }
-          }
-          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,
-            visibility: goVisibility(nameNode.text),
-          });
-        }
-        break;
-      }
+function walkGoNode(node, ctx) {
+  switch (node.type) {
+    case 'function_declaration':
+      handleGoFuncDecl(node, ctx);
+      break;
+    case 'method_declaration':
+      handleGoMethodDecl(node, ctx);
+      break;
+    case 'type_declaration':
+      handleGoTypeDecl(node, ctx);
+      break;
+    case 'import_declaration':
+      handleGoImportDecl(node, ctx);
+      break;
+    case 'const_declaration':
+      handleGoConstDecl(node, ctx);
+      break;
+    case 'call_expression':
+      handleGoCallExpr(node, ctx);
+      break;
+  }
 
-      case 'type_declaration': {
-        for (let i = 0; i < node.childCount; i++) {
-          const spec = node.child(i);
-          if (!spec || spec.type !== 'type_spec') continue;
-          const nameNode = spec.childForFieldName('name');
-          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({
-                name: nameNode.text,
-                kind: 'interface',
-                line: node.startPosition.row + 1,
-                endLine: nodeEndLine(node),
-              });
-              for (let j = 0; j < typeNode.childCount; j++) {
-                const member = typeNode.child(j);
-                if (member && member.type === 'method_elem') {
-                  const methName = member.childForFieldName('name');
-                  if (methName) {
-                    definitions.push({
-                      name: `${nameNode.text}.${methName.text}`,
-                      kind: 'method',
-                      line: member.startPosition.row + 1,
-                      endLine: member.endPosition.row + 1,
-                    });
-                  }
-                }
-              }
-            } else {
-              definitions.push({
-                name: nameNode.text,
-                kind: 'type',
-                line: node.startPosition.row + 1,
-                endLine: nodeEndLine(node),
-              });
-            }
-          }
-        }
+  for (let i = 0; i < node.childCount; i++) walkGoNode(node.child(i), ctx);
+}
+
+// ── Walk-path per-node-type handlers ────────────────────────────────────────
+
+function handleGoFuncDecl(node, ctx) {
+  const nameNode = node.childForFieldName('name');
+  if (!nameNode) return;
+  const params = extractGoParameters(node.childForFieldName('parameters'));
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'function',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+    children: params.length > 0 ? params : undefined,
+    visibility: goVisibility(nameNode.text),
+  });
+}
+
+function handleGoMethodDecl(node, ctx) {
+  const nameNode = node.childForFieldName('name');
+  const receiver = node.childForFieldName('receiver');
+  if (!nameNode) return;
+  let receiverType = null;
+  if (receiver) {
+    for (let i = 0; i < receiver.childCount; i++) {
+      const param = receiver.child(i);
+      if (!param) continue;
+      const typeNode = param.childForFieldName('type');
+      if (typeNode) {
+        receiverType =
+          typeNode.type === 'pointer_type' ? typeNode.text.replace(/^\*/, '') : typeNode.text;
         break;
       }
+    }
+  }
+  const fullName = receiverType ? `${receiverType}.${nameNode.text}` : nameNode.text;
+  const params = extractGoParameters(node.childForFieldName('parameters'));
+  ctx.definitions.push({
+    name: fullName,
+    kind: 'method',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+    children: params.length > 0 ? params : undefined,
+    visibility: goVisibility(nameNode.text),
+  });
+}
 
-      case 'import_declaration': {
-        for (let i = 0; i < node.childCount; i++) {
-          const child = node.child(i);
-          if (!child) continue;
-          if (child.type === 'import_spec') {
-            const pathNode = child.childForFieldName('path');
-            if (pathNode) {
-              const importPath = pathNode.text.replace(/"/g, '');
-              const nameNode = child.childForFieldName('name');
-              const alias = nameNode ? nameNode.text : importPath.split('/').pop();
-              imports.push({
-                source: importPath,
-                names: [alias],
-                line: child.startPosition.row + 1,
-                goImport: true,
+function handleGoTypeDecl(node, ctx) {
+  for (let i = 0; i < node.childCount; i++) {
+    const spec = node.child(i);
+    if (!spec || spec.type !== 'type_spec') continue;
+    const nameNode = spec.childForFieldName('name');
+    const typeNode = spec.childForFieldName('type');
+    if (nameNode && typeNode) {
+      if (typeNode.type === 'struct_type') {
+        const fields = extractStructFields(typeNode);
+        ctx.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') {
+        ctx.definitions.push({
+          name: nameNode.text,
+          kind: 'interface',
+          line: node.startPosition.row + 1,
+          endLine: nodeEndLine(node),
+        });
+        for (let j = 0; j < typeNode.childCount; j++) {
+          const member = typeNode.child(j);
+          if (member && member.type === 'method_elem') {
+            const methName = member.childForFieldName('name');
+            if (methName) {
+              ctx.definitions.push({
+                name: `${nameNode.text}.${methName.text}`,
+                kind: 'method',
+                line: member.startPosition.row + 1,
+                endLine: member.endPosition.row + 1,
               });
             }
           }
-          if (child.type === 'import_spec_list') {
-            for (let j = 0; j < child.childCount; j++) {
-              const spec = child.child(j);
-              if (spec && spec.type === 'import_spec') {
-                const pathNode = spec.childForFieldName('path');
-                if (pathNode) {
-                  const importPath = pathNode.text.replace(/"/g, '');
-                  const nameNode = spec.childForFieldName('name');
-                  const alias = nameNode ? nameNode.text : importPath.split('/').pop();
-                  imports.push({
-                    source: importPath,
-                    names: [alias],
-                    line: spec.startPosition.row + 1,
-                    goImport: true,
-                  });
-                }
-              }
-            }
-          }
-        }
-        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;
+      } else {
+        ctx.definitions.push({
+          name: nameNode.text,
+          kind: 'type',
+          line: node.startPosition.row + 1,
+          endLine: nodeEndLine(node),
+        });
       }
+    }
+  }
+}
 
-      case 'call_expression': {
-        const fn = node.childForFieldName('function');
-        if (fn) {
-          if (fn.type === 'identifier') {
-            calls.push({ name: fn.text, line: node.startPosition.row + 1 });
-          } else if (fn.type === 'selector_expression') {
-            const field = fn.childForFieldName('field');
-            if (field) {
-              const operand = fn.childForFieldName('operand');
-              const call = { name: field.text, line: node.startPosition.row + 1 };
-              if (operand) call.receiver = operand.text;
-              calls.push(call);
-            }
-          }
+function handleGoImportDecl(node, ctx) {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    if (child.type === 'import_spec') {
+      extractGoImportSpec(child, ctx);
+    }
+    if (child.type === 'import_spec_list') {
+      for (let j = 0; j < child.childCount; j++) {
+        const spec = child.child(j);
+        if (spec && spec.type === 'import_spec') {
+          extractGoImportSpec(spec, ctx);
         }
-        break;
       }
     }
+  }
+}
+
+function extractGoImportSpec(spec, ctx) {
+  const pathNode = spec.childForFieldName('path');
+  if (pathNode) {
+    const importPath = pathNode.text.replace(/"/g, '');
+    const nameNode = spec.childForFieldName('name');
+    const alias = nameNode ? nameNode.text : importPath.split('/').pop();
+    ctx.imports.push({
+      source: importPath,
+      names: [alias],
+      line: spec.startPosition.row + 1,
+      goImport: true,
+    });
+  }
+}
 
-    for (let i = 0; i < node.childCount; i++) walkGoNode(node.child(i));
+function handleGoConstDecl(node, ctx) {
+  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) {
+      ctx.definitions.push({
+        name: constName.text,
+        kind: 'constant',
+        line: spec.startPosition.row + 1,
+        endLine: spec.endPosition.row + 1,
+      });
+    }
   }
+}
 
-  walkGoNode(tree.rootNode);
-  return { definitions, calls, imports, classes, exports };
+function handleGoCallExpr(node, ctx) {
+  const fn = node.childForFieldName('function');
+  if (!fn) return;
+  if (fn.type === 'identifier') {
+    ctx.calls.push({ name: fn.text, line: node.startPosition.row + 1 });
+  } else if (fn.type === 'selector_expression') {
+    const field = fn.childForFieldName('field');
+    if (field) {
+      const operand = fn.childForFieldName('operand');
+      const call = { name: field.text, line: node.startPosition.row + 1 };
+      if (operand) call.receiver = operand.text;
+      ctx.calls.push(call);
+    }
+  }
 }
 
 // ── Child extraction helpers ────────────────────────────────────────────────

package/src/extractors/hcl.js

@@ -4,92 +4,108 @@ import { nodeEndLine } from './helpers.js';
  * Extract symbols from HCL (Terraform) files.
  */
 export function extractHCLSymbols(tree, _filePath) {
-  const definitions = [];
-  const imports = [];
+  const ctx = { definitions: [], imports: [] };
 
-  function walkHclNode(node) {
-    if (node.type === 'block') {
-      const children = [];
-      for (let i = 0; i < node.childCount; i++) children.push(node.child(i));
+  walkHclNode(tree.rootNode, ctx);
+  return {
+    definitions: ctx.definitions,
+    calls: [],
+    imports: ctx.imports,
+    classes: [],
+    exports: [],
+  };
+}
 
-      const identifiers = children.filter((c) => c.type === 'identifier');
-      const strings = children.filter((c) => c.type === 'string_lit');
+function walkHclNode(node, ctx) {
+  if (node.type === 'block') {
+    handleHclBlock(node, ctx);
+  }
 
-      if (identifiers.length > 0) {
-        const blockType = identifiers[0].text;
-        let name = '';
+  for (let i = 0; i < node.childCount; i++) walkHclNode(node.child(i), ctx);
+}
 
-        if (blockType === 'resource' && strings.length >= 2) {
-          name = `${strings[0].text.replace(/"/g, '')}.${strings[1].text.replace(/"/g, '')}`;
-        } else if (blockType === 'data' && strings.length >= 2) {
-          name = `data.${strings[0].text.replace(/"/g, '')}.${strings[1].text.replace(/"/g, '')}`;
-        } else if (
-          (blockType === 'variable' || blockType === 'output' || blockType === 'module') &&
-          strings.length >= 1
-        ) {
-          name = `${blockType}.${strings[0].text.replace(/"/g, '')}`;
-        } else if (blockType === 'locals') {
-          name = 'locals';
-        } else if (blockType === 'terraform' || blockType === 'provider') {
-          name = blockType;
-          if (strings.length >= 1) name += `.${strings[0].text.replace(/"/g, '')}`;
-        }
+function handleHclBlock(node, ctx) {
+  const children = [];
+  for (let i = 0; i < node.childCount; i++) children.push(node.child(i));
 
-        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,
-          });
-        }
+  const identifiers = children.filter((c) => c.type === 'identifier');
+  const strings = children.filter((c) => c.type === 'string_lit');
 
-        if (blockType === 'module') {
-          const body = children.find((c) => c.type === 'body');
-          if (body) {
-            for (let i = 0; i < body.childCount; i++) {
-              const attr = body.child(i);
-              if (attr && attr.type === 'attribute') {
-                const key = attr.childForFieldName('key') || attr.child(0);
-                const val = attr.childForFieldName('val') || attr.child(2);
-                if (key && key.text === 'source' && val) {
-                  const src = val.text.replace(/"/g, '');
-                  if (src.startsWith('./') || src.startsWith('../')) {
-                    imports.push({ source: src, names: [], line: attr.startPosition.row + 1 });
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
+  if (identifiers.length === 0) return;
+  const blockType = identifiers[0].text;
+  const name = resolveHclBlockName(blockType, strings);
+
+  if (name) {
+    let blockChildren;
+    if (blockType === 'variable' || blockType === 'output') {
+      blockChildren = extractHclAttributes(children);
     }
+    ctx.definitions.push({
+      name,
+      kind: blockType,
+      line: node.startPosition.row + 1,
+      endLine: nodeEndLine(node),
+      children: blockChildren?.length > 0 ? blockChildren : undefined,
+    });
+  }
 
-    for (let i = 0; i < node.childCount; i++) walkHclNode(node.child(i));
+  if (blockType === 'module') {
+    extractHclModuleSource(children, node, ctx);
   }
+}
 
-  walkHclNode(tree.rootNode);
-  return { definitions, calls: [], imports, classes: [], exports: [] };
+function resolveHclBlockName(blockType, strings) {
+  if (blockType === 'resource' && strings.length >= 2) {
+    return `${strings[0].text.replace(/"/g, '')}.${strings[1].text.replace(/"/g, '')}`;
+  }
+  if (blockType === 'data' && strings.length >= 2) {
+    return `data.${strings[0].text.replace(/"/g, '')}.${strings[1].text.replace(/"/g, '')}`;
+  }
+  if (
+    (blockType === 'variable' || blockType === 'output' || blockType === 'module') &&
+    strings.length >= 1
+  ) {
+    return `${blockType}.${strings[0].text.replace(/"/g, '')}`;
+  }
+  if (blockType === 'locals') return 'locals';
+  if (blockType === 'terraform' || blockType === 'provider') {
+    let name = blockType;
+    if (strings.length >= 1) name += `.${strings[0].text.replace(/"/g, '')}`;
+    return name;
+  }
+  return '';
+}
+
+function extractHclAttributes(children) {
+  const attrs = [];
+  const body = children.find((c) => c.type === 'body');
+  if (!body) return attrs;
+  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) {
+        attrs.push({ name: key.text, kind: 'property', line: attr.startPosition.row + 1 });
+      }
+    }
+  }
+  return attrs;
+}
+
+function extractHclModuleSource(children, _node, ctx) {
+  const body = children.find((c) => c.type === 'body');
+  if (!body) return;
+  for (let i = 0; i < body.childCount; i++) {
+    const attr = body.child(i);
+    if (attr && attr.type === 'attribute') {
+      const key = attr.childForFieldName('key') || attr.child(0);
+      const val = attr.childForFieldName('val') || attr.child(2);
+      if (key && key.text === 'source' && val) {
+        const src = val.text.replace(/"/g, '');
+        if (src.startsWith('./') || src.startsWith('../')) {
+          ctx.imports.push({ source: src, names: [], line: attr.startPosition.row + 1 });
+        }
+      }
+    }
+  }
 }