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

package/src/extractors/python.js

@@ -0,0 +1,143 @@
+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;
+          if (fn.type === 'identifier') callName = fn.text;
+          else if (fn.type === 'attribute') {
+            const attr = fn.childForFieldName('attribute');
+            if (attr) callName = attr.text;
+          }
+          if (callName) calls.push({ name: callName, line: node.startPosition.row + 1 });
+        }
+        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,185 @@
+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 {
+            calls.push({ name: methodNode.text, line: node.startPosition.row + 1 });
+          }
+        }
+        break;
+      }
+    }
+
+    for (let i = 0; i < node.childCount; i++) walkRubyNode(node.child(i));
+  }
+
+  walkRubyNode(tree.rootNode);
+  return { definitions, calls, imports, classes, exports };
+}

package/src/extractors/rust.js

@@ -0,0 +1,215 @@
+import { nodeEndLine } from './helpers.js';
+
+/**
+ * Extract symbols from Rust files.
+ */
+export function extractRustSymbols(tree, _filePath) {
+  const definitions = [];
+  const calls = [];
+  const imports = [];
+  const classes = [];
+  const exports = [];
+
+  function findCurrentImpl(node) {
+    let current = node.parent;
+    while (current) {
+      if (current.type === 'impl_item') {
+        const typeNode = current.childForFieldName('type');
+        return typeNode ? typeNode.text : null;
+      }
+      current = current.parent;
+    }
+    return null;
+  }
+
+  function walkRustNode(node) {
+    switch (node.type) {
+      case 'function_item': {
+        const nameNode = node.childForFieldName('name');
+        if (nameNode) {
+          const implType = findCurrentImpl(node);
+          const fullName = implType ? `${implType}.${nameNode.text}` : nameNode.text;
+          const kind = implType ? 'method' : 'function';
+          definitions.push({
+            name: fullName,
+            kind,
+            line: node.startPosition.row + 1,
+            endLine: nodeEndLine(node),
+          });
+        }
+        break;
+      }
+
+      case 'struct_item': {
+        const nameNode = node.childForFieldName('name');
+        if (nameNode) {
+          definitions.push({
+            name: nameNode.text,
+            kind: 'struct',
+            line: node.startPosition.row + 1,
+            endLine: nodeEndLine(node),
+          });
+        }
+        break;
+      }
+
+      case 'enum_item': {
+        const nameNode = node.childForFieldName('name');
+        if (nameNode) {
+          definitions.push({
+            name: nameNode.text,
+            kind: 'enum',
+            line: node.startPosition.row + 1,
+            endLine: nodeEndLine(node),
+          });
+        }
+        break;
+      }
+
+      case 'trait_item': {
+        const nameNode = node.childForFieldName('name');
+        if (nameNode) {
+          definitions.push({
+            name: nameNode.text,
+            kind: 'trait',
+            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 === 'function_signature_item' || child.type === 'function_item')
+              ) {
+                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 'impl_item': {
+        const typeNode = node.childForFieldName('type');
+        const traitNode = node.childForFieldName('trait');
+        if (typeNode && traitNode) {
+          classes.push({
+            name: typeNode.text,
+            implements: traitNode.text,
+            line: node.startPosition.row + 1,
+          });
+        }
+        break;
+      }
+
+      case 'use_declaration': {
+        const argNode = node.child(1);
+        if (argNode) {
+          const usePaths = extractRustUsePath(argNode);
+          for (const imp of usePaths) {
+            imports.push({
+              source: imp.source,
+              names: imp.names,
+              line: node.startPosition.row + 1,
+              rustUse: 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 === 'field_expression') {
+            const field = fn.childForFieldName('field');
+            if (field) calls.push({ name: field.text, line: node.startPosition.row + 1 });
+          } else if (fn.type === 'scoped_identifier') {
+            const name = fn.childForFieldName('name');
+            if (name) calls.push({ name: name.text, line: node.startPosition.row + 1 });
+          }
+        }
+        break;
+      }
+
+      case 'macro_invocation': {
+        const macroNode = node.child(0);
+        if (macroNode) {
+          calls.push({ name: `${macroNode.text}!`, line: node.startPosition.row + 1 });
+        }
+        break;
+      }
+    }
+
+    for (let i = 0; i < node.childCount; i++) walkRustNode(node.child(i));
+  }
+
+  walkRustNode(tree.rootNode);
+  return { definitions, calls, imports, classes, exports };
+}
+
+function extractRustUsePath(node) {
+  if (!node) return [];
+
+  if (node.type === 'use_list') {
+    const results = [];
+    for (let i = 0; i < node.childCount; i++) {
+      results.push(...extractRustUsePath(node.child(i)));
+    }
+    return results;
+  }
+
+  if (node.type === 'scoped_use_list') {
+    const pathNode = node.childForFieldName('path');
+    const listNode = node.childForFieldName('list');
+    const prefix = pathNode ? pathNode.text : '';
+    if (listNode) {
+      const names = [];
+      for (let i = 0; i < listNode.childCount; i++) {
+        const child = listNode.child(i);
+        if (
+          child &&
+          (child.type === 'identifier' || child.type === 'use_as_clause' || child.type === 'self')
+        ) {
+          const name =
+            child.type === 'use_as_clause'
+              ? (child.childForFieldName('alias') || child.childForFieldName('name'))?.text
+              : child.text;
+          if (name) names.push(name);
+        }
+      }
+      return [{ source: prefix, names }];
+    }
+    return [{ source: prefix, names: [] }];
+  }
+
+  if (node.type === 'use_as_clause') {
+    const name = node.childForFieldName('alias') || node.childForFieldName('name');
+    return [{ source: node.text, names: name ? [name.text] : [] }];
+  }
+
+  if (node.type === 'use_wildcard') {
+    const pathNode = node.childForFieldName('path');
+    return [{ source: pathNode ? pathNode.text : '*', names: ['*'] }];
+  }
+
+  if (node.type === 'scoped_identifier' || node.type === 'identifier') {
+    const text = node.text;
+    const lastName = text.split('::').pop();
+    return [{ source: text, names: [lastName] }];
+  }
+
+  return [];
+}

package/src/index.js

@@ -45,6 +45,7 @@ export {
   impactAnalysisData,
   moduleMapData,
   queryNameData,
+  statsData,
 } from './queries.js';
 // Registry (multi-repo)
 export {

package/src/mcp.js

@@ -422,7 +422,8 @@ export async function startMCPServer(customDbPath, options = {}) {
           break;
         }
         case 'list_repos': {
-          const { listRepos } = await import('./registry.js');
+          const { listRepos, pruneRegistry } = await import('./registry.js');
+          pruneRegistry();
           let repos = listRepos();
           if (allowedRepos) {
             repos = repos.filter((r) => allowedRepos.includes(r.name));