@optave/codegraph 3.5.0 → 3.7.0

package/src/extractors/csharp.ts

@@ -6,7 +6,16 @@ import type {
   TreeSitterNode,
   TreeSitterTree,
 } from '../types.js';
-import { extractModifierVisibility, findChild, MAX_WALK_DEPTH, nodeEndLine } from './helpers.js';
+import {
+  extractBodyMembers,
+  extractModifierVisibility,
+  findChild,
+  findParentNode,
+  lastPathSegment,
+  MAX_WALK_DEPTH,
+  nodeEndLine,
+  setTypeMapEntry,
+} from './helpers.js';
 
 /**
  * Extract symbols from C# files.
@@ -208,7 +217,7 @@ function handleCsUsingDirective(node: TreeSitterNode, ctx: ExtractorOutput): voi
     findChild(node, 'identifier');
   if (!nameNode) return;
   const fullPath = nameNode.text;
-  const lastName = fullPath.split('.').pop() ?? fullPath;
+  const lastName = lastPathSegment(fullPath, '.');
   ctx.imports.push({
     source: fullPath,
     names: [lastName],
@@ -246,22 +255,15 @@ function handleCsObjectCreation(node: TreeSitterNode, ctx: ExtractorOutput): voi
   if (typeName) ctx.calls.push({ name: typeName, line: node.startPosition.row + 1 });
 }
 
+const CS_PARENT_TYPES = [
+  'class_declaration',
+  'struct_declaration',
+  'interface_declaration',
+  'enum_declaration',
+  'record_declaration',
+] as const;
 function findCSharpParentType(node: TreeSitterNode): string | null {
-  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;
+  return findParentNode(node, CS_PARENT_TYPES);
 }
 
 // ── Child extraction helpers ────────────────────────────────────────────────
@@ -307,19 +309,12 @@ function extractCSharpClassFields(classNode: TreeSitterNode): SubDeclaration[] {
 }
 
 function extractCSharpEnumMembers(enumNode: TreeSitterNode): SubDeclaration[] {
-  const constants: SubDeclaration[] = [];
-  const body =
-    enumNode.childForFieldName('body') || findChild(enumNode, 'enum_member_declaration_list');
-  if (!body) return constants;
-  for (let i = 0; i < body.childCount; i++) {
-    const member = body.child(i);
-    if (!member || member.type !== 'enum_member_declaration') continue;
-    const nameNode = member.childForFieldName('name');
-    if (nameNode) {
-      constants.push({ name: nameNode.text, kind: 'constant', line: member.startPosition.row + 1 });
-    }
-  }
-  return constants;
+  return extractBodyMembers(
+    enumNode,
+    ['body', 'enum_member_declaration_list'],
+    'enum_member_declaration',
+    'constant',
+  );
 }
 
 // ── Type map extraction ──────────────────────────────────────────────────────
@@ -328,6 +323,31 @@ function extractCSharpTypeMap(node: TreeSitterNode, ctx: ExtractorOutput): void
   extractCSharpTypeMapDepth(node, ctx, 0);
 }
 
+/** Extract type info from a variable_declaration node (local vars with explicit types). */
+function handleCSharpVarDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const typeNode = node.childForFieldName('type') || node.child(0);
+  if (!typeNode || typeNode.type === 'var_keyword') return;
+  const typeName = extractCSharpTypeName(typeNode);
+  if (!typeName) return;
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child || child.type !== 'variable_declarator') continue;
+    const nameNode = child.childForFieldName('name') || child.child(0);
+    if (nameNode && nameNode.type === 'identifier' && ctx.typeMap) {
+      setTypeMapEntry(ctx.typeMap, nameNode.text, typeName, 0.9);
+    }
+  }
+}
+
+/** Extract type info from a parameter node. */
+function handleCSharpParam(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const typeNode = node.childForFieldName('type');
+  const nameNode = node.childForFieldName('name');
+  if (!typeNode || !nameNode) return;
+  const typeName = extractCSharpTypeName(typeNode);
+  if (typeName && ctx.typeMap) setTypeMapEntry(ctx.typeMap, nameNode.text, typeName, 0.9);
+}
+
 function extractCSharpTypeMapDepth(
   node: TreeSitterNode,
   ctx: ExtractorOutput,
@@ -335,33 +355,10 @@ function extractCSharpTypeMapDepth(
 ): void {
   if (depth >= MAX_WALK_DEPTH) return;
 
-  // local_declaration_statement → variable_declaration → type + variable_declarator(s)
   if (node.type === 'variable_declaration') {
-    const typeNode = node.childForFieldName('type') || node.child(0);
-    if (typeNode && typeNode.type !== 'var_keyword') {
-      const typeName = extractCSharpTypeName(typeNode);
-      if (typeName) {
-        for (let i = 0; i < node.childCount; i++) {
-          const child = node.child(i);
-          if (child && child.type === 'variable_declarator') {
-            const nameNode = child.childForFieldName('name') || child.child(0);
-            if (nameNode && nameNode.type === 'identifier') {
-              ctx.typeMap?.set(nameNode.text, { type: typeName, confidence: 0.9 });
-            }
-          }
-        }
-      }
-    }
-  }
-
-  // Method/constructor parameter: parameter node has type + name fields
-  if (node.type === 'parameter') {
-    const typeNode = node.childForFieldName('type');
-    const nameNode = node.childForFieldName('name');
-    if (typeNode && nameNode) {
-      const typeName = extractCSharpTypeName(typeNode);
-      if (typeName) ctx.typeMap?.set(nameNode.text, { type: typeName, confidence: 0.9 });
-    }
+    handleCSharpVarDecl(node, ctx);
+  } else if (node.type === 'parameter') {
+    handleCSharpParam(node, ctx);
   }
 
   for (let i = 0; i < node.childCount; i++) {

package/src/extractors/dart.ts

@@ -0,0 +1,304 @@
+import type { ExtractorOutput, SubDeclaration, TreeSitterNode, TreeSitterTree } from '../types.js';
+import { findChild, nodeEndLine } from './helpers.js';
+
+/**
+ * Extract symbols from Dart files.
+ */
+export function extractDartSymbols(tree: TreeSitterTree, _filePath: string): ExtractorOutput {
+  const ctx: ExtractorOutput = {
+    definitions: [],
+    calls: [],
+    imports: [],
+    classes: [],
+    exports: [],
+    typeMap: new Map(),
+  };
+
+  walkDartNode(tree.rootNode, ctx);
+  return ctx;
+}
+
+function walkDartNode(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  switch (node.type) {
+    case 'class_definition':
+      handleDartClass(node, ctx);
+      break;
+    case 'enum_declaration':
+      handleDartEnum(node, ctx);
+      break;
+    case 'mixin_declaration':
+      handleDartMixin(node, ctx);
+      break;
+    case 'extension_declaration':
+      handleDartExtension(node, ctx);
+      break;
+    case 'function_signature':
+      handleDartFunction(node, ctx);
+      break;
+    case 'method_signature':
+      handleDartMethodSig(node, ctx);
+      break;
+    case 'library_import':
+      handleDartImport(node, ctx);
+      break;
+    case 'constructor_invocation':
+    case 'new_expression':
+      handleDartConstructorCall(node, ctx);
+      break;
+    case 'type_alias':
+      handleDartTypeAlias(node, ctx);
+      break;
+    case 'selector':
+      handleDartSelector(node, ctx);
+      break;
+  }
+
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) walkDartNode(child, ctx);
+  }
+}
+
+function handleDartClass(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const nameNode = node.childForFieldName('name');
+  if (!nameNode) return;
+  const name = nameNode.text;
+  const children: SubDeclaration[] = [];
+
+  const body = node.childForFieldName('body') || findChild(node, 'class_body');
+  if (body) {
+    extractDartClassMembers(body, name, ctx, children);
+  }
+
+  ctx.definitions.push({
+    name,
+    kind: 'class',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+    children: children.length > 0 ? children : undefined,
+  });
+
+  extractDartInheritance(node, name, ctx);
+}
+
+function extractDartClassMembers(
+  body: TreeSitterNode,
+  className: string,
+  ctx: ExtractorOutput,
+  children: SubDeclaration[],
+): void {
+  for (let i = 0; i < body.childCount; i++) {
+    const member = body.child(i);
+    if (!member) continue;
+
+    if (member.type === 'method_signature' || member.type === 'function_signature') {
+      const fnName = extractDartFunctionName(member);
+      if (fnName) {
+        ctx.definitions.push({
+          name: `${className}.${fnName}`,
+          kind: 'method',
+          line: member.startPosition.row + 1,
+          endLine: nodeEndLine(member),
+        });
+      }
+    } else if (member.type === 'declaration') {
+      // Field declarations
+      for (let j = 0; j < member.childCount; j++) {
+        const decl = member.child(j);
+        if (decl?.type === 'identifier') {
+          children.push({
+            name: decl.text,
+            kind: 'property',
+            line: member.startPosition.row + 1,
+          });
+          break;
+        }
+      }
+    }
+  }
+}
+
+function extractDartFunctionName(node: TreeSitterNode): string | null {
+  const nameNode = node.childForFieldName('name');
+  if (nameNode) return nameNode.text;
+
+  // Walk children for function_signature inside method_signature
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    if (
+      child.type === 'function_signature' ||
+      child.type === 'getter_signature' ||
+      child.type === 'setter_signature' ||
+      child.type === 'constructor_signature'
+    ) {
+      const name = child.childForFieldName('name');
+      if (name) return name.text;
+    }
+  }
+  return null;
+}
+
+function handleDartEnum(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const nameNode = node.childForFieldName('name');
+  if (!nameNode) return;
+
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'enum',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+  });
+}
+
+function handleDartMixin(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const nameNode = findChild(node, 'identifier');
+  if (!nameNode) return;
+
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'class',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+  });
+}
+
+function handleDartExtension(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const nameNode = node.childForFieldName('name');
+  if (!nameNode) return;
+
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'class',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+  });
+}
+
+function handleDartFunction(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  // Skip methods already emitted by class handler
+  if (isInsideDartClass(node)) return;
+
+  const nameNode = node.childForFieldName('name');
+  if (!nameNode) return;
+
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'function',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+  });
+}
+
+function handleDartMethodSig(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  if (isInsideDartClass(node)) return;
+  const fnName = extractDartFunctionName(node);
+  if (!fnName) return;
+
+  ctx.definitions.push({
+    name: fnName,
+    kind: 'function',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+  });
+}
+
+function isInsideDartClass(node: TreeSitterNode): boolean {
+  let current = node.parent;
+  while (current) {
+    if (
+      current.type === 'class_body' ||
+      current.type === 'class_definition' ||
+      current.type === 'enum_body' ||
+      current.type === 'mixin_declaration'
+    ) {
+      return true;
+    }
+    current = current.parent;
+  }
+  return false;
+}
+
+function handleDartImport(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const spec = findChild(node, 'import_specification');
+  if (!spec) return;
+
+  const uri = findChild(spec, 'configurable_uri') || findChild(spec, 'uri');
+  if (!uri) return;
+
+  const source = uri.text.replace(/^['"]|['"]$/g, '');
+  const names: string[] = [];
+
+  // Check for `as` alias
+  const alias = findChild(spec, 'identifier');
+  if (alias) names.push(alias.text);
+
+  ctx.imports.push({
+    source,
+    names: names.length > 0 ? names : [source.split('/').pop() || source],
+    line: node.startPosition.row + 1,
+  });
+}
+
+function handleDartConstructorCall(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const nameNode = findChild(node, 'type_identifier') || findChild(node, 'identifier');
+  if (!nameNode) return;
+
+  ctx.calls.push({
+    name: nameNode.text,
+    line: node.startPosition.row + 1,
+  });
+}
+
+function handleDartSelector(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  // selector with argument_part represents a function call
+  const argPart = findChild(node, 'argument_part');
+  if (!argPart) return;
+
+  // Look for the identifier this selector belongs to
+  const unconditional = findChild(node, 'unconditional_assignable_selector');
+  if (unconditional) {
+    const id = findChild(unconditional, 'identifier');
+    if (id) {
+      ctx.calls.push({ name: id.text, line: node.startPosition.row + 1 });
+    }
+  }
+}
+
+function handleDartTypeAlias(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const nameNode = findChild(node, 'type_identifier') || findChild(node, 'identifier');
+  if (!nameNode) return;
+
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'type',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+  });
+}
+
+function extractDartInheritance(node: TreeSitterNode, name: string, ctx: ExtractorOutput): void {
+  const superclass = node.childForFieldName('superclass');
+  if (superclass) {
+    const typeName =
+      findChild(superclass, 'type_identifier') || findChild(superclass, 'identifier');
+    if (typeName) {
+      ctx.classes.push({ name, extends: typeName.text, line: node.startPosition.row + 1 });
+    }
+  }
+
+  const interfaces = node.childForFieldName('interfaces');
+  if (interfaces) {
+    for (let i = 0; i < interfaces.childCount; i++) {
+      const iface = interfaces.child(i);
+      if (!iface) continue;
+      const typeName =
+        iface.type === 'type_identifier'
+          ? iface
+          : findChild(iface, 'type_identifier') || findChild(iface, 'identifier');
+      if (typeName) {
+        ctx.classes.push({ name, implements: typeName.text, line: node.startPosition.row + 1 });
+      }
+    }
+  }
+}

