@optave/codegraph 2.0.0 → 2.1.1-dev.00f091c

package/src/extractors/csharp.js

@@ -0,0 +1,248 @@
+import { findChild, nodeEndLine } from './helpers.js';
+
+/**
+ * Extract symbols from C# files.
+ */
+export function extractCSharpSymbols(tree, _filePath) {
+  const definitions = [];
+  const calls = [];
+  const imports = [];
+  const classes = [];
+  const exports = [];
+
+  function findCSharpParentType(node) {
+    let current = node.parent;
+    while (current) {
+      if (
+        current.type === 'class_declaration' ||
+        current.type === 'struct_declaration' ||
+        current.type === 'interface_declaration' ||
+        current.type === 'enum_declaration' ||
+        current.type === 'record_declaration'
+      ) {
+        const nameNode = current.childForFieldName('name');
+        return nameNode ? nameNode.text : null;
+      }
+      current = current.parent;
+    }
+    return null;
+  }
+
+  function walkCSharpNode(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),
+          });
+          extractCSharpBaseTypes(node, nameNode.text, classes);
+        }
+        break;
+      }
+
+      case 'struct_declaration': {
+        const nameNode = node.childForFieldName('name');
+        if (nameNode) {
+          definitions.push({
+            name: nameNode.text,
+            kind: 'struct',
+            line: node.startPosition.row + 1,
+            endLine: nodeEndLine(node),
+          });
+          extractCSharpBaseTypes(node, nameNode.text, classes);
+        }
+        break;
+      }
+
+      case 'record_declaration': {
+        const nameNode = node.childForFieldName('name');
+        if (nameNode) {
+          definitions.push({
+            name: nameNode.text,
+            kind: 'record',
+            line: node.startPosition.row + 1,
+            endLine: nodeEndLine(node),
+          });
+          extractCSharpBaseTypes(node, nameNode.text, classes);
+        }
+        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 parentType = findCSharpParentType(node);
+          const fullName = parentType ? `${parentType}.${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 parentType = findCSharpParentType(node);
+          const fullName = parentType ? `${parentType}.${nameNode.text}` : nameNode.text;
+          definitions.push({
+            name: fullName,
+            kind: 'method',
+            line: node.startPosition.row + 1,
+            endLine: nodeEndLine(node),
+          });
+        }
+        break;
+      }
+
+      case 'property_declaration': {
+        const nameNode = node.childForFieldName('name');
+        if (nameNode) {
+          const parentType = findCSharpParentType(node);
+          const fullName = parentType ? `${parentType}.${nameNode.text}` : nameNode.text;
+          definitions.push({
+            name: fullName,
+            kind: 'method',
+            line: node.startPosition.row + 1,
+            endLine: nodeEndLine(node),
+          });
+        }
+        break;
+      }
+
+      case 'using_directive': {
+        // using System.Collections.Generic;
+        const nameNode =
+          node.childForFieldName('name') ||
+          findChild(node, 'qualified_name') ||
+          findChild(node, 'identifier');
+        if (nameNode) {
+          const fullPath = nameNode.text;
+          const lastName = fullPath.split('.').pop();
+          imports.push({
+            source: fullPath,
+            names: [lastName],
+            line: node.startPosition.row + 1,
+            csharpUsing: true,
+          });
+        }
+        break;
+      }
+
+      case 'invocation_expression': {
+        const fn = node.childForFieldName('function') || node.child(0);
+        if (fn) {
+          if (fn.type === 'identifier') {
+            calls.push({ name: fn.text, line: node.startPosition.row + 1 });
+          } else if (fn.type === 'member_access_expression') {
+            const name = fn.childForFieldName('name');
+            if (name) {
+              const expr = fn.childForFieldName('expression');
+              const call = { name: name.text, line: node.startPosition.row + 1 };
+              if (expr) call.receiver = expr.text;
+              calls.push(call);
+            }
+          } else if (fn.type === 'generic_name' || fn.type === 'member_binding_expression') {
+            const name = fn.childForFieldName('name') || fn.child(0);
+            if (name) calls.push({ name: name.text, line: node.startPosition.row + 1 });
+          }
+        }
+        break;
+      }
+
+      case 'object_creation_expression': {
+        const typeNode = node.childForFieldName('type');
+        if (typeNode) {
+          const typeName =
+            typeNode.type === 'generic_name'
+              ? typeNode.childForFieldName('name')?.text || 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++) walkCSharpNode(node.child(i));
+  }
+
+  walkCSharpNode(tree.rootNode);
+  return { definitions, calls, imports, classes, exports };
+}
+
+function extractCSharpBaseTypes(node, className, classes) {
+  const baseList = node.childForFieldName('bases');
+  if (!baseList) return;
+  for (let i = 0; i < baseList.childCount; i++) {
+    const child = baseList.child(i);
+    if (!child) continue;
+    if (child.type === 'identifier' || child.type === 'qualified_name') {
+      classes.push({ name: className, extends: child.text, line: node.startPosition.row + 1 });
+    } else if (child.type === 'generic_name') {
+      const name = child.childForFieldName('name') || child.child(0);
+      if (name)
+        classes.push({ name: className, extends: name.text, line: node.startPosition.row + 1 });
+    } else if (child.type === 'base_list') {
+      for (let j = 0; j < child.childCount; j++) {
+        const base = child.child(j);
+        if (base && (base.type === 'identifier' || base.type === 'qualified_name')) {
+          classes.push({ name: className, extends: base.text, line: node.startPosition.row + 1 });
+        } else if (base && base.type === 'generic_name') {
+          const name = base.childForFieldName('name') || base.child(0);
+          if (name)
+            classes.push({ name: className, extends: name.text, line: node.startPosition.row + 1 });
+        }
+      }
+    }
+  }
+}

package/src/extractors/go.js

@@ -0,0 +1,172 @@
+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) {
+              const operand = fn.childForFieldName('operand');
+              const call = { name: field.text, line: node.startPosition.row + 1 };
+              if (operand) call.receiver = operand.text;
+              calls.push(call);
+            }
+          }
+        }
+        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';