@optave/codegraph 3.6.0 → 3.7.0

package/src/extractors/haskell.ts

@@ -0,0 +1,235 @@
+import type { ExtractorOutput, SubDeclaration, TreeSitterNode, TreeSitterTree } from '../types.js';
+import { findChild, nodeEndLine } from './helpers.js';
+
+/**
+ * Extract symbols from Haskell files.
+ *
+ * Note: tree-sitter-haskell uses `type_synomym` (misspelled) for type aliases.
+ */
+export function extractHaskellSymbols(tree: TreeSitterTree, _filePath: string): ExtractorOutput {
+  const ctx: ExtractorOutput = {
+    definitions: [],
+    calls: [],
+    imports: [],
+    classes: [],
+    exports: [],
+    typeMap: new Map(),
+  };
+
+  walkHaskellNode(tree.rootNode, ctx);
+  return ctx;
+}
+
+function walkHaskellNode(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  switch (node.type) {
+    case 'function':
+      handleHaskellFunction(node, ctx);
+      break;
+    case 'bind':
+      handleHaskellBind(node, ctx);
+      break;
+    case 'data_type':
+      handleHaskellDataType(node, ctx);
+      break;
+    case 'newtype':
+      handleHaskellNewtype(node, ctx);
+      break;
+    case 'type_synomym':
+      handleHaskellTypeSynonym(node, ctx);
+      break;
+    case 'class':
+      handleHaskellClass(node, ctx);
+      break;
+    case 'instance':
+      handleHaskellInstance(node, ctx);
+      break;
+    case 'import':
+      handleHaskellImport(node, ctx);
+      break;
+    case 'apply':
+      handleHaskellApply(node, ctx);
+      break;
+  }
+
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) walkHaskellNode(child, ctx);
+  }
+}
+
+function handleHaskellFunction(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const nameNode = node.childForFieldName('name');
+  if (!nameNode) return;
+
+  const params = extractHaskellParams(node);
+
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'function',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+    children: params.length > 0 ? params : undefined,
+  });
+}
+
+function extractHaskellParams(funcNode: TreeSitterNode): SubDeclaration[] {
+  const params: SubDeclaration[] = [];
+  // Haskell function patterns are positional children
+  for (let i = 0; i < funcNode.childCount; i++) {
+    const child = funcNode.child(i);
+    if (!child) continue;
+    if (child.type === 'patterns' || child.type === 'parameter') {
+      for (let j = 0; j < child.childCount; j++) {
+        const pat = child.child(j);
+        if (pat && (pat.type === 'variable' || pat.type === 'identifier')) {
+          params.push({ name: pat.text, kind: 'parameter', line: pat.startPosition.row + 1 });
+        }
+      }
+    }
+    if (child.type === 'variable' && i > 0) {
+      // Pattern parameters after the function name
+      params.push({ name: child.text, kind: 'parameter', line: child.startPosition.row + 1 });
+    }
+  }
+  return params;
+}
+
+function handleHaskellBind(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const nameNode = node.childForFieldName('name');
+  if (!nameNode) return;
+
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'variable',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+  });
+}
+
+function handleHaskellDataType(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const nameNode = node.childForFieldName('name');
+  if (!nameNode) return;
+  const name = nameNode.text;
+
+  const children: SubDeclaration[] = [];
+  // Extract constructors
+  const constructors = node.childForFieldName('constructors');
+  if (constructors) {
+    for (let i = 0; i < constructors.childCount; i++) {
+      const ctor = constructors.child(i);
+      if (!ctor) continue;
+      if (ctor.type === 'data_constructor' || ctor.type === 'gadt_constructor') {
+        const ctorName = findChild(ctor, 'constructor') || findChild(ctor, 'constructor_operator');
+        if (ctorName) {
+          children.push({
+            name: ctorName.text,
+            kind: 'property',
+            line: ctor.startPosition.row + 1,
+          });
+        }
+      }
+    }
+  }
+
+  ctx.definitions.push({
+    name,
+    kind: 'type',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+    children: children.length > 0 ? children : undefined,
+  });
+}
+
+function handleHaskellNewtype(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const nameNode = node.childForFieldName('name');
+  if (!nameNode) return;
+
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'type',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+  });
+}
+
+function handleHaskellTypeSynonym(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const nameNode = node.childForFieldName('name');
+  if (!nameNode) return;
+
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'type',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+  });
+}
+
+function handleHaskellClass(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 handleHaskellInstance(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 handleHaskellImport(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const moduleNode = node.childForFieldName('module');
+  if (!moduleNode) return;
+
+  const source = moduleNode.text;
+  const names: string[] = [];
+
+  const alias = node.childForFieldName('alias');
+  if (alias) names.push(alias.text);
+
+  const importList = node.childForFieldName('names');
+  if (importList) {
+    for (let i = 0; i < importList.childCount; i++) {
+      const item = importList.child(i);
+      if (
+        item &&
+        (item.type === 'variable' || item.type === 'constructor' || item.type === 'type')
+      ) {
+        names.push(item.text);
+      }
+    }
+  }
+
+  ctx.imports.push({
+    source,
+    names: names.length > 0 ? names : [source.split('.').pop() || source],
+    line: node.startPosition.row + 1,
+  });
+}
+
+function handleHaskellApply(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const funcNode = node.childForFieldName('function');
+  if (!funcNode) return;
+
+  // Only record named function applications, not complex expressions
+  if (
+    funcNode.type === 'variable' ||
+    funcNode.type === 'constructor' ||
+    funcNode.type === 'identifier'
+  ) {
+    ctx.calls.push({ name: funcNode.text, line: node.startPosition.row + 1 });
+  } else if (funcNode.type === 'qualified_variable' || funcNode.type === 'qualified_constructor') {
+    ctx.calls.push({ name: funcNode.text, line: node.startPosition.row + 1 });
+  }
+}

package/src/extractors/index.ts

@@ -2,14 +2,20 @@ export { extractBashSymbols } from './bash.js';
 export { extractCSymbols } from './c.js';
 export { extractCppSymbols } from './cpp.js';
 export { extractCSharpSymbols } from './csharp.js';
+export { extractDartSymbols } from './dart.js';
+export { extractElixirSymbols } from './elixir.js';
 export { extractGoSymbols } from './go.js';
+export { extractHaskellSymbols } from './haskell.js';
 export { extractHCLSymbols } from './hcl.js';
 export { extractJavaSymbols } from './java.js';
 export { extractSymbols } from './javascript.js';
 export { extractKotlinSymbols } from './kotlin.js';
+export { extractLuaSymbols } from './lua.js';
+export { extractOCamlSymbols } from './ocaml.js';
 export { extractPHPSymbols } from './php.js';
 export { extractPythonSymbols } from './python.js';
 export { extractRubySymbols } from './ruby.js';
 export { extractRustSymbols } from './rust.js';
 export { extractScalaSymbols } from './scala.js';
 export { extractSwiftSymbols } from './swift.js';
+export { extractZigSymbols } from './zig.js';

package/src/extractors/lua.ts

@@ -0,0 +1,169 @@
+import type {
+  Call,
+  ExtractorOutput,
+  SubDeclaration,
+  TreeSitterNode,
+  TreeSitterTree,
+} from '../types.js';
+import { findChild, nodeEndLine } from './helpers.js';
+
+/**
+ * Extract symbols from Lua files.
+ */
+export function extractLuaSymbols(tree: TreeSitterTree, _filePath: string): ExtractorOutput {
+  const ctx: ExtractorOutput = {
+    definitions: [],
+    calls: [],
+    imports: [],
+    classes: [],
+    exports: [],
+    typeMap: new Map(),
+  };
+
+  walkLuaNode(tree.rootNode, ctx);
+  return ctx;
+}
+
+function walkLuaNode(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  switch (node.type) {
+    case 'function_declaration':
+      handleLuaFunctionDecl(node, ctx);
+      break;
+    case 'variable_declaration':
+      handleLuaVariableDecl(node, ctx);
+      break;
+    case 'function_call':
+      handleLuaFunctionCall(node, ctx);
+      break;
+  }
+
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) walkLuaNode(child, ctx);
+  }
+}
+
+function handleLuaFunctionDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const nameNode = node.childForFieldName('name');
+  if (!nameNode) return;
+
+  let name: string;
+  let kind: 'function' | 'method' = 'function';
+
+  if (nameNode.type === 'method_index_expression') {
+    const table = nameNode.childForFieldName('table');
+    const method = nameNode.childForFieldName('method');
+    if (table && method) {
+      name = `${table.text}.${method.text}`;
+      kind = 'method';
+    } else {
+      name = nameNode.text;
+    }
+  } else if (nameNode.type === 'dot_index_expression') {
+    const table = nameNode.childForFieldName('table');
+    const field = nameNode.childForFieldName('field');
+    if (table && field) {
+      name = `${table.text}.${field.text}`;
+      kind = 'method';
+    } else {
+      name = nameNode.text;
+    }
+  } else {
+    name = nameNode.text;
+  }
+
+  const params = extractLuaParams(node);
+
+  ctx.definitions.push({
+    name,
+    kind,
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+    children: params.length > 0 ? params : undefined,
+  });
+}
+
+function extractLuaParams(funcNode: TreeSitterNode): SubDeclaration[] {
+  const params: SubDeclaration[] = [];
+  const paramList = funcNode.childForFieldName('parameters');
+  if (!paramList) return params;
+
+  for (let i = 0; i < paramList.childCount; i++) {
+    const param = paramList.child(i);
+    if (!param || param.type !== 'identifier') continue;
+    params.push({ name: param.text, kind: 'parameter', line: param.startPosition.row + 1 });
+  }
+  return params;
+}
+
+function handleLuaVariableDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  // Check for require calls in the assignment
+  const assignment = findChild(node, 'assignment_statement');
+  if (assignment) {
+    checkForRequire(assignment, ctx);
+  }
+}
+
+function checkForRequire(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    if (child.type === 'function_call') {
+      const nameNode = child.childForFieldName('name');
+      if (nameNode && nameNode.type === 'identifier' && nameNode.text === 'require') {
+        const args = child.childForFieldName('arguments');
+        if (args) {
+          const strArg = findChild(args, 'string');
+          if (strArg) {
+            const source = strArg.text.replace(/^['"]|['"]$/g, '');
+            ctx.imports.push({
+              source,
+              names: ['require'],
+              line: child.startPosition.row + 1,
+            });
+          }
+        }
+      }
+    }
+  }
+}
+
+function handleLuaFunctionCall(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const nameNode = node.childForFieldName('name');
+  if (!nameNode) return;
+
+  // Check for require() as import
+  if (nameNode.type === 'identifier' && nameNode.text === 'require') {
+    const args = node.childForFieldName('arguments');
+    if (args) {
+      const strArg = findChild(args, 'string');
+      if (strArg) {
+        const source = strArg.text.replace(/^['"]|['"]$/g, '');
+        ctx.imports.push({
+          source,
+          names: ['require'],
+          line: node.startPosition.row + 1,
+        });
+        return;
+      }
+    }
+  }
+
+  const call: Call = { name: '', line: node.startPosition.row + 1 };
+
+  if (nameNode.type === 'method_index_expression') {
+    const table = nameNode.childForFieldName('table');
+    const method = nameNode.childForFieldName('method');
+    if (method) call.name = method.text;
+    if (table) call.receiver = table.text;
+  } else if (nameNode.type === 'dot_index_expression') {
+    const table = nameNode.childForFieldName('table');
+    const field = nameNode.childForFieldName('field');
+    if (field) call.name = field.text;
+    if (table) call.receiver = table.text;
+  } else {
+    call.name = nameNode.text;
+  }
+
+  if (call.name) ctx.calls.push(call);
+}

package/src/extractors/ocaml.ts

@@ -0,0 +1,259 @@
+import type {
+  Call,
+  ExtractorOutput,
+  SubDeclaration,
+  TreeSitterNode,
+  TreeSitterTree,
+} from '../types.js';
+import { findChild, nodeEndLine } from './helpers.js';
+
+/**
+ * Extract symbols from OCaml files.
+ */
+export function extractOCamlSymbols(tree: TreeSitterTree, _filePath: string): ExtractorOutput {
+  const ctx: ExtractorOutput = {
+    definitions: [],
+    calls: [],
+    imports: [],
+    classes: [],
+    exports: [],
+    typeMap: new Map(),
+  };
+
+  walkOCamlNode(tree.rootNode, ctx);
+  return ctx;
+}
+
+function walkOCamlNode(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  switch (node.type) {
+    case 'value_definition':
+      handleOCamlValueDef(node, ctx);
+      break;
+    case 'let_binding':
+      // Only handle top-level let bindings not inside value_definition
+      if (node.parent?.type !== 'value_definition') {
+        handleOCamlLetBinding(node, ctx);
+      }
+      break;
+    case 'module_definition':
+      handleOCamlModuleDef(node, ctx);
+      break;
+    case 'type_definition':
+      handleOCamlTypeDef(node, ctx);
+      break;
+    case 'class_definition':
+      handleOCamlClassDef(node, ctx);
+      break;
+    case 'open_module':
+      handleOCamlOpen(node, ctx);
+      break;
+    case 'application_expression':
+      handleOCamlApplication(node, ctx);
+      break;
+  }
+
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) walkOCamlNode(child, ctx);
+  }
+}
+
+function handleOCamlValueDef(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  // value_definition contains one or more let_bindings
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child && child.type === 'let_binding') {
+      handleOCamlLetBinding(child, ctx);
+    }
+  }
+}
+
+function handleOCamlLetBinding(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  // let_binding has a pattern (the name) and optionally a body
+  const pattern = node.childForFieldName('pattern');
+  if (!pattern) return;
+
+  // Check if this is a function (has parameter children)
+  const hasParams = hasOCamlParams(node);
+  const name = extractOCamlPatternName(pattern);
+  if (!name) return;
+
+  if (hasParams) {
+    const params = extractOCamlParams(node);
+    ctx.definitions.push({
+      name,
+      kind: 'function',
+      line: node.startPosition.row + 1,
+      endLine: nodeEndLine(node),
+      children: params.length > 0 ? params : undefined,
+    });
+  } else {
+    ctx.definitions.push({
+      name,
+      kind: 'variable',
+      line: node.startPosition.row + 1,
+      endLine: nodeEndLine(node),
+    });
+  }
+}
+
+function extractOCamlPatternName(pattern: TreeSitterNode): string | null {
+  if (pattern.type === 'value_name' || pattern.type === 'identifier') {
+    return pattern.text;
+  }
+  // Operator definitions like `let (+) a b = ...`
+  if (pattern.type === 'parenthesized_operator') {
+    return pattern.text;
+  }
+  const nameNode = findChild(pattern, 'value_name') || findChild(pattern, 'identifier');
+  return nameNode ? nameNode.text : null;
+}
+
+function hasOCamlParams(letBinding: TreeSitterNode): boolean {
+  for (let i = 0; i < letBinding.childCount; i++) {
+    const child = letBinding.child(i);
+    if (!child) continue;
+    if (child.type === 'parameter' || child.type === 'value_pattern') return true;
+  }
+  return false;
+}
+
+function extractOCamlParams(letBinding: TreeSitterNode): SubDeclaration[] {
+  const params: SubDeclaration[] = [];
+  for (let i = 0; i < letBinding.childCount; i++) {
+    const child = letBinding.child(i);
+    if (!child) continue;
+    if (child.type === 'parameter' || child.type === 'value_pattern') {
+      const name = extractOCamlPatternName(child);
+      if (name) {
+        params.push({ name, kind: 'parameter', line: child.startPosition.row + 1 });
+      }
+    }
+  }
+  return params;
+}
+
+function handleOCamlModuleDef(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const binding = findChild(node, 'module_binding');
+  if (!binding) return;
+
+  const nameNode =
+    binding.childForFieldName('name') ||
+    findChild(binding, 'module_name') ||
+    findChild(binding, 'identifier');
+  if (!nameNode) return;
+
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'module',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+  });
+}
+
+function handleOCamlTypeDef(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  // type_definition contains one or more type_bindings
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child || child.type !== 'type_binding') continue;
+
+    const nameNode =
+      child.childForFieldName('name') ||
+      findChild(child, 'type_constructor') ||
+      findChild(child, 'identifier');
+    if (!nameNode) continue;
+
+    const children: SubDeclaration[] = [];
+    extractOCamlTypeConstructors(child, children);
+
+    ctx.definitions.push({
+      name: nameNode.text,
+      kind: 'type',
+      line: child.startPosition.row + 1,
+      endLine: nodeEndLine(child),
+      children: children.length > 0 ? children : undefined,
+    });
+  }
+}
+
+function extractOCamlTypeConstructors(
+  typeBinding: TreeSitterNode,
+  children: SubDeclaration[],
+): void {
+  for (let i = 0; i < typeBinding.childCount; i++) {
+    const child = typeBinding.child(i);
+    if (!child) continue;
+    if (child.type === 'constructor_declaration') {
+      const nameNode = findChild(child, 'constructor_name') || findChild(child, 'identifier');
+      if (nameNode) {
+        children.push({ name: nameNode.text, kind: 'property', line: child.startPosition.row + 1 });
+      }
+    }
+  }
+}
+
+function handleOCamlClassDef(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const binding = findChild(node, 'class_binding');
+  if (!binding) return;
+
+  const nameNode = binding.childForFieldName('name') || findChild(binding, 'identifier');
+  if (!nameNode) return;
+
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'class',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+  });
+}
+
+function handleOCamlOpen(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  // open_module contains a module_path
+  let moduleName: string | null = null;
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    if (
+      child.type === 'module_path' ||
+      child.type === 'module_name' ||
+      child.type === 'extended_module_path' ||
+      child.type === 'constructor_name'
+    ) {
+      moduleName = child.text;
+      break;
+    }
+  }
+  if (!moduleName) return;
+
+  ctx.imports.push({
+    source: moduleName,
+    names: [moduleName.split('.').pop() || moduleName],
+    line: node.startPosition.row + 1,
+  });
+}
+
+function handleOCamlApplication(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  // application_expression: first child is the function, rest are arguments
+  const funcNode = node.child(0);
+  if (!funcNode) return;
+
+  if (
+    funcNode.type === 'value_path' ||
+    funcNode.type === 'value_name' ||
+    funcNode.type === 'identifier'
+  ) {
+    ctx.calls.push({ name: funcNode.text, line: node.startPosition.row + 1 });
+  } else if (funcNode.type === 'field_get_expression') {
+    // Module.function calls
+    const field =
+      funcNode.childForFieldName('field') ||
+      findChild(funcNode, 'value_name') ||
+      findChild(funcNode, 'identifier');
+    const record = funcNode.child(0);
+    if (field) {
+      const call: Call = { name: field.text, line: node.startPosition.row + 1 };
+      if (record && record !== field) call.receiver = record.text;
+      ctx.calls.push(call);
+    }
+  }
+}