@optave/codegraph 3.5.0 → 3.7.0

package/src/extractors/go.ts

@@ -4,9 +4,16 @@ import type {
   SubDeclaration,
   TreeSitterNode,
   TreeSitterTree,
-  TypeMapEntry,
 } from '../types.js';
-import { findChild, goVisibility, MAX_WALK_DEPTH, nodeEndLine } from './helpers.js';
+import {
+  findChild,
+  goVisibility,
+  lastPathSegment,
+  MAX_WALK_DEPTH,
+  nodeEndLine,
+  setTypeMapEntry,
+  stripQuotes,
+} from './helpers.js';
 
 /**
  * Extract symbols from Go files.
@@ -106,43 +113,63 @@ function handleGoTypeDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
     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') {
-        const fields = extractStructFields(typeNode);
-        ctx.definitions.push({
-          name: nameNode.text,
-          kind: 'struct',
-          line: node.startPosition.row + 1,
-          endLine: nodeEndLine(node),
-          children: fields.length > 0 ? fields : undefined,
-        });
-      } else if (typeNode.type === 'interface_type') {
-        ctx.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) {
-              ctx.definitions.push({
-                name: `${nameNode.text}.${methName.text}`,
-                kind: 'method',
-                line: member.startPosition.row + 1,
-                endLine: member.endPosition.row + 1,
-              });
-            }
-          }
-        }
-      } else {
+    if (!nameNode || !typeNode) continue;
+
+    if (typeNode.type === 'struct_type') {
+      handleGoStructType(node, nameNode, typeNode, ctx);
+    } else if (typeNode.type === 'interface_type') {
+      handleGoInterfaceType(node, nameNode, typeNode, ctx);
+    } else {
+      ctx.definitions.push({
+        name: nameNode.text,
+        kind: 'type',
+        line: node.startPosition.row + 1,
+        endLine: nodeEndLine(node),
+      });
+    }
+  }
+}
+
+/** Handle a struct type_spec: emit struct definition with field children. */
+function handleGoStructType(
+  declNode: TreeSitterNode,
+  nameNode: TreeSitterNode,
+  typeNode: TreeSitterNode,
+  ctx: ExtractorOutput,
+): void {
+  const fields = extractStructFields(typeNode);
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'struct',
+    line: declNode.startPosition.row + 1,
+    endLine: nodeEndLine(declNode),
+    children: fields.length > 0 ? fields : undefined,
+  });
+}
+
+/** Handle an interface type_spec: emit interface definition + method definitions. */
+function handleGoInterfaceType(
+  declNode: TreeSitterNode,
+  nameNode: TreeSitterNode,
+  typeNode: TreeSitterNode,
+  ctx: ExtractorOutput,
+): void {
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'interface',
+    line: declNode.startPosition.row + 1,
+    endLine: nodeEndLine(declNode),
+  });
+  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) {
         ctx.definitions.push({
-          name: nameNode.text,
-          kind: 'type',
-          line: node.startPosition.row + 1,
-          endLine: nodeEndLine(node),
+          name: `${nameNode.text}.${methName.text}`,
+          kind: 'method',
+          line: member.startPosition.row + 1,
+          endLine: member.endPosition.row + 1,
         });
       }
     }
