@optave/codegraph 3.5.0 → 3.6.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/php.ts

@@ -5,7 +5,14 @@ import type {
   TreeSitterNode,
   TreeSitterTree,
 } from '../types.js';
-import { extractModifierVisibility, findChild, MAX_WALK_DEPTH, nodeEndLine } from './helpers.js';
+import {
+  extractBodyMembers,
+  extractModifierVisibility,
+  findChild,
+  lastPathSegment,
+  MAX_WALK_DEPTH,
+  nodeEndLine,
+} from './helpers.js';
 
 function extractPhpParameters(fnNode: TreeSitterNode): SubDeclaration[] {
   const params: SubDeclaration[] = [];
@@ -25,6 +32,39 @@ function extractPhpParameters(fnNode: TreeSitterNode): SubDeclaration[] {
   return params;
 }
 
+/** Extract property declarations from a PHP class member. */
+function extractPhpProperties(member: TreeSitterNode, children: SubDeclaration[]): void {
+  for (let j = 0; j < member.childCount; j++) {
+    const el = member.child(j);
+    if (!el || el.type !== 'property_element') continue;
+    const varNode = findChild(el, 'variable_name');
+    if (varNode) {
+      children.push({
+        name: varNode.text,
+        kind: 'property',
+        line: member.startPosition.row + 1,
+        visibility: extractModifierVisibility(member),
+      });
+    }
+  }
+}
+
+/** Extract constant declarations from a PHP class member. */
+function extractPhpConstants(member: TreeSitterNode, children: SubDeclaration[]): void {
+  for (let j = 0; j < member.childCount; j++) {
+    const el = member.child(j);
+    if (!el || el.type !== 'const_element') continue;
+    const nameNode = el.childForFieldName('name') || findChild(el, 'name');
+    if (nameNode) {
+      children.push({
+        name: nameNode.text,
+        kind: 'constant',
+        line: member.startPosition.row + 1,
+      });
+    }
+  }
+}
+
 function extractPhpClassChildren(classNode: TreeSitterNode): SubDeclaration[] {
   const children: SubDeclaration[] = [];
   const body = classNode.childForFieldName('body') || findChild(classNode, 'declaration_list');
@@ -33,50 +73,16 @@ function extractPhpClassChildren(classNode: TreeSitterNode): SubDeclaration[] {
     const member = body.child(i);
     if (!member) continue;
     if (member.type === 'property_declaration') {
-      for (let j = 0; j < member.childCount; j++) {
-        const el = member.child(j);
-        if (!el || el.type !== 'property_element') continue;
-        const varNode = findChild(el, 'variable_name');
-        if (varNode) {
-          children.push({
-            name: varNode.text,
-            kind: 'property',
-            line: member.startPosition.row + 1,
-            visibility: extractModifierVisibility(member),
-          });
-        }
-      }
+      extractPhpProperties(member, children);
     } else if (member.type === 'const_declaration') {
-      for (let j = 0; j < member.childCount; j++) {
-        const el = member.child(j);
-        if (!el || el.type !== 'const_element') continue;
-        const nameNode = el.childForFieldName('name') || findChild(el, 'name');
-        if (nameNode) {
-          children.push({
-            name: nameNode.text,
-            kind: 'constant',
-            line: member.startPosition.row + 1,
-          });
-        }
-      }
+      extractPhpConstants(member, children);
     }
   }
   return children;
 }
 
 function extractPhpEnumCases(enumNode: TreeSitterNode): SubDeclaration[] {
-  const children: SubDeclaration[] = [];
-  const body = enumNode.childForFieldName('body') || findChild(enumNode, 'enum_declaration_list');
-  if (!body) return children;
-  for (let i = 0; i < body.childCount; i++) {
-    const member = body.child(i);
-    if (!member || member.type !== 'enum_case') continue;
-    const nameNode = member.childForFieldName('name');
-    if (nameNode) {
-      children.push({ name: nameNode.text, kind: 'constant', line: member.startPosition.row + 1 });
-    }
-  }
-  return children;
+  return extractBodyMembers(enumNode, ['body', 'enum_declaration_list'], 'enum_case', 'constant');
 }
 
 /**
@@ -272,7 +278,7 @@ function handlePhpNamespaceUse(node: TreeSitterNode, ctx: ExtractorOutput): void
       const nameNode = findChild(child, 'qualified_name') || findChild(child, 'name');
       if (nameNode) {
         const fullPath = nameNode.text;
-        const lastName = fullPath.split('\\').pop() ?? fullPath;
+        const lastName = lastPathSegment(fullPath, '\\');
         const alias = child.childForFieldName('alias');
         ctx.imports.push({
           source: fullPath,
@@ -284,7 +290,7 @@ function handlePhpNamespaceUse(node: TreeSitterNode, ctx: ExtractorOutput): void
     }
     if (child && (child.type === 'qualified_name' || child.type === 'name')) {
       const fullPath = child.text;
-      const lastName = fullPath.split('\\').pop() ?? fullPath;
+      const lastName = lastPathSegment(fullPath, '\\');
       ctx.imports.push({
         source: fullPath,
         names: [lastName],

package/src/extractors/python.ts

@@ -4,9 +4,15 @@ import type {
   SubDeclaration,
   TreeSitterNode,
   TreeSitterTree,
-  TypeMapEntry,
 } from '../types.js';
-import { findChild, MAX_WALK_DEPTH, nodeEndLine, pythonVisibility } from './helpers.js';
+import {
+  findChild,
+  findParentNode,
+  MAX_WALK_DEPTH,
+  nodeEndLine,
+  pythonVisibility,
+  setTypeMapEntry,
+} from './helpers.js';
 
 /** Built-in globals that start with uppercase but are not user-defined types. */
 const BUILTIN_GLOBALS_PY: Set<string> = new Set([
@@ -268,6 +274,37 @@ function extractPythonParameters(fnNode: TreeSitterNode): SubDeclaration[] {
   return params;
 }
 
+/** Extract class-level assignment properties from expression statements. */
+function extractClassAssignment(
+  child: TreeSitterNode,
+  seen: Set<string>,
+  props: SubDeclaration[],
+): void {
+  const assignment = findChild(child, 'assignment');
+  if (!assignment) return;
+  const left = assignment.childForFieldName('left');
+  if (!left || left.type !== 'identifier' || seen.has(left.text)) return;
+  seen.add(left.text);
+  props.push({
+    name: left.text,
+    kind: 'property',
+    line: child.startPosition.row + 1,
+    visibility: pythonVisibility(left.text),
+  });
+}
+
+/** If node is an __init__ method, walk its body for self.x assignments. */
+function extractInitProperties(
+  node: TreeSitterNode,
+  seen: Set<string>,
+  props: SubDeclaration[],
+): void {
+  const fnName = node.childForFieldName('name');
+  if (!fnName || fnName.text !== '__init__') return;
+  const initBody = node.childForFieldName('body') || findChild(node, 'block');
+  if (initBody) walkInitBody(initBody, seen, props);
+}
+
 function extractPythonClassProperties(classNode: TreeSitterNode): SubDeclaration[] {
   const props: SubDeclaration[] = [];
   const seen = new Set<string>();
@@ -279,42 +316,14 @@ function extractPythonClassProperties(classNode: TreeSitterNode): SubDeclaration
     if (!child) continue;
 
     if (child.type === 'expression_statement') {
-      const assignment = findChild(child, 'assignment');
-      if (assignment) {
-        const left = assignment.childForFieldName('left');
-        if (left && left.type === 'identifier' && !seen.has(left.text)) {
-          seen.add(left.text);
-          props.push({
-            name: left.text,
-            kind: 'property',
-            line: child.startPosition.row + 1,
-            visibility: pythonVisibility(left.text),
-          });
-        }
-      }
-    }
-
-    if (child.type === 'function_definition') {
-      const fnName = child.childForFieldName('name');
-      if (fnName && fnName.text === '__init__') {
-        const initBody = child.childForFieldName('body') || findChild(child, 'block');
-        if (initBody) {
-          walkInitBody(initBody, seen, props);
-        }
-      }
-    }
-
-    if (child.type === 'decorated_definition') {
+      extractClassAssignment(child, seen, props);
+    } else if (child.type === 'function_definition') {
+      extractInitProperties(child, seen, props);
+    } else if (child.type === 'decorated_definition') {
       for (let j = 0; j < child.childCount; j++) {
         const inner = child.child(j);
         if (inner && inner.type === 'function_definition') {
-          const fnName = inner.childForFieldName('name');
-          if (fnName && fnName.text === '__init__') {
-            const initBody = inner.childForFieldName('body') || findChild(inner, 'block');
-            if (initBody) {
-              walkInitBody(initBody, seen, props);
-            }
-          }
+          extractInitProperties(inner, seen, props);
         }
       }
     }
@@ -348,15 +357,37 @@ function extractPythonTypeMap(node: TreeSitterNode, ctx: ExtractorOutput): void
   extractPythonTypeMapDepth(node, ctx, 0);
 }
 
-function setIfHigherPy(
-  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 });
+/** Handle typed_parameter or typed_default_parameter for type map. */
+function handlePyTypedParam(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const isDefault = node.type === 'typed_default_parameter';
+  const nameNode = isDefault ? node.childForFieldName('name') : node.child(0);
+  const typeNode = node.childForFieldName('type');
+  if (!nameNode || nameNode.type !== 'identifier' || !typeNode) return;
+  if (nameNode.text === 'self' || nameNode.text === 'cls') return;
+  const typeName = extractPythonTypeName(typeNode);
+  if (typeName && ctx.typeMap) setTypeMapEntry(ctx.typeMap, nameNode.text, typeName, 0.9);
+}
+
+/** Handle assignment for constructor/factory type inference. */
+function handlePyAssignmentType(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const left = node.childForFieldName('left');
+  const right = node.childForFieldName('right');
+  if (!left || left.type !== 'identifier' || !right || right.type !== 'call') return;
+
+  const fn = right.childForFieldName('function');
+  if (!fn) return;
+  if (fn.type === 'identifier') {
+    const name = fn.text;
+    if (name[0] && name[0] !== name[0].toLowerCase()) {
+      if (ctx.typeMap) setTypeMapEntry(ctx.typeMap, left.text, name, 1.0);
+    }
+  } else if (fn.type === 'attribute') {
+    const obj = fn.childForFieldName('object');
+    if (!obj || obj.type !== 'identifier') return;
+    const objName = obj.text;
+    if (objName[0] && objName[0] !== objName[0].toLowerCase() && !BUILTIN_GLOBALS_PY.has(objName)) {
+      if (ctx.typeMap) setTypeMapEntry(ctx.typeMap, left.text, objName, 0.7);
+    }
   }
 }
 
@@ -367,57 +398,10 @@ function extractPythonTypeMapDepth(
 ): void {
   if (depth >= MAX_WALK_DEPTH) return;
 
-  // typed_parameter: identifier : type (confidence 0.9)
-  if (node.type === 'typed_parameter') {
-    const nameNode = node.child(0);
-    const typeNode = node.childForFieldName('type');
-    if (nameNode && nameNode.type === 'identifier' && typeNode) {
-      const typeName = extractPythonTypeName(typeNode);
-      if (typeName && nameNode.text !== 'self' && nameNode.text !== 'cls') {
-        if (ctx.typeMap) setIfHigherPy(ctx.typeMap, nameNode.text, typeName, 0.9);
-      }
-    }
-  }
-
-  // typed_default_parameter: name : type = default (confidence 0.9)
-  if (node.type === 'typed_default_parameter') {
-    const nameNode = node.childForFieldName('name');
-    const typeNode = node.childForFieldName('type');
-    if (nameNode && nameNode.type === 'identifier' && typeNode) {
-      const typeName = extractPythonTypeName(typeNode);
-      if (typeName && nameNode.text !== 'self' && nameNode.text !== 'cls') {
-        if (ctx.typeMap) setIfHigherPy(ctx.typeMap, nameNode.text, typeName, 0.9);
-      }
-    }
-  }
-
-  // assignment: x = SomeClass(...) → constructor (confidence 1.0)
-  //             x = SomeClass.create(...) → factory (confidence 0.7)
-  if (node.type === 'assignment') {
-    const left = node.childForFieldName('left');
-    const right = node.childForFieldName('right');
-    if (left && left.type === 'identifier' && right && right.type === 'call') {
-      const fn = right.childForFieldName('function');
-      if (fn && fn.type === 'identifier') {
-        const name = fn.text;
-        if (name[0] && name[0] !== name[0].toLowerCase()) {
-          if (ctx.typeMap) setIfHigherPy(ctx.typeMap, left.text, name, 1.0);
-        }
-      }
-      if (fn && fn.type === 'attribute') {
-        const obj = fn.childForFieldName('object');
-        if (obj && obj.type === 'identifier') {
-          const objName = obj.text;
-          if (
-            objName[0] &&
-            objName[0] !== objName[0].toLowerCase() &&
-            !BUILTIN_GLOBALS_PY.has(objName)
-          ) {
-            if (ctx.typeMap) setIfHigherPy(ctx.typeMap, left.text, objName, 0.7);
-          }
-        }
-      }
-    }
+  if (node.type === 'typed_parameter' || node.type === 'typed_default_parameter') {
+    handlePyTypedParam(node, ctx);
+  } else if (node.type === 'assignment') {
+    handlePyAssignmentType(node, ctx);
   }
 
   for (let i = 0; i < node.childCount; i++) {
@@ -441,14 +425,7 @@ function extractPythonTypeName(typeNode: TreeSitterNode): string | null {
   return null;
 }
 
+const PY_CLASS_TYPES = ['class_definition'] as const;
 function findPythonParentClass(node: TreeSitterNode): string | null {
-  let current = node.parent;
-  while (current) {
-    if (current.type === 'class_definition') {
-      const nameNode = current.childForFieldName('name');
-      return nameNode ? nameNode.text : null;
-    }
-    current = current.parent;
-  }
-  return null;
+  return findParentNode(node, PY_CLASS_TYPES);
 }

package/src/extractors/ruby.ts

@@ -5,7 +5,7 @@ import type {
   TreeSitterNode,
   TreeSitterTree,
 } from '../types.js';
-import { findChild, nodeEndLine } from './helpers.js';
+import { findChild, findParentNode, lastPathSegment, nodeEndLine, stripQuotes } from './helpers.js';
 
 /**
  * Extract symbols from Ruby files.
@@ -176,10 +176,10 @@ function handleRubyRequire(node: TreeSitterNode, ctx: ExtractorOutput): void {
   for (let i = 0; i < args.childCount; i++) {
     const arg = args.child(i);
     if (arg && (arg.type === 'string' || arg.type === 'string_content')) {
-      const strContent = arg.text.replace(/^['"]|['"]$/g, '');
+      const strContent = stripQuotes(arg.text);
       ctx.imports.push({
         source: strContent,
-        names: [strContent.split('/').pop() ?? strContent],
+        names: [lastPathSegment(strContent)],
         line: node.startPosition.row + 1,
         rubyRequire: true,
       });
@@ -190,7 +190,7 @@ function handleRubyRequire(node: TreeSitterNode, ctx: ExtractorOutput): void {
       if (content) {
         ctx.imports.push({
           source: content.text,
-          names: [content.text.split('/').pop() ?? content.text],
+          names: [lastPathSegment(content.text)],
           line: node.startPosition.row + 1,
           rubyRequire: true,
         });
@@ -221,16 +221,9 @@ function handleRubyModuleInclusion(
   }
 }
 
+const RUBY_PARENT_TYPES = ['class', 'module'] as const;
 function findRubyParentClass(node: TreeSitterNode): string | null {
-  let current = node.parent;
-  while (current) {
-    if (current.type === 'class' || current.type === 'module') {
-      const nameNode = current.childForFieldName('name');
-      return nameNode ? nameNode.text : null;
-    }
-    current = current.parent;
-  }
-  return null;
+  return findParentNode(node, RUBY_PARENT_TYPES);
 }
 
 // ── Child extraction helpers ────────────────────────────────────────────────