@optave/codegraph 3.5.0 → 3.7.0

package/src/extractors/helpers.ts

@@ -1,4 +1,4 @@
-import type { TreeSitterNode } from '../types.js';
+import type { SubDeclaration, TreeSitterNode, TypeMapEntry } from '../types.js';
 
 /**
  * Maximum recursion depth for tree-sitter AST walkers.
@@ -18,6 +18,22 @@ export function findChild(node: TreeSitterNode, type: string): TreeSitterNode |
   return null;
 }
 
+/**
+ * Merge a type-map entry, keeping the higher-confidence one.
+ * Shared across all language extractors that build type maps for call resolution.
+ */
+export function setTypeMapEntry(
+  typeMap: Map<string, TypeMapEntry>,
+  name: string,
+  type: string,
+  confidence: number,
+): void {
+  const existing = typeMap.get(name);
+  if (!existing || confidence > existing.confidence) {
+    typeMap.set(name, { type, confidence });
+  }
+}
+
 /**
  * Extract visibility from a node by scanning its children for modifier keywords.
  * Works for Java, C#, PHP, and similar languages where modifiers are child nodes.
@@ -70,6 +86,82 @@ export function rustVisibility(node: TreeSitterNode): 'public' | 'private' {
   return 'private';
 }
 
+// ── Parser abstraction helpers ─────────────────────────────────────────────
+
+/**
+ * Walk up the parent chain to find an enclosing node whose type is in `typeNames`.
+ * Returns the text of `nameField` (default `'name'`) on the matching ancestor, or null.
+ *
+ * Replaces per-language `findParentClass` / `findParentType` / `findCurrentImpl` helpers.
+ */
+export function findParentNode(
+  node: TreeSitterNode,
+  typeNames: readonly string[],
+  nameField: string = 'name',
+): string | null {
+  let current = node.parent;
+  while (current) {
+    if (typeNames.includes(current.type)) {
+      const nameNode = current.childForFieldName(nameField);
+      return nameNode ? nameNode.text : null;
+    }
+    current = current.parent;
+  }
+  return null;
+}
+
+/**
+ * Extract child declarations from a container node's body.
+ * Finds the body via `bodyFields` (tries childForFieldName then findChild for each),
+ * iterates its children, filters by `memberType`, extracts `nameField`, and returns SubDeclarations.
+ *
+ * Replaces per-language extractStructFields / extractEnumVariants / extractEnumConstants helpers
+ * for the common case where each member has a direct name field.
+ */
+export function extractBodyMembers(
+  containerNode: TreeSitterNode,
+  bodyFields: readonly string[],
+  memberType: string,
+  kind: SubDeclaration['kind'],
+  nameField: string = 'name',
+  visibility?: (member: TreeSitterNode) => SubDeclaration['visibility'],
+): SubDeclaration[] {
+  const members: SubDeclaration[] = [];
+  let body: TreeSitterNode | null = null;
+  for (const field of bodyFields) {
+    body = containerNode.childForFieldName(field) || findChild(containerNode, field);
+    if (body) break;
+  }
+  if (!body) return members;
+  for (let i = 0; i < body.childCount; i++) {
+    const member = body.child(i);
+    if (!member || member.type !== memberType) continue;
+    const nn = member.childForFieldName(nameField);
+    if (nn) {
+      const entry: SubDeclaration = { name: nn.text, kind, line: member.startPosition.row + 1 };
+      if (visibility) entry.visibility = visibility(member);
+      members.push(entry);
+    }
+  }
+  return members;
+}
+
+/**
+ * Strip leading/trailing quotes (single, double, or backtick) from a string.
+ * Strips only the leading/trailing delimiter; interior quotes are untouched.
+ */
+export function stripQuotes(text: string): string {
+  return text.replace(/^['"`]|['"`]$/g, '');
+}
+
+/**
+ * Extract the last segment of a delimited path.
+ * e.g. `lastPathSegment('java.util.List', '.')` → `'List'`
+ */
+export function lastPathSegment(path: string, separator: string = '/'): string {
+  return path.split(separator).pop() ?? path;
+}
+
 export function extractModifierVisibility(
   node: TreeSitterNode,
   modifierTypes: Set<string> = DEFAULT_MODIFIER_TYPES,

package/src/extractors/index.ts

@@ -1,9 +1,21 @@
+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/java.ts

@@ -6,7 +6,14 @@ import type {
   TreeSitterTree,
   TypeMapEntry,
 } from '../types.js';
-import { extractModifierVisibility, findChild, nodeEndLine } from './helpers.js';
+import {
+  extractBodyMembers,
+  extractModifierVisibility,
+  findChild,
+  findParentNode,
+  lastPathSegment,
+  nodeEndLine,
+} from './helpers.js';
 
 /**
  * Extract symbols from Java files.
@@ -104,6 +111,25 @@ function handleJavaClassDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
   }
 }
 
+const JAVA_TYPE_NODE_TYPES = new Set(['type_identifier', 'identifier', 'generic_type']);
+
+/** Resolve interface name from a type node (handles generic_type unwrapping). */
+function resolveJavaIfaceName(node: TreeSitterNode): string | undefined {
+  return node.type === 'generic_type' ? node.child(0)?.text : node.text;
+}
+
+/** Push a single interface type node as an implements entry. */
+function pushJavaIface(
+  node: TreeSitterNode,
+  className: string,
+  line: number,
+  ctx: ExtractorOutput,
+): void {
+  if (!JAVA_TYPE_NODE_TYPES.has(node.type)) return;
+  const ifaceName = resolveJavaIfaceName(node);
+  if (ifaceName) ctx.classes.push({ name: className, implements: ifaceName, line });
+}
+
 function extractJavaInterfaces(
   interfaces: TreeSitterNode,
   className: string,
@@ -112,28 +138,15 @@ function extractJavaInterfaces(
 ): void {
   for (let i = 0; i < interfaces.childCount; i++) {
     const child = interfaces.child(i);
-    if (
-      child &&
-      (child.type === 'type_identifier' ||
-        child.type === 'identifier' ||
-        child.type === 'type_list' ||
-        child.type === 'generic_type')
-    ) {
-      if (child.type === 'type_list') {
-        for (let j = 0; j < child.childCount; j++) {
-          const t = child.child(j);
-          if (
-            t &&
-            (t.type === 'type_identifier' || t.type === 'identifier' || t.type === 'generic_type')
-          ) {
-            const ifaceName = t.type === 'generic_type' ? t.child(0)?.text : t.text;
-            if (ifaceName) ctx.classes.push({ name: className, implements: ifaceName, line });
-          }
-        }
-      } else {
-        const ifaceName = child.type === 'generic_type' ? child.child(0)?.text : child.text;
-        if (ifaceName) ctx.classes.push({ name: className, implements: ifaceName, line });
+    if (!child) continue;
+
+    if (child.type === 'type_list') {
+      for (let j = 0; j < child.childCount; j++) {
+        const t = child.child(j);
+        if (t) pushJavaIface(t, className, line, ctx);
       }
+    } else {
+      pushJavaIface(child, className, line, ctx);
     }
   }
 }
@@ -218,7 +231,7 @@ function handleJavaImportDecl(node: TreeSitterNode, ctx: ExtractorOutput): void
     const child = node.child(i);
     if (child && (child.type === 'scoped_identifier' || child.type === 'identifier')) {
       const fullPath = child.text;
-      const lastName = fullPath.split('.').pop() ?? fullPath;
+      const lastName = lastPathSegment(fullPath, '.');
       ctx.imports.push({
         source: fullPath,
         names: [lastName],
@@ -263,20 +276,13 @@ function handleJavaObjectCreation(node: TreeSitterNode, ctx: ExtractorOutput): v
   if (typeName) ctx.calls.push({ name: typeName, line: node.startPosition.row + 1 });
 }
 
+const JAVA_PARENT_TYPES = [
+  'class_declaration',
+  'enum_declaration',
+  'interface_declaration',
+] as const;
 function findJavaParentClass(node: TreeSitterNode): string | null {
-  let current = node.parent;
-  while (current) {
-    if (
-      current.type === 'class_declaration' ||
-      current.type === 'enum_declaration' ||
-      current.type === 'interface_declaration'
-    ) {
-      const nameNode = current.childForFieldName('name');
-      return nameNode ? nameNode.text : null;
-    }
-    current = current.parent;
-  }
-  return null;
+  return findParentNode(node, JAVA_PARENT_TYPES);
 }
 
 // ── Child extraction helpers ────────────────────────────────────────────────
@@ -333,16 +339,5 @@ function extractClassFields(classNode: TreeSitterNode): SubDeclaration[] {
 }
 
 function extractEnumConstants(enumNode: TreeSitterNode): SubDeclaration[] {
-  const constants: SubDeclaration[] = [];
-  const body = enumNode.childForFieldName('body') || findChild(enumNode, 'enum_body');
-  if (!body) return constants;
-  for (let i = 0; i < body.childCount; i++) {
-    const member = body.child(i);
-    if (!member || member.type !== 'enum_constant') 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_body'], 'enum_constant', 'constant');
 }