@optave/codegraph 3.5.0 → 3.7.0

package/src/extractors/kotlin.ts

@@ -0,0 +1,293 @@
+import type {
+  Call,
+  ExtractorOutput,
+  SubDeclaration,
+  TreeSitterNode,
+  TreeSitterTree,
+} from '../types.js';
+import { extractModifierVisibility, findChild, nodeEndLine } from './helpers.js';
+
+/**
+ * Extract symbols from Kotlin files.
+ */
+export function extractKotlinSymbols(tree: TreeSitterTree, _filePath: string): ExtractorOutput {
+  const ctx: ExtractorOutput = {
+    definitions: [],
+    calls: [],
+    imports: [],
+    classes: [],
+    exports: [],
+    typeMap: new Map(),
+  };
+
+  walkKotlinNode(tree.rootNode, ctx);
+  return ctx;
+}
+
+function walkKotlinNode(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  switch (node.type) {
+    case 'class_declaration':
+      handleKotlinClassDecl(node, ctx);
+      break;
+    case 'object_declaration':
+      handleKotlinObjectDecl(node, ctx);
+      break;
+    case 'function_declaration':
+      handleKotlinFunctionDecl(node, ctx);
+      break;
+    case 'import_header':
+      handleKotlinImport(node, ctx);
+      break;
+    case 'call_expression':
+      handleKotlinCallExpression(node, ctx);
+      break;
+    case 'navigation_expression':
+      handleKotlinNavExpression(node, ctx);
+      break;
+  }
+
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child) walkKotlinNode(child, ctx);
+  }
+}
+
+// ── Walk-path per-node-type handlers ────────────────────────────────────────
+
+function hasKeywordChild(node: TreeSitterNode, keyword: string): boolean {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child && child.text === keyword) return true;
+  }
+  return false;
+}
+
+function hasModifier(node: TreeSitterNode, keyword: string): boolean {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    if (child.type === 'modifiers' && child.text.includes(keyword)) return true;
+  }
+  return false;
+}
+
+function handleKotlinClassDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const isInterface = hasKeywordChild(node, 'interface');
+  const isEnum = hasModifier(node, 'enum');
+
+  const nameNode = findChild(node, 'type_identifier');
+  if (!nameNode) return;
+  const name = nameNode.text;
+
+  const kind = isInterface ? 'interface' : isEnum ? 'enum' : 'class';
+
+  const children: SubDeclaration[] = [];
+  if (isEnum) {
+    // Enum entries are inside class_body
+    const body = findChild(node, 'class_body');
+    if (body) {
+      for (let i = 0; i < body.childCount; i++) {
+        const child = body.child(i);
+        if (child && child.type === 'enum_entry') {
+          const entryName = findChild(child, 'simple_identifier');
+          if (entryName) {
+            children.push({
+              name: entryName.text,
+              kind: 'constant',
+              line: child.startPosition.row + 1,
+            });
+          }
+        }
+      }
+    }
+  } else {
+    // Extract properties from class_body
+    const body = findChild(node, 'class_body');
+    if (body) {
+      for (let i = 0; i < body.childCount; i++) {
+        const child = body.child(i);
+        if (child && child.type === 'property_declaration') {
+          const propName = findChild(child, 'variable_declaration');
+          if (propName) {
+            const id = findChild(propName, 'simple_identifier');
+            if (id) {
+              children.push({
+                name: id.text,
+                kind: 'property',
+                line: child.startPosition.row + 1,
+                visibility: extractModifierVisibility(child),
+              });
+            }
+          }
+        }
+      }
+    }
+  }
+
+  ctx.definitions.push({
+    name,
+    kind,
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+    children: children.length > 0 ? children : undefined,
+  });
+
+  // Methods inside class_body
+  const body = findChild(node, 'class_body');
+  if (body) {
+    for (let i = 0; i < body.childCount; i++) {
+      const child = body.child(i);
+      if (child && child.type === 'function_declaration') {
+        const methName = findChild(child, 'simple_identifier');
+        if (methName) {
+          ctx.definitions.push({
+            name: `${name}.${methName.text}`,
+            kind: 'method',
+            line: child.startPosition.row + 1,
+            endLine: child.endPosition.row + 1,
+            visibility: extractModifierVisibility(child),
+          });
+        }
+      }
+    }
+  }
+
+  // Inheritance: delegation_specifier nodes are DIRECT children
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child || child.type !== 'delegation_specifier') continue;
+
+    // constructor_invocation > user_type > type_identifier (extends)
+    const ctorInvocation = findChild(child, 'constructor_invocation');
+    if (ctorInvocation) {
+      const userType = findChild(ctorInvocation, 'user_type');
+      if (userType) {
+        const typeId = findChild(userType, 'type_identifier');
+        if (typeId) {
+          ctx.classes.push({
+            name,
+            extends: typeId.text,
+            line: node.startPosition.row + 1,
+          });
+        }
+      }
+      continue;
+    }
+
+    // user_type > type_identifier (implements)
+    const userType = findChild(child, 'user_type');
+    if (userType) {
+      const typeId = findChild(userType, 'type_identifier');
+      if (typeId) {
+        ctx.classes.push({
+          name,
+          implements: typeId.text,
+          line: node.startPosition.row + 1,
+        });
+      }
+    }
+  }
+}
+
+function handleKotlinObjectDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const nameNode = findChild(node, 'type_identifier');
+  if (!nameNode) return;
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'class',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+  });
+
+  // Methods inside object body
+  const body = findChild(node, 'class_body');
+  if (body) {
+    for (let i = 0; i < body.childCount; i++) {
+      const child = body.child(i);
+      if (child && child.type === 'function_declaration') {
+        const methName = findChild(child, 'simple_identifier');
+        if (methName) {
+          ctx.definitions.push({
+            name: `${nameNode.text}.${methName.text}`,
+            kind: 'method',
+            line: child.startPosition.row + 1,
+            endLine: child.endPosition.row + 1,
+            visibility: extractModifierVisibility(child),
+          });
+        }
+      }
+    }
+  }
+}
+
+function handleKotlinFunctionDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  // Skip methods already emitted by class/object handlers
+  if (
+    node.parent?.type === 'class_body' &&
+    (node.parent.parent?.type === 'class_declaration' ||
+      node.parent.parent?.type === 'object_declaration')
+  ) {
+    return;
+  }
+  const nameNode = findChild(node, 'simple_identifier');
+  if (!nameNode) return;
+  const params = extractKotlinParameters(node);
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'function',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+    children: params.length > 0 ? params : undefined,
+    visibility: extractModifierVisibility(node),
+  });
+}
+
+function handleKotlinImport(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const identNode = findChild(node, 'identifier');
+  if (!identNode) return;
+  const fullPath = identNode.text;
+  const lastName = fullPath.split('.').pop() ?? fullPath;
+  ctx.imports.push({
+    source: fullPath,
+    names: [lastName],
+    line: node.startPosition.row + 1,
+    kotlinImport: true,
+  });
+}
+
+function handleKotlinCallExpression(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const funcNode = node.child(0);
+  if (!funcNode) return;
+  if (funcNode.type === 'simple_identifier') {
+    ctx.calls.push({ name: funcNode.text, line: node.startPosition.row + 1 });
+  }
+}
+
+function handleKotlinNavExpression(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  // navigation_expression: expr . identifier — only emit if parent is call_expression
+  if (node.parent?.type !== 'call_expression') return;
+  const lastChild = node.child(node.childCount - 1);
+  const firstChild = node.child(0);
+  if (lastChild && lastChild.type === 'simple_identifier' && firstChild) {
+    const call: Call = { name: lastChild.text, line: node.startPosition.row + 1 };
+    call.receiver = firstChild.text;
+    ctx.calls.push(call);
+  }
+}
+
+// ── Child extraction helpers ────────────────────────────────────────────────
+
+function extractKotlinParameters(funcNode: TreeSitterNode): SubDeclaration[] {
+  const params: SubDeclaration[] = [];
+  const paramList = findChild(funcNode, 'function_value_parameters');
+  if (!paramList) return params;
+  for (let i = 0; i < paramList.childCount; i++) {
+    const param = paramList.child(i);
+    if (!param || param.type !== 'parameter') continue;
+    const nameNode = findChild(param, 'simple_identifier');
+    if (nameNode) {
+      params.push({ name: nameNode.text, kind: 'parameter', line: param.startPosition.row + 1 });
+    }
+  }
+  return params;
+}

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);
+}