package/src/extractors/elixir.ts

@@ -0,0 +1,251 @@
+import type {
+  Call,
+  ExtractorOutput,
+  SubDeclaration,
+  TreeSitterNode,
+  TreeSitterTree,
+} from '../types.js';
+import { findChild, nodeEndLine } from './helpers.js';
+
+/**
+ * Extract symbols from Elixir files.
+ *
+ * Elixir's tree-sitter grammar represents most constructs as generic `call` nodes.
+ * We distinguish modules, functions, imports etc. by the call target's identifier text.
+ */
+export function extractElixirSymbols(tree: TreeSitterTree, _filePath: string): ExtractorOutput {
+  const ctx: ExtractorOutput = {
+    definitions: [],
+    calls: [],
+    imports: [],
+    classes: [],
+    exports: [],
+    typeMap: new Map(),
+  };
+
+  walkElixirNode(tree.rootNode, ctx, null);
+  return ctx;
+}
+
+function walkElixirNode(
+  node: TreeSitterNode,
+  ctx: ExtractorOutput,
+  currentModule: string | null,
+): void {
+  let nextModule = currentModule;
+
+  if (node.type === 'call') {
+    const target = node.childForFieldName('target');
+    if (target?.type === 'identifier' && target.text === 'defmodule') {
+      const args = findChild(node, 'arguments');
+      const aliasNode = args && findChild(args, 'alias');
+      if (aliasNode) nextModule = aliasNode.text;
+    }
+    handleElixirCall(node, ctx, nextModule);
+  }
+
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) walkElixirNode(child, ctx, nextModule);
+  }
+}
+
+function handleElixirCall(
+  node: TreeSitterNode,
+  ctx: ExtractorOutput,
+  currentModule: string | null,
+): void {
+  const target = node.childForFieldName('target');
+  if (!target) return;
+
+  if (target.type === 'identifier') {
+    const keyword = target.text;
+    switch (keyword) {
+      case 'defmodule':
+        handleDefmodule(node, ctx);
+        return;
+      case 'def':
+      case 'defp':
+        handleDefFunction(node, ctx, currentModule, keyword === 'defp' ? 'private' : 'public');
+        return;
+      case 'defprotocol':
+        handleDefprotocol(node, ctx);
+        return;
+      case 'defimpl':
+        handleDefimpl(node, ctx);
+        return;
+      case 'import':
+      case 'use':
+      case 'require':
+      case 'alias':
+        handleElixirImport(node, ctx, keyword);
+        return;
+      default:
+        // Regular function call
+        ctx.calls.push({ name: keyword, line: node.startPosition.row + 1 });
+        return;
+    }
+  }
+
+  if (target.type === 'dot') {
+    handleDotCall(node, target, ctx);
+  }
+}
+
+function handleDefmodule(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const args = findChild(node, 'arguments');
+  if (!args) return;
+  const aliasNode = findChild(args, 'alias');
+  if (!aliasNode) return;
+  const name = aliasNode.text;
+
+  const children: SubDeclaration[] = [];
+  const doBlock = findChild(node, 'do_block');
+  if (doBlock) {
+    collectModuleMembers(doBlock, ctx, name, children);
+  }
+
+  ctx.definitions.push({
+    name,
+    kind: 'module',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+    children: children.length > 0 ? children : undefined,
+  });
+}
+
+function collectModuleMembers(
+  doBlock: TreeSitterNode,
+  _ctx: ExtractorOutput,
+  _moduleName: string,
+  children: SubDeclaration[],
+): void {
+  for (let i = 0; i < doBlock.childCount; i++) {
+    const child = doBlock.child(i);
+    if (!child || child.type !== 'call') continue;
+    const target = child.childForFieldName('target');
+    if (!target || target.type !== 'identifier') continue;
+
+    if (target.text === 'def' || target.text === 'defp') {
+      const fnName = extractFunctionName(child);
+      if (fnName) {
+        children.push({
+          name: fnName,
+          kind: 'property',
+          line: child.startPosition.row + 1,
+        });
+      }
+    }
+  }
+}
+
+function handleDefFunction(
+  node: TreeSitterNode,
+  ctx: ExtractorOutput,
+  currentModule: string | null,
+  visibility: 'public' | 'private',
+): void {
+  const fnName = extractFunctionName(node);
+  if (!fnName) return;
+
+  const fullName = currentModule ? `${currentModule}.${fnName}` : fnName;
+  const params = extractElixirParams(node);
+
+  ctx.definitions.push({
+    name: fullName,
+    kind: 'function',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+    visibility,
+    children: params.length > 0 ? params : undefined,
+  });
+}
+
+function extractFunctionName(defCallNode: TreeSitterNode): string | null {
+  const args = findChild(defCallNode, 'arguments');
+  if (!args) return null;
+
+  for (let i = 0; i < args.childCount; i++) {
+    const child = args.child(i);
+    if (!child) continue;
+    if (child.type === 'call') {
+      const target = child.childForFieldName('target');
+      if (target?.type === 'identifier') return target.text;
+    }
+    if (child.type === 'identifier') return child.text;
+  }
+  return null;
+}
+
+function extractElixirParams(defCallNode: TreeSitterNode): SubDeclaration[] {
+  const params: SubDeclaration[] = [];
+  const args = findChild(defCallNode, 'arguments');
+  if (!args) return params;
+
+  for (let i = 0; i < args.childCount; i++) {
+    const child = args.child(i);
+    if (!child || child.type !== 'call') continue;
+    const innerArgs = findChild(child, 'arguments');
+    if (!innerArgs) continue;
+    for (let j = 0; j < innerArgs.childCount; j++) {
+      const param = innerArgs.child(j);
+      if (!param) continue;
+      if (param.type === 'identifier') {
+        params.push({ name: param.text, kind: 'parameter', line: param.startPosition.row + 1 });
+      }
+    }
+  }
+  return params;
+}
+
+function handleDefprotocol(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const args = findChild(node, 'arguments');
+  if (!args) return;
+  const aliasNode = findChild(args, 'alias');
+  if (!aliasNode) return;
+
+  ctx.definitions.push({
+    name: aliasNode.text,
+    kind: 'interface',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+  });
+}
+
+function handleDefimpl(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const args = findChild(node, 'arguments');
+  if (!args) return;
+  const aliasNode = findChild(args, 'alias');
+  if (!aliasNode) return;
+
+  ctx.definitions.push({
+    name: aliasNode.text,
+    kind: 'class',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+  });
+}
+
+function handleElixirImport(node: TreeSitterNode, ctx: ExtractorOutput, keyword: string): void {
+  const args = findChild(node, 'arguments');
+  if (!args) return;
+  const aliasNode = findChild(args, 'alias');
+  if (!aliasNode) return;
+
+  ctx.imports.push({
+    source: aliasNode.text,
+    names: [keyword],
+    line: node.startPosition.row + 1,
+  });
+}
+
+function handleDotCall(node: TreeSitterNode, dotNode: TreeSitterNode, ctx: ExtractorOutput): void {
+  const call: Call = { name: '', line: node.startPosition.row + 1 };
+  const right = findChild(dotNode, 'identifier');
+  const left = findChild(dotNode, 'alias');
+
+  if (right) call.name = right.text;
+  if (left) call.receiver = left.text;
+
+  if (call.name) ctx.calls.push(call);
+}