@optave/codegraph 2.0.0 → 2.1.1-dev.3c12b64

package/src/extractors/go.js

@@ -0,0 +1,167 @@
+import { nodeEndLine } from './helpers.js';
+
+/**
+ * Extract symbols from Go files.
+ */
+export function extractGoSymbols(tree, _filePath) {
+  const definitions = [];
+  const calls = [];
+  const imports = [];
+  const classes = [];
+  const exports = [];
+
+  function walkGoNode(node) {
+    switch (node.type) {
+      case 'function_declaration': {
+        const nameNode = node.childForFieldName('name');
+        if (nameNode) {
+          definitions.push({
+            name: nameNode.text,
+            kind: 'function',
+            line: node.startPosition.row + 1,
+            endLine: nodeEndLine(node),
+          });
+        }
+        break;
+      }
+
+      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;
+          definitions.push({
+            name: fullName,
+            kind: 'method',
+            line: node.startPosition.row + 1,
+            endLine: nodeEndLine(node),
+          });
+        }
+        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') {
+              definitions.push({
+                name: nameNode.text,
+                kind: 'struct',
+                line: node.startPosition.row + 1,
+                endLine: nodeEndLine(node),
+              });
+            } 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),
+              });
+            }
+          }
+        }
+        break;
+      }
+
+      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,
+              });
+            }
+          }
+          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 '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) calls.push({ name: field.text, line: node.startPosition.row + 1 });
+          }
+        }
+        break;
+      }
+    }
+
+    for (let i = 0; i < node.childCount; i++) walkGoNode(node.child(i));
+  }
+
+  walkGoNode(tree.rootNode);
+  return { definitions, calls, imports, classes, exports };
+}

package/src/extractors/hcl.js