@@ -170,9 +197,9 @@ function handleGoImportDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
 function extractGoImportSpec(spec: TreeSitterNode, ctx: ExtractorOutput): void {
   const pathNode = spec.childForFieldName('path');
   if (pathNode) {
-    const importPath = pathNode.text.replace(/"/g, '');
+    const importPath = stripQuotes(pathNode.text);
     const nameNode = spec.childForFieldName('name');
-    const alias = nameNode ? nameNode.text : (importPath.split('/').pop() ?? importPath);
+    const alias = nameNode ? nameNode.text : lastPathSegment(importPath);
     ctx.imports.push({
       source: importPath,
       names: [alias],
@@ -220,113 +247,104 @@ function extractGoTypeMap(node: TreeSitterNode, ctx: ExtractorOutput): void {
   extractGoTypeMapDepth(node, ctx, 0);
 }
 
-function setIfHigher(
-  typeMap: Map<string, TypeMapEntry>,
-  name: string,
-  type: string,
-  confidence: number,
+/** Map identifiers in a typed declaration node to their type (confidence 0.9). */
+function handleTypedIdentifiers(
+  node: TreeSitterNode,
+  typeMap: Map<string, { type: string; confidence: number }>,
 ): void {
-  const existing = typeMap.get(name);
-  if (!existing || confidence > existing.confidence) {
-    typeMap.set(name, { type, confidence });
+  const typeNode = node.childForFieldName('type');
+  if (!typeNode) return;
+  const typeName = extractGoTypeName(typeNode);
+  if (!typeName) return;
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child && child.type === 'identifier') {
+      setTypeMapEntry(typeMap, child.text, typeName, 0.9);
+    }
   }
 }
 
-function extractGoTypeMapDepth(node: TreeSitterNode, ctx: ExtractorOutput, depth: number): void {
-  if (depth >= MAX_WALK_DEPTH) return;
-
-  // var x MyType = ... or var x, y MyType → var_declaration > var_spec (confidence 0.9)
-  if (node.type === 'var_spec') {
-    const typeNode = node.childForFieldName('type');
+/** Infer type from a single RHS expression in a short var declaration. */
+function inferShortVarType(
+  varNode: TreeSitterNode,
+  rhs: TreeSitterNode,
+  typeMap: Map<string, { type: string; confidence: number }>,
+): void {
+  // x := Struct{...} — composite literal (confidence 1.0)
+  if (rhs.type === 'composite_literal') {
+    const typeNode = rhs.childForFieldName('type');
     if (typeNode) {
       const typeName = extractGoTypeName(typeNode);
-      if (typeName) {
-        for (let i = 0; i < node.childCount; i++) {
-          const child = node.child(i);
-          if (child && child.type === 'identifier') {
-            if (ctx.typeMap) setIfHigher(ctx.typeMap, child.text, typeName, 0.9);
-          }
-        }
+      if (typeName) setTypeMapEntry(typeMap, varNode.text, typeName, 1.0);
+    }
+  }
+  // x := &Struct{...} — address-of composite literal (confidence 1.0)
+  if (rhs.type === 'unary_expression') {
+    const operand = rhs.childForFieldName('operand');
+    if (operand && operand.type === 'composite_literal') {
+      const typeNode = operand.childForFieldName('type');
+      if (typeNode) {
+        const typeName = extractGoTypeName(typeNode);
+        if (typeName) setTypeMapEntry(typeMap, varNode.text, typeName, 1.0);
       }
     }
   }
-
-  // Function/method parameter types: parameter_declaration (confidence 0.9)
-  if (node.type === 'parameter_declaration') {
-    const typeNode = node.childForFieldName('type');
-    if (typeNode) {
-      const typeName = extractGoTypeName(typeNode);
-      if (typeName) {
-        for (let i = 0; i < node.childCount; i++) {
-          const child = node.child(i);
-          if (child && child.type === 'identifier') {
-            if (ctx.typeMap) setIfHigher(ctx.typeMap, child.text, typeName, 0.9);
-          }
-        }
+  // x := NewFoo() or x := pkg.NewFoo() — factory function (confidence 0.7)
+  if (rhs.type === 'call_expression') {
+    const fn = rhs.childForFieldName('function');
+    if (fn && fn.type === 'selector_expression') {
+      const field = fn.childForFieldName('field');
+      if (field?.text.startsWith('New')) {
+        const typeName = field.text.slice(3);
+        if (typeName) setTypeMapEntry(typeMap, varNode.text, typeName, 0.7);
       }
+    } else if (fn && fn.type === 'identifier' && fn.text.startsWith('New')) {
+      const typeName = fn.text.slice(3);
+      if (typeName) setTypeMapEntry(typeMap, varNode.text, typeName, 0.7);
     }
   }
+}
 
-  // short_var_declaration: x := Struct{}, x := &Struct{}, x := NewFoo()
-  // Handles multi-variable forms: x, y := A{}, B{}
-  if (node.type === 'short_var_declaration') {
-    const left = node.childForFieldName('left');
-    const right = node.childForFieldName('right');
-    if (left && right) {
-      const lefts =
-        left.type === 'expression_list'
-          ? Array.from({ length: left.childCount }, (_, i) => left.child(i)).filter(
-              (c): c is TreeSitterNode => c?.type === 'identifier',
-            )
-          : left.type === 'identifier'
-            ? [left]
-            : [];
-      const rights =
-        right.type === 'expression_list'
-          ? Array.from({ length: right.childCount }, (_, i) => right.child(i)).filter(
-              (c): c is TreeSitterNode => !!c?.type,
-            )
-          : [right];
-
-      for (let idx = 0; idx < lefts.length; idx++) {
-        const varNode = lefts[idx];
-        const rhs = rights[idx];
-        if (!varNode || !rhs) continue;
-
-        // x := Struct{...} — composite literal (confidence 1.0)
-        if (rhs.type === 'composite_literal') {
-          const typeNode = rhs.childForFieldName('type');
-          if (typeNode) {
-            const typeName = extractGoTypeName(typeNode);
-            if (typeName && ctx.typeMap) setIfHigher(ctx.typeMap, varNode.text, typeName, 1.0);
-          }
-        }
-        // x := &Struct{...} — address-of composite literal (confidence 1.0)
-        if (rhs.type === 'unary_expression') {
-          const operand = rhs.childForFieldName('operand');
-          if (operand && operand.type === 'composite_literal') {
-            const typeNode = operand.childForFieldName('type');
-            if (typeNode) {
-              const typeName = extractGoTypeName(typeNode);
-              if (typeName && ctx.typeMap) setIfHigher(ctx.typeMap, varNode.text, typeName, 1.0);
-            }
-          }
-        }
-        // x := NewFoo() or x := pkg.NewFoo() — factory function (confidence 0.7)
-        if (rhs.type === 'call_expression') {
-          const fn = rhs.childForFieldName('function');
-          if (fn && fn.type === 'selector_expression') {
-            const field = fn.childForFieldName('field');
-            if (field?.text.startsWith('New')) {
-              const typeName = field.text.slice(3);
-              if (typeName && ctx.typeMap) setIfHigher(ctx.typeMap, varNode.text, typeName, 0.7);
-            }
-          } else if (fn && fn.type === 'identifier' && fn.text.startsWith('New')) {
-            const typeName = fn.text.slice(3);
-            if (typeName && ctx.typeMap) setIfHigher(ctx.typeMap, varNode.text, typeName, 0.7);
-          }
-        }
-      }
+/** Handle short_var_declaration: x := Struct{}, x := &Struct{}, x := NewFoo(). */
+function handleShortVarDecl(
+  node: TreeSitterNode,
+  typeMap: Map<string, { type: string; confidence: number }>,
+): void {
+  const left = node.childForFieldName('left');
+  const right = node.childForFieldName('right');
+  if (!left || !right) return;
+
+  const lefts =
+    left.type === 'expression_list'
+      ? Array.from({ length: left.childCount }, (_, i) => left.child(i)).filter(
+          (c): c is TreeSitterNode => c?.type === 'identifier',
+        )
+      : left.type === 'identifier'
+        ? [left]
+        : [];
+  const rights =
+    right.type === 'expression_list'
+      ? Array.from({ length: right.childCount }, (_, i) => right.child(i)).filter(
+          (c): c is TreeSitterNode => !!c?.type,
+        )
+      : [right];
+
+  for (let idx = 0; idx < lefts.length; idx++) {
+    const varNode = lefts[idx];
+    const rhs = rights[idx];
+    if (!varNode || !rhs) continue;
+    inferShortVarType(varNode, rhs, typeMap);
+  }
+}
+
+function extractGoTypeMapDepth(node: TreeSitterNode, ctx: ExtractorOutput, depth: number): void {
+  if (depth >= MAX_WALK_DEPTH) return;
+
+  if (ctx.typeMap) {
+    if (node.type === 'var_spec' || node.type === 'parameter_declaration') {
+      handleTypedIdentifiers(node, ctx.typeMap);
+    } else if (node.type === 'short_var_declaration') {
+      handleShortVarDecl(node, ctx.typeMap);
     }
   }
 

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/hcl.ts

@@ -6,7 +6,7 @@ import type {
   TreeSitterNode,
   TreeSitterTree,
 } from '../types.js';
-import { nodeEndLine } from './helpers.js';
+import { nodeEndLine, stripQuotes } from './helpers.js';
 
 /**
  * Extract symbols from HCL (Terraform) files.
@@ -80,18 +80,18 @@ function resolveHclBlockName(blockType: string, strings: TreeSitterNode[]): stri
   const s0 = strings[0];
   const s1 = strings[1];
   if (blockType === 'resource' && s0 && s1) {
-    return `${s0.text.replace(/"/g, '')}.${s1.text.replace(/"/g, '')}`;
+    return `${stripQuotes(s0.text)}.${stripQuotes(s1.text)}`;
   }
   if (blockType === 'data' && s0 && s1) {
-    return `data.${s0.text.replace(/"/g, '')}.${s1.text.replace(/"/g, '')}`;
+    return `data.${stripQuotes(s0.text)}.${stripQuotes(s1.text)}`;
   }
   if ((blockType === 'variable' || blockType === 'output' || blockType === 'module') && s0) {
-    return `${blockType}.${s0.text.replace(/"/g, '')}`;
+    return `${blockType}.${stripQuotes(s0.text)}`;
   }
   if (blockType === 'locals') return 'locals';
   if (blockType === 'terraform' || blockType === 'provider') {
     let name = blockType;
-    if (s0) name += `.${s0.text.replace(/"/g, '')}`;
+    if (s0) name += `.${stripQuotes(s0.text)}`;
     return name;
   }
   return '';
@@ -126,7 +126,7 @@ function extractHclModuleSource(
       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, '');
+        const src = stripQuotes(val.text);
         if (src.startsWith('./') || src.startsWith('../')) {
           ctx.imports.push({ source: src, names: [], line: attr.startPosition.row + 1 });
         }