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

package/src/extractors/php.js

@@ -0,0 +1,243 @@
+import { findChild, nodeEndLine } from './helpers.js';
+
+/**
+ * Extract symbols from PHP files.
+ */
+export function extractPHPSymbols(tree, _filePath) {
+  const definitions = [];
+  const calls = [];
+  const imports = [];
+  const classes = [];
+  const exports = [];
+
+  function findPHPParentClass(node) {
+    let current = node.parent;
+    while (current) {
+      if (
+        current.type === 'class_declaration' ||
+        current.type === 'trait_declaration' ||
+        current.type === 'enum_declaration'
+      ) {
+        const nameNode = current.childForFieldName('name');
+        return nameNode ? nameNode.text : null;
+      }
+      current = current.parent;
+    }
+    return null;
+  }
+
+  function walkPhpNode(node) {
+    switch (node.type) {
+      case 'function_definition': {
+        const nameNode = node.childForFieldName('name');
+        if (nameNode) {
+          definitions.push({
+            name: nameNode.text,
+            kind: 'function',
+            line: node.startPosition.row + 1,
+            endLine: nodeEndLine(node),
+          });
+        }
+        break;
+      }
+
+      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),
+          });
+
+          // Check base clause (extends)
+          const baseClause =
+            node.childForFieldName('base_clause') || findChild(node, 'base_clause');
+          if (baseClause) {
+            for (let i = 0; i < baseClause.childCount; i++) {
+              const child = baseClause.child(i);
+              if (child && (child.type === 'name' || child.type === 'qualified_name')) {
+                classes.push({
+                  name: nameNode.text,
+                  extends: child.text,
+                  line: node.startPosition.row + 1,
+                });
+                break;
+              }
+            }
+          }
+
+          // Check class interface clause (implements)
+          const interfaceClause = findChild(node, 'class_interface_clause');
+          if (interfaceClause) {
+            for (let i = 0; i < interfaceClause.childCount; i++) {
+              const child = interfaceClause.child(i);
+              if (child && (child.type === 'name' || child.type === 'qualified_name')) {
+                classes.push({
+                  name: nameNode.text,
+                  implements: child.text,
+                  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 'trait_declaration': {
+        const nameNode = node.childForFieldName('name');
+        if (nameNode) {
+          definitions.push({
+            name: nameNode.text,
+            kind: 'trait',
+            line: node.startPosition.row + 1,
+            endLine: nodeEndLine(node),
+          });
+        }
+        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 = findPHPParentClass(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 'namespace_use_declaration': {
+        // use App\Models\User;
+        for (let i = 0; i < node.childCount; i++) {
+          const child = node.child(i);
+          if (child && child.type === 'namespace_use_clause') {
+            const nameNode = findChild(child, 'qualified_name') || findChild(child, 'name');
+            if (nameNode) {
+              const fullPath = nameNode.text;
+              const lastName = fullPath.split('\\').pop();
+              const alias = child.childForFieldName('alias');
+              imports.push({
+                source: fullPath,
+                names: [alias ? alias.text : lastName],
+                line: node.startPosition.row + 1,
+                phpUse: true,
+              });
+            }
+          }
+          // Single use clause without wrapper
+          if (child && (child.type === 'qualified_name' || child.type === 'name')) {
+            const fullPath = child.text;
+            const lastName = fullPath.split('\\').pop();
+            imports.push({
+              source: fullPath,
+              names: [lastName],
+              line: node.startPosition.row + 1,
+              phpUse: true,
+            });
+          }
+        }
+        break;
+      }
+
+      case 'function_call_expression': {
+        const fn = node.childForFieldName('function') || node.child(0);
+        if (fn) {
+          if (fn.type === 'name' || fn.type === 'identifier') {
+            calls.push({ name: fn.text, line: node.startPosition.row + 1 });
+          } else if (fn.type === 'qualified_name') {
+            const parts = fn.text.split('\\');
+            calls.push({ name: parts[parts.length - 1], line: node.startPosition.row + 1 });
+          }
+        }
+        break;
+      }
+
+      case 'member_call_expression': {
+        const name = node.childForFieldName('name');
+        if (name) {
+          const obj = node.childForFieldName('object');
+          const call = { name: name.text, line: node.startPosition.row + 1 };
+          if (obj) call.receiver = obj.text;
+          calls.push(call);
+        }
+        break;
+      }
+
+      case 'scoped_call_expression': {
+        const name = node.childForFieldName('name');
+        if (name) {
+          const scope = node.childForFieldName('scope');
+          const call = { name: name.text, line: node.startPosition.row + 1 };
+          if (scope) call.receiver = scope.text;
+          calls.push(call);
+        }
+        break;
+      }
+
+      case 'object_creation_expression': {
+        const classNode = node.child(1); // skip 'new' keyword
+        if (classNode && (classNode.type === 'name' || classNode.type === 'qualified_name')) {
+          const parts = classNode.text.split('\\');
+          calls.push({ name: parts[parts.length - 1], line: node.startPosition.row + 1 });
+        }
+        break;
+      }
+    }
+
+    for (let i = 0; i < node.childCount; i++) walkPhpNode(node.child(i));
+  }
+
+  walkPhpNode(tree.rootNode);
+  return { definitions, calls, imports, classes, exports };
+}

package/src/extractors/python.js

@@ -0,0 +1,150 @@
+import { findChild, nodeEndLine } from './helpers.js';
+
+/**
+ * Extract symbols from Python files.
+ */
+export function extractPythonSymbols(tree, _filePath) {
+  const definitions = [];
+  const calls = [];
+  const imports = [];
+  const classes = [];
+  const exports = [];
+
+  function walkPythonNode(node) {
+    switch (node.type) {
+      case 'function_definition': {
+        const nameNode = node.childForFieldName('name');
+        if (nameNode) {
+          const decorators = [];
+          if (node.previousSibling && node.previousSibling.type === 'decorator') {
+            decorators.push(node.previousSibling.text);
+          }
+          const parentClass = findPythonParentClass(node);
+          const fullName = parentClass ? `${parentClass}.${nameNode.text}` : nameNode.text;
+          const kind = parentClass ? 'method' : 'function';
+          definitions.push({
+            name: fullName,
+            kind,
+            line: node.startPosition.row + 1,
+            endLine: nodeEndLine(node),
+            decorators,
+          });
+        }
+        break;
+      }
+
+      case 'class_definition': {
+        const nameNode = node.childForFieldName('name');
+        if (nameNode) {
+          definitions.push({
+            name: nameNode.text,
+            kind: 'class',
+            line: node.startPosition.row + 1,
+            endLine: nodeEndLine(node),
+          });
+          const superclasses =
+            node.childForFieldName('superclasses') || findChild(node, 'argument_list');
+          if (superclasses) {
+            for (let i = 0; i < superclasses.childCount; i++) {
+              const child = superclasses.child(i);
+              if (child && child.type === 'identifier') {
+                classes.push({
+                  name: nameNode.text,
+                  extends: child.text,
+                  line: node.startPosition.row + 1,
+                });
+              }
+            }
+          }
+        }
+        break;
+      }
+
+      case 'decorated_definition': {
+        for (let i = 0; i < node.childCount; i++) walkPythonNode(node.child(i));
+        return;
+      }
+
+      case 'call': {
+        const fn = node.childForFieldName('function');
+        if (fn) {
+          let callName = null;
+          let receiver;
+          if (fn.type === 'identifier') callName = fn.text;
+          else if (fn.type === 'attribute') {
+            const attr = fn.childForFieldName('attribute');
+            if (attr) callName = attr.text;
+            const obj = fn.childForFieldName('object');
+            if (obj) receiver = obj.text;
+          }
+          if (callName) {
+            const call = { name: callName, line: node.startPosition.row + 1 };
+            if (receiver) call.receiver = receiver;
+            calls.push(call);
+          }
+        }
+        break;
+      }
+
+      case 'import_statement': {
+        const names = [];
+        for (let i = 0; i < node.childCount; i++) {
+          const child = node.child(i);
+          if (child && (child.type === 'dotted_name' || child.type === 'aliased_import')) {
+            const name =
+              child.type === 'aliased_import'
+                ? (child.childForFieldName('alias') || child.childForFieldName('name'))?.text
+                : child.text;
+            if (name) names.push(name);
+          }
+        }
+        if (names.length > 0)
+          imports.push({
+            source: names[0],
+            names,
+            line: node.startPosition.row + 1,
+            pythonImport: true,
+          });
+        break;
+      }
+
+      case 'import_from_statement': {
+        let source = '';
+        const names = [];
+        for (let i = 0; i < node.childCount; i++) {
+          const child = node.child(i);
+          if (!child) continue;
+          if (child.type === 'dotted_name' || child.type === 'relative_import') {
+            if (!source) source = child.text;
+            else names.push(child.text);
+          }
+          if (child.type === 'aliased_import') {
+            const n = child.childForFieldName('name') || child.child(0);
+            if (n) names.push(n.text);
+          }
+          if (child.type === 'wildcard_import') names.push('*');
+        }
+        if (source)
+          imports.push({ source, names, line: node.startPosition.row + 1, pythonImport: true });
+        break;
+      }
+    }
+
+    for (let i = 0; i < node.childCount; i++) walkPythonNode(node.child(i));
+  }
+
+  function findPythonParentClass(node) {
+    let current = node.parent;
+    while (current) {
+      if (current.type === 'class_definition') {
+        const nameNode = current.childForFieldName('name');
+        return nameNode ? nameNode.text : null;
+      }
+      current = current.parent;
+    }
+    return null;
+  }
+
+  walkPythonNode(tree.rootNode);
+  return { definitions, calls, imports, classes, exports };
+}

package/src/extractors/ruby.js

@@ -0,0 +1,188 @@
+import { findChild, nodeEndLine } from './helpers.js';
+
+/**
+ * Extract symbols from Ruby files.
+ */
+export function extractRubySymbols(tree, _filePath) {
+  const definitions = [];
+  const calls = [];
+  const imports = [];
+  const classes = [];
+  const exports = [];
+
+  function findRubyParentClass(node) {
+    let current = node.parent;
+    while (current) {
+      if (current.type === 'class') {
+        const nameNode = current.childForFieldName('name');
+        return nameNode ? nameNode.text : null;
+      }
+      if (current.type === 'module') {
+        const nameNode = current.childForFieldName('name');
+        return nameNode ? nameNode.text : null;
+      }
+      current = current.parent;
+    }
+    return null;
+  }
+
+  function walkRubyNode(node) {
+    switch (node.type) {
+      case 'class': {
+        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) {
+            // superclass wraps the < token and class name
+            for (let i = 0; i < superclass.childCount; i++) {
+              const child = superclass.child(i);
+              if (child && (child.type === 'constant' || child.type === 'scope_resolution')) {
+                classes.push({
+                  name: nameNode.text,
+                  extends: child.text,
+                  line: node.startPosition.row + 1,
+                });
+                break;
+              }
+            }
+            // Direct superclass node may be a constant
+            if (superclass.type === 'superclass') {
+              for (let i = 0; i < superclass.childCount; i++) {
+                const child = superclass.child(i);
+                if (child && (child.type === 'constant' || child.type === 'scope_resolution')) {
+                  classes.push({
+                    name: nameNode.text,
+                    extends: child.text,
+                    line: node.startPosition.row + 1,
+                  });
+                  break;
+                }
+              }
+            }
+          }
+        }
+        break;
+      }
+
+      case 'module': {
+        const nameNode = node.childForFieldName('name');
+        if (nameNode) {
+          definitions.push({
+            name: nameNode.text,
+            kind: 'module',
+            line: node.startPosition.row + 1,
+            endLine: nodeEndLine(node),
+          });
+        }
+        break;
+      }
+
+      case 'method': {
+        const nameNode = node.childForFieldName('name');
+        if (nameNode) {
+          const parentClass = findRubyParentClass(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 'singleton_method': {
+        const nameNode = node.childForFieldName('name');
+        if (nameNode) {
+          const parentClass = findRubyParentClass(node);
+          const fullName = parentClass ? `${parentClass}.${nameNode.text}` : nameNode.text;
+          definitions.push({
+            name: fullName,
+            kind: 'function',
+            line: node.startPosition.row + 1,
+            endLine: nodeEndLine(node),
+          });
+        }
+        break;
+      }
+
+      case 'call': {
+        const methodNode = node.childForFieldName('method');
+        if (methodNode) {
+          // Check for require/require_relative
+          if (methodNode.text === 'require' || methodNode.text === 'require_relative') {
+            const args = node.childForFieldName('arguments');
+            if (args) {
+              for (let i = 0; i < args.childCount; i++) {
+                const arg = args.child(i);
+                if (arg && (arg.type === 'string' || arg.type === 'string_content')) {
+                  const strContent = arg.text.replace(/^['"]|['"]$/g, '');
+                  imports.push({
+                    source: strContent,
+                    names: [strContent.split('/').pop()],
+                    line: node.startPosition.row + 1,
+                    rubyRequire: true,
+                  });
+                  break;
+                }
+                // Look inside string for string_content
+                if (arg && arg.type === 'string') {
+                  const content = findChild(arg, 'string_content');
+                  if (content) {
+                    imports.push({
+                      source: content.text,
+                      names: [content.text.split('/').pop()],
+                      line: node.startPosition.row + 1,
+                      rubyRequire: true,
+                    });
+                    break;
+                  }
+                }
+              }
+            }
+          } else if (
+            methodNode.text === 'include' ||
+            methodNode.text === 'extend' ||
+            methodNode.text === 'prepend'
+          ) {
+            // Module inclusion — treated like implements
+            const parentClass = findRubyParentClass(node);
+            if (parentClass) {
+              const args = node.childForFieldName('arguments');
+              if (args) {
+                for (let i = 0; i < args.childCount; i++) {
+                  const arg = args.child(i);
+                  if (arg && (arg.type === 'constant' || arg.type === 'scope_resolution')) {
+                    classes.push({
+                      name: parentClass,
+                      implements: arg.text,
+                      line: node.startPosition.row + 1,
+                    });
+                  }
+                }
+              }
+            }
+          } else {
+            const recv = node.childForFieldName('receiver');
+            const call = { name: methodNode.text, line: node.startPosition.row + 1 };
+            if (recv) call.receiver = recv.text;
+            calls.push(call);
+          }
+        }
+        break;
+      }
+    }
+
+    for (let i = 0; i < node.childCount; i++) walkRubyNode(node.child(i));
+  }
+
+  walkRubyNode(tree.rootNode);
+  return { definitions, calls, imports, classes, exports };
+}