@@ -0,0 +1,73 @@
+import { nodeEndLine } from './helpers.js';
+
+/**
+ * Extract symbols from HCL (Terraform) files.
+ */
+export function extractHCLSymbols(tree, _filePath) {
+  const definitions = [];
+  const imports = [];
+
+  function walkHclNode(node) {
+    if (node.type === 'block') {
+      const children = [];
+      for (let i = 0; i < node.childCount; i++) children.push(node.child(i));
+
+      const identifiers = children.filter((c) => c.type === 'identifier');
+      const strings = children.filter((c) => c.type === 'string_lit');
+
+      if (identifiers.length > 0) {
+        const blockType = identifiers[0].text;
+        let name = '';
+
+        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, '')}`;
+        }
+
+        if (name) {
+          definitions.push({
+            name,
+            kind: blockType,
+            line: node.startPosition.row + 1,
+            endLine: nodeEndLine(node),
+          });
+        }
+
+        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 });
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+
+    for (let i = 0; i < node.childCount; i++) walkHclNode(node.child(i));
+  }
+
+  walkHclNode(tree.rootNode);
+  return { definitions, calls: [], imports, classes: [], exports: [] };
+}

package/src/extractors/helpers.js

@@ -0,0 +1,10 @@
+export function nodeEndLine(node) {
+  return node.endPosition.row + 1;
+}
+
+export function findChild(node, type) {
+  for (let i = 0; i < node.childCount; i++) {
+    if (node.child(i).type === type) return node.child(i);
+  }
+  return null;
+}

package/src/extractors/index.js

@@ -0,0 +1,9 @@
+export { extractCSharpSymbols } from './csharp.js';
+export { extractGoSymbols } from './go.js';
+export { extractHCLSymbols } from './hcl.js';
+export { extractJavaSymbols } from './java.js';
+export { extractSymbols } from './javascript.js';
+export { extractPHPSymbols } from './php.js';
+export { extractPythonSymbols } from './python.js';
+export { extractRubySymbols } from './ruby.js';
+export { extractRustSymbols } from './rust.js';

package/src/extractors/java.js

@@ -0,0 +1,227 @@
+import { nodeEndLine } from './helpers.js';
+
+/**
+ * Extract symbols from Java files.
+ */
+export function extractJavaSymbols(tree, _filePath) {
+  const definitions = [];
+  const calls = [];
+  const imports = [];
+  const classes = [];
+  const exports = [];
+
+  function findJavaParentClass(node) {
+    let current = node.parent;
+    while (current) {
+      if (
+        current.type === 'class_declaration' ||
+        current.type === 'enum_declaration' ||
+        current.type === 'interface_declaration'
+      ) {
+        const nameNode = current.childForFieldName('name');
+        return nameNode ? nameNode.text : null;
+      }
+      current = current.parent;
+    }
+    return null;
+  }
+
+  function walkJavaNode(node) {
+    switch (node.type) {
+      case 'class_declaration': {
+        const nameNode = node.childForFieldName('name');
+        if (nameNode) {
+          definitions.push({
+            name: nameNode.text,
+            kind: 'class',
+            line: node.startPosition.row + 1,
+            endLine: nodeEndLine(node),
+          });
+
+          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)
+                  classes.push({
+                    name: nameNode.text,
+                    extends: superName,
+                    line: node.startPosition.row + 1,
+                  });
+                break;
+              }
+            }
+          }
+
+          const interfaces = node.childForFieldName('interfaces');
+          if (interfaces) {
+            for (let i = 0; i < interfaces.childCount; i++) {
+              const child = interfaces.child(i);
+              if (
+                child &&
+                (child.type === 'type_identifier' ||
+                  child.type === 'identifier' ||
+                  child.type === 'type_list' ||
+                  child.type === 'generic_type')
+              ) {
+                if (child.type === 'type_list') {
+                  for (let j = 0; j < child.childCount; j++) {
+                    const t = child.child(j);
+                    if (
+                      t &&
+                      (t.type === 'type_identifier' ||
+                        t.type === 'identifier' ||
+                        t.type === 'generic_type')
+                    ) {
+                      const ifaceName = t.type === 'generic_type' ? t.child(0)?.text : t.text;
+                      if (ifaceName)
+                        classes.push({
+                          name: nameNode.text,
+                          implements: ifaceName,
+                          line: node.startPosition.row + 1,
+                        });
+                    }
+                  }
+                } else {
+                  const ifaceName =
+                    child.type === 'generic_type' ? child.child(0)?.text : child.text;
+                  if (ifaceName)
+                    classes.push({
+                      name: nameNode.text,
+                      implements: ifaceName,
+                      line: node.startPosition.row + 1,
+                    });
+                }
+              }
+            }
+          }
+        }
+        break;
+      }
+
+      case 'interface_declaration': {
+        const nameNode = node.childForFieldName('name');
+        if (nameNode) {
+          definitions.push({
+            name: nameNode.text,
+            kind: 'interface',
+            line: node.startPosition.row + 1,
+            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) {
+                  definitions.push({
+                    name: `${nameNode.text}.${methName.text}`,
+                    kind: 'method',
+                    line: child.startPosition.row + 1,
+                    endLine: child.endPosition.row + 1,
+                  });
+                }
+              }
+            }
+          }
+        }
+        break;
+      }
+
+      case 'enum_declaration': {
+        const nameNode = node.childForFieldName('name');
+        if (nameNode) {
+          definitions.push({
+            name: nameNode.text,
+            kind: 'enum',
+            line: node.startPosition.row + 1,
+            endLine: nodeEndLine(node),
+          });
+        }
+        break;
+      }
+
+      case 'method_declaration': {
+        const nameNode = node.childForFieldName('name');
+        if (nameNode) {
+          const parentClass = findJavaParentClass(node);
+          const fullName = parentClass ? `${parentClass}.${nameNode.text}` : nameNode.text;
+          definitions.push({
+            name: fullName,
+            kind: 'method',
+            line: node.startPosition.row + 1,
+            endLine: nodeEndLine(node),
+          });
+        }
+        break;
+      }
+
+      case 'constructor_declaration': {
+        const nameNode = node.childForFieldName('name');
+        if (nameNode) {
+          const parentClass = findJavaParentClass(node);
+          const fullName = parentClass ? `${parentClass}.${nameNode.text}` : nameNode.text;
+          definitions.push({
+            name: fullName,
+            kind: 'method',
+            line: node.startPosition.row + 1,
+            endLine: nodeEndLine(node),
+          });
+        }
+        break;
+      }
+
+      case 'import_declaration': {
+        for (let i = 0; i < node.childCount; i++) {
+          const child = node.child(i);
+          if (child && (child.type === 'scoped_identifier' || child.type === 'identifier')) {
+            const fullPath = child.text;
+            const lastName = fullPath.split('.').pop();
+            imports.push({
+              source: fullPath,
+              names: [lastName],
+              line: node.startPosition.row + 1,
+              javaImport: true,
+            });
+          }
+          if (child && child.type === 'asterisk') {
+            const lastImport = imports[imports.length - 1];
+            if (lastImport) lastImport.names = ['*'];
+          }
+        }
+        break;
+      }
+
+      case 'method_invocation': {
+        const nameNode = node.childForFieldName('name');
+        if (nameNode) {
+          calls.push({ name: nameNode.text, line: node.startPosition.row + 1 });
+        }
+        break;
+      }
+
+      case 'object_creation_expression': {
+        const typeNode = node.childForFieldName('type');
+        if (typeNode) {
+          const typeName =
+            typeNode.type === 'generic_type' ? typeNode.child(0)?.text : typeNode.text;
+          if (typeName) calls.push({ name: typeName, line: node.startPosition.row + 1 });
+        }
+        break;
+      }
+    }
+
+    for (let i = 0; i < node.childCount; i++) walkJavaNode(node.child(i));
+  }
+
+  walkJavaNode(tree.rootNode);
+  return { definitions, calls, imports, classes, exports };
+}