gitnexus 1.5.3 → 1.6.1

package/dist/core/ingestion/languages/c-cpp.js

@@ -8,14 +8,27 @@
  * for its left-to-right multiple inheritance resolution order.
  */
 import { SupportedLanguages } from '../../../_shared/index.js';
+import { createClassExtractor } from '../class-extractors/generic.js';
 import { defineLanguage } from '../language-provider.js';
 import { typeConfig as cCppConfig } from '../type-extractors/c-cpp.js';
 import { cCppExportChecker } from '../export-detection.js';
 import { resolveCImport, resolveCppImport } from '../import-resolvers/standard.js';
 import { C_QUERIES, CPP_QUERIES } from '../tree-sitter-queries.js';
-import { isCppInsideClassOrStruct } from '../utils/ast-helpers.js';
+/**
+ * Node types for standard function declarations that need C/C++ declarator handling.
+ * Used by cCppExtractFunctionName to determine how to extract the function name.
+ */
+const FUNCTION_DECLARATION_TYPES = new Set([
+    'function_declaration',
+    'function_definition',
+    'async_function_declaration',
+    'generator_function_declaration',
+    'function_item',
+]);
 import { createFieldExtractor } from '../field-extractors/generic.js';
 import { cConfig as cFieldConfig, cppConfig as cppFieldConfig, } from '../field-extractors/configs/c-cpp.js';
+import { createMethodExtractor } from '../method-extractors/generic.js';
+import { cMethodConfig, cppMethodConfig } from '../method-extractors/configs/c-cpp.js';
 const C_BUILT_INS = new Set([
     'printf',
     'fprintf',
@@ -122,6 +135,150 @@ const C_BUILT_INS = new Set([
     'get',
     'put',
 ]);
+const cClassExtractor = createClassExtractor({
+    language: SupportedLanguages.C,
+    typeDeclarationNodes: ['struct_specifier', 'enum_specifier'],
+});
+const cppClassExtractor = createClassExtractor({
+    language: SupportedLanguages.CPlusPlus,
+    typeDeclarationNodes: ['class_specifier', 'struct_specifier', 'enum_specifier'],
+    ancestorScopeNodeTypes: ['namespace_definition', 'class_specifier', 'struct_specifier'],
+});
+/**
+ * C/C++ function name extraction — unwraps pointer_declarator / reference_declarator /
+ * function_declarator / qualified_identifier chains to find the actual function name.
+ * Handles field_identifier (method inside class body) and parenthesized_declarator.
+ */
+const cCppExtractFunctionName = (node) => {
+    if (!FUNCTION_DECLARATION_TYPES.has(node.type))
+        return null;
+    let funcName = null;
+    let label = 'Function';
+    // C/C++: function_definition -> [pointer_declarator ->] function_declarator -> qualified_identifier/identifier
+    // Unwrap pointer_declarator / reference_declarator wrappers to reach function_declarator
+    let declarator = node.childForFieldName?.('declarator');
+    if (!declarator) {
+        for (let i = 0; i < node.childCount; i++) {
+            const c = node.child(i);
+            if (c?.type === 'function_declarator') {
+                declarator = c;
+                break;
+            }
+        }
+    }
+    while (declarator &&
+        (declarator.type === 'pointer_declarator' || declarator.type === 'reference_declarator')) {
+        let nextDeclarator = declarator.childForFieldName?.('declarator');
+        if (!nextDeclarator) {
+            for (let i = 0; i < declarator.childCount; i++) {
+                const c = declarator.child(i);
+                if (c?.type === 'function_declarator' ||
+                    c?.type === 'pointer_declarator' ||
+                    c?.type === 'reference_declarator') {
+                    nextDeclarator = c;
+                    break;
+                }
+            }
+        }
+        declarator = nextDeclarator;
+    }
+    if (declarator) {
+        let innerDeclarator = declarator.childForFieldName?.('declarator');
+        if (!innerDeclarator) {
+            for (let i = 0; i < declarator.childCount; i++) {
+                const c = declarator.child(i);
+                if (c?.type === 'qualified_identifier' ||
+                    c?.type === 'identifier' ||
+                    c?.type === 'field_identifier' ||
+                    c?.type === 'parenthesized_declarator') {
+                    innerDeclarator = c;
+                    break;
+                }
+            }
+        }
+        if (innerDeclarator?.type === 'qualified_identifier') {
+            let nameNode = innerDeclarator.childForFieldName?.('name');
+            if (!nameNode) {
+                for (let i = 0; i < innerDeclarator.childCount; i++) {
+                    const c = innerDeclarator.child(i);
+                    if (c?.type === 'identifier') {
+                        nameNode = c;
+                        break;
+                    }
+                }
+            }
+            if (nameNode?.text) {
+                funcName = nameNode.text;
+                label = 'Method';
+            }
+        }
+        else if (innerDeclarator?.type === 'identifier' ||
+            innerDeclarator?.type === 'field_identifier') {
+            // field_identifier is used for method names inside C++ class bodies
+            funcName = innerDeclarator.text;
+            if (innerDeclarator.type === 'field_identifier')
+                label = 'Method';
+        }
+        else if (innerDeclarator?.type === 'parenthesized_declarator') {
+            let nestedId = null;
+            for (let i = 0; i < innerDeclarator.childCount; i++) {
+                const c = innerDeclarator.child(i);
+                if (c?.type === 'qualified_identifier' || c?.type === 'identifier') {
+                    nestedId = c;
+                    break;
+                }
+            }
+            if (nestedId?.type === 'qualified_identifier') {
+                let nameNode = nestedId.childForFieldName?.('name');
+                if (!nameNode) {
+                    for (let i = 0; i < nestedId.childCount; i++) {
+                        const c = nestedId.child(i);
+                        if (c?.type === 'identifier') {
+                            nameNode = c;
+                            break;
+                        }
+                    }
+                }
+                if (nameNode?.text) {
+                    funcName = nameNode.text;
+                    label = 'Method';
+                }
+            }
+            else if (nestedId?.type === 'identifier') {
+                funcName = nestedId.text;
+            }
+        }
+    }
+    // Fallback for other node types in FUNCTION_DECLARATION_TYPES (e.g. function_item for Rust in C++ tree)
+    if (!funcName) {
+        let nameNode = node.childForFieldName?.('name');
+        if (!nameNode) {
+            for (let i = 0; i < node.childCount; i++) {
+                const c = node.child(i);
+                if (c?.type === 'identifier' ||
+                    c?.type === 'property_identifier' ||
+                    c?.type === 'simple_identifier') {
+                    nameNode = c;
+                    break;
+                }
+            }
+        }
+        funcName = nameNode?.text ?? null;
+    }
+    return { funcName, label };
+};
+/** Check if a C/C++ function_definition is inside a class or struct body.
+ *  Used by cppLabelOverride to skip duplicate function captures
+ *  that are already covered by definition.method queries. */
+function isCppInsideClassOrStruct(functionNode) {
+    let ancestor = functionNode?.parent ?? null;
+    while (ancestor) {
+        if (ancestor.type === 'class_specifier' || ancestor.type === 'struct_specifier')
+            return true;
+        ancestor = ancestor.parent;
+    }
+    return false;
+}
 /** Label override shared by C and C++: skip function_definition captures inside class/struct
  *  bodies (they're duplicates of definition.method captures). */
 const cppLabelOverride = (functionNode, defaultLabel) => {
@@ -138,6 +295,11 @@ export const cProvider = defineLanguage({
     importResolver: resolveCImport,
     importSemantics: 'wildcard',
     fieldExtractor: createFieldExtractor(cFieldConfig),
+    methodExtractor: createMethodExtractor({
+        ...cMethodConfig,
+        extractFunctionName: cCppExtractFunctionName,
+    }),
+    classExtractor: cClassExtractor,
     labelOverride: cppLabelOverride,
     builtInNames: C_BUILT_INS,
 });
@@ -151,6 +313,11 @@ export const cppProvider = defineLanguage({
     importSemantics: 'wildcard',
     mroStrategy: 'leftmost-base',
     fieldExtractor: createFieldExtractor(cppFieldConfig),
+    methodExtractor: createMethodExtractor({
+        ...cppMethodConfig,
+        extractFunctionName: cCppExtractFunctionName,
+    }),
+    classExtractor: cppClassExtractor,
     labelOverride: cppLabelOverride,
     builtInNames: C_BUILT_INS,
 });

package/dist/core/ingestion/languages/csharp.js

@@ -6,6 +6,7 @@
  * Interface names follow the I-prefix convention (e.g., IDisposable).
  */
 import { SupportedLanguages } from '../../../_shared/index.js';
+import { createClassExtractor } from '../class-extractors/generic.js';
 import { defineLanguage } from '../language-provider.js';
 import { typeConfig as csharpConfig } from '../type-extractors/csharp.js';
 import { csharpExportChecker } from '../export-detection.js';
@@ -122,5 +123,24 @@ export const csharpProvider = defineLanguage({
     mroStrategy: 'implements-split',
     fieldExtractor: createFieldExtractor(csharpFieldConfig),
     methodExtractor: createMethodExtractor(csharpMethodConfig),
+    classExtractor: createClassExtractor({
+        language: SupportedLanguages.CSharp,
+        typeDeclarationNodes: [
+            'class_declaration',
+            'interface_declaration',
+            'struct_declaration',
+            'enum_declaration',
+            'record_declaration',
+        ],
+        fileScopeNodeTypes: ['file_scoped_namespace_declaration'],
+        ancestorScopeNodeTypes: [
+            'namespace_declaration',
+            'class_declaration',
+            'interface_declaration',
+            'struct_declaration',
+            'enum_declaration',
+            'record_declaration',
+        ],
+    }),
     builtInNames: BUILT_INS,
 });

package/dist/core/ingestion/languages/dart.js

@@ -9,8 +9,9 @@
  *     as a sibling of function_signature/method_signature (not as a child).
  *     The hook resolves the enclosing function by inspecting the previous sibling.
  */
-import { FUNCTION_NODE_TYPES, extractFunctionName } from '../utils/ast-helpers.js';
+import { FUNCTION_NODE_TYPES } from '../utils/ast-helpers.js';
 import { SupportedLanguages } from '../../../_shared/index.js';
+import { createClassExtractor } from '../class-extractors/generic.js';
 import { defineLanguage } from '../language-provider.js';
 import { typeConfig as dartConfig } from '../type-extractors/dart.js';
 import { dartExportChecker } from '../export-detection.js';
@@ -18,14 +19,16 @@ import { resolveDartImport } from '../import-resolvers/dart.js';
 import { DART_QUERIES } from '../tree-sitter-queries.js';
 import { createFieldExtractor } from '../field-extractors/generic.js';
 import { dartConfig as dartFieldConfig } from '../field-extractors/configs/dart.js';
+import { createMethodExtractor } from '../method-extractors/generic.js';
+import { dartMethodConfig } from '../method-extractors/configs/dart.js';
 /**
  * Resolve the enclosing function from a `function_body` node by looking at its
  * previous sibling.  In Dart's tree-sitter grammar, function_signature and
  * function_body are siblings under program or class_body, unlike most languages
  * where the function declaration wraps both.
  *
- * Delegates name extraction to the shared `extractFunctionName` which already
- * handles Dart's function_signature and method_signature node types.
+ * Extracts the function name inline — Dart uses function_signature and
+ * method_signature (which wraps function_signature) as its FUNCTION_NODE_TYPES.
  */
 const dartEnclosingFunctionFinder = (node) => {
     if (node.type !== 'function_body')
@@ -33,7 +36,20 @@ const dartEnclosingFunctionFinder = (node) => {
     const prev = node.previousSibling;
     if (!prev || !FUNCTION_NODE_TYPES.has(prev.type))
         return null;
-    const { funcName, label } = extractFunctionName(prev);
+    // method_signature wraps function_signature — unwrap to reach the name
+    let target = prev;
+    let label = 'Function';
+    if (prev.type === 'method_signature') {
+        label = 'Method';
+        for (let i = 0; i < prev.childCount; i++) {
+            const c = prev.child(i);
+            if (c?.type === 'function_signature') {
+                target = c;
+                break;
+            }
+        }
+    }
+    const funcName = target.childForFieldName?.('name')?.text ?? null;
     return funcName ? { funcName, label } : null;
 };
 const BUILT_INS = new Set([
@@ -69,6 +85,12 @@ export const dartProvider = defineLanguage({
     importResolver: resolveDartImport,
     importSemantics: 'wildcard',
     fieldExtractor: createFieldExtractor(dartFieldConfig),
+    methodExtractor: createMethodExtractor(dartMethodConfig),
+    classExtractor: createClassExtractor({
+        language: SupportedLanguages.Dart,
+        typeDeclarationNodes: ['class_definition', 'extension_declaration', 'enum_declaration'],
+        ancestorScopeNodeTypes: ['class_definition', 'extension_declaration', 'enum_declaration'],
+    }),
     enclosingFunctionFinder: dartEnclosingFunctionFinder,
     builtInNames: BUILT_INS,
 });

package/dist/core/ingestion/languages/go.js

@@ -9,6 +9,7 @@
  *   - callRouter: present (Go method calls may need routing)
  */
 import { SupportedLanguages } from '../../../_shared/index.js';
+import { createClassExtractor } from '../class-extractors/generic.js';
 import { defineLanguage } from '../language-provider.js';
 import { typeConfig as goConfig } from '../type-extractors/go.js';
 import { goExportChecker } from '../export-detection.js';
@@ -16,6 +17,8 @@ import { resolveGoImport } from '../import-resolvers/go.js';
 import { GO_QUERIES } from '../tree-sitter-queries.js';
 import { createFieldExtractor } from '../field-extractors/generic.js';
 import { goConfig as goFieldConfig } from '../field-extractors/configs/go.js';
+import { createMethodExtractor } from '../method-extractors/generic.js';
+import { goMethodConfig } from '../method-extractors/configs/go.js';
 export const goProvider = defineLanguage({
     id: SupportedLanguages.Go,
     extensions: ['.go'],
@@ -25,4 +28,23 @@ export const goProvider = defineLanguage({
     importResolver: resolveGoImport,
     importSemantics: 'wildcard',
     fieldExtractor: createFieldExtractor(goFieldConfig),
+    methodExtractor: createMethodExtractor(goMethodConfig),
+    classExtractor: createClassExtractor({
+        language: SupportedLanguages.Go,
+        typeDeclarationNodes: ['type_declaration'],
+        fileScopeNodeTypes: ['package_clause'],
+        extractName(node) {
+            const typeSpec = node.namedChildren.find((child) => child.type === 'type_spec');
+            return typeSpec?.childForFieldName('name')?.text;
+        },
+        extractType(node) {
+            const typeSpec = node.namedChildren.find((child) => child.type === 'type_spec');
+            const typeNode = typeSpec?.childForFieldName('type');
+            if (typeNode?.type === 'struct_type')
+                return 'Struct';
+            if (typeNode?.type === 'interface_type')
+                return 'Interface';
+            return undefined;
+        },
+    }),
 });

package/dist/core/ingestion/languages/index.d.ts

@@ -24,6 +24,7 @@ export declare const providers: {
     ruby: LanguageProvider;
     swift: LanguageProvider;
     dart: LanguageProvider;
+    vue: LanguageProvider;
     cobol: LanguageProvider;
 };
 /** Get provider by language enum (always succeeds for SupportedLanguages). */

package/dist/core/ingestion/languages/index.js

@@ -20,6 +20,7 @@ import { phpProvider } from './php.js';
 import { rubyProvider } from './ruby.js';
 import { swiftProvider } from './swift.js';
 import { dartProvider } from './dart.js';
+import { vueProvider } from './vue.js';
 import { cobolProvider } from './cobol.js';
 export const providers = {
     [SupportedLanguages.JavaScript]: javascriptProvider,
@@ -36,6 +37,7 @@ export const providers = {
     [SupportedLanguages.Ruby]: rubyProvider,
     [SupportedLanguages.Swift]: swiftProvider,
     [SupportedLanguages.Dart]: dartProvider,
+    [SupportedLanguages.Vue]: vueProvider,
     [SupportedLanguages.Cobol]: cobolProvider,
 };
 /** Get provider by language enum (always succeeds for SupportedLanguages). */

package/dist/core/ingestion/languages/java.js

@@ -7,6 +7,7 @@
  * interface implementation.
  */
 import { SupportedLanguages } from '../../../_shared/index.js';
+import { createClassExtractor } from '../class-extractors/generic.js';
 import { defineLanguage } from '../language-provider.js';
 import { javaTypeConfig } from '../type-extractors/jvm.js';
 import { javaExportChecker } from '../export-detection.js';
@@ -29,4 +30,20 @@ export const javaProvider = defineLanguage({
     mroStrategy: 'implements-split',
     fieldExtractor: createFieldExtractor(javaConfig),
     methodExtractor: createMethodExtractor(javaMethodConfig),
+    classExtractor: createClassExtractor({
+        language: SupportedLanguages.Java,
+        typeDeclarationNodes: [
+            'class_declaration',
+            'interface_declaration',
+            'enum_declaration',
+            'record_declaration',
+        ],
+        fileScopeNodeTypes: ['package_declaration'],
+        ancestorScopeNodeTypes: [
+            'class_declaration',
+            'interface_declaration',
+            'enum_declaration',
+            'record_declaration',
+        ],
+    }),
 });

package/dist/core/ingestion/languages/kotlin.js

@@ -7,6 +7,7 @@
  * multiple interface implementation.
  */
 import { SupportedLanguages } from '../../../_shared/index.js';
+import { createClassExtractor } from '../class-extractors/generic.js';
 import { defineLanguage } from '../language-provider.js';
 import { kotlinTypeConfig } from '../type-extractors/jvm.js';
 import { kotlinExportChecker } from '../export-detection.js';
@@ -14,11 +15,22 @@ import { resolveKotlinImport } from '../import-resolvers/jvm.js';
 import { extractKotlinNamedBindings } from '../named-bindings/kotlin.js';
 import { appendKotlinWildcard } from '../import-resolvers/jvm.js';
 import { KOTLIN_QUERIES } from '../tree-sitter-queries.js';
-import { isKotlinClassMethod } from '../utils/ast-helpers.js';
 import { createFieldExtractor } from '../field-extractors/generic.js';
 import { kotlinConfig } from '../field-extractors/configs/jvm.js';
 import { createMethodExtractor } from '../method-extractors/generic.js';
 import { kotlinMethodConfig } from '../method-extractors/configs/jvm.js';
+/** Check if a Kotlin function_declaration capture is inside a class_body (i.e., a method).
+ *  Kotlin grammar uses function_declaration for both top-level functions and class methods.
+ *  Returns true when the captured definition node has a class_body ancestor. */
+function isKotlinClassMethod(captureNode) {
+    let ancestor = captureNode?.parent;
+    while (ancestor) {
+        if (ancestor.type === 'class_body')
+            return true;
+        ancestor = ancestor.parent;
+    }
+    return false;
+}
 const BUILT_INS = new Set([
     'println',
     'print',
@@ -89,6 +101,17 @@ export const kotlinProvider = defineLanguage({
     mroStrategy: 'implements-split',
     fieldExtractor: createFieldExtractor(kotlinConfig),
     methodExtractor: createMethodExtractor(kotlinMethodConfig),
+    classExtractor: createClassExtractor({
+        language: SupportedLanguages.Kotlin,
+        typeDeclarationNodes: ['class_declaration', 'object_declaration', 'companion_object'],
+        fileScopeNodeTypes: ['package_header'],
+        ancestorScopeNodeTypes: ['class_declaration', 'object_declaration', 'companion_object'],
+        extractType(node) {
+            if (node.type !== 'class_declaration')
+                return undefined;
+            return node.children.some((child) => child?.text === 'interface') ? 'Interface' : 'Class';
+        },
+    }),
     builtInNames: BUILT_INS,
     labelOverride: (functionNode, defaultLabel) => {
         if (defaultLabel !== 'Function')

package/dist/core/ingestion/languages/php.js

@@ -6,6 +6,7 @@
  * extensions from legacy versions through modern PHP 8.
  */
 import { SupportedLanguages } from '../../../_shared/index.js';
+import { createClassExtractor } from '../class-extractors/generic.js';
 import { defineLanguage } from '../language-provider.js';
 import { typeConfig as phpConfig } from '../type-extractors/php.js';
 import { phpExportChecker } from '../export-detection.js';
@@ -15,6 +16,8 @@ import { PHP_QUERIES } from '../tree-sitter-queries.js';
 import { findDescendant, extractStringContent } from '../utils/ast-helpers.js';
 import { createFieldExtractor } from '../field-extractors/generic.js';
 import { phpConfig as phpFieldConfig } from '../field-extractors/configs/php.js';
+import { createMethodExtractor } from '../method-extractors/generic.js';
+import { phpMethodConfig } from '../method-extractors/configs/php.js';
 const BUILT_INS = new Set([
     'echo',
     'isset',
@@ -153,18 +156,21 @@ function extractPhpPropertyDescription(propName, propDeclNode) {
  * Returns description like "hasMany(Post)" or null.
  */
 function extractEloquentRelationDescription(methodNode) {
-    function findRelationCall(node) {
-        if (node.type === 'member_call_expression') {
+    function findRelationCall(root) {
+        const stack = [root];
+        while (stack.length > 0) {
+            const node = stack.pop();
+            if (node.type === 'member_call_expression') {
+                const children = node.children ?? [];
+                const objectNode = children.find((c) => c.type === 'variable_name' && c.text === '$this');
+                const nameNode = children.find((c) => c.type === 'name');
+                if (objectNode && nameNode && ELOQUENT_RELATIONS.has(nameNode.text))
+                    return node;
+            }
             const children = node.children ?? [];
-            const objectNode = children.find((c) => c.type === 'variable_name' && c.text === '$this');
-            const nameNode = children.find((c) => c.type === 'name');
-            if (objectNode && nameNode && ELOQUENT_RELATIONS.has(nameNode.text))
-                return node;
-        }
-        for (const child of node.children ?? []) {
-            const found = findRelationCall(child);
-            if (found)
-                return found;
+            for (let i = children.length - 1; i >= 0; i--) {
+                stack.push(children[i]);
+            }
         }
         return null;
     }
@@ -216,6 +222,12 @@ export const phpProvider = defineLanguage({
     importResolver: resolvePhpImport,
     namedBindingExtractor: extractPhpNamedBindings,
     fieldExtractor: createFieldExtractor(phpFieldConfig),
+    methodExtractor: createMethodExtractor(phpMethodConfig),
+    classExtractor: createClassExtractor({
+        language: SupportedLanguages.PHP,
+        typeDeclarationNodes: ['class_declaration', 'interface_declaration', 'enum_declaration'],
+        ancestorScopeNodeTypes: ['namespace_definition'],
+    }),
     descriptionExtractor: phpDescriptionExtractor,
     isRouteFile: isPhpRouteFile,
     builtInNames: BUILT_INS,

package/dist/core/ingestion/languages/python.js

@@ -10,6 +10,7 @@
  *   - namedBindingExtractor: present (from X import Y)
  */
 import { SupportedLanguages } from '../../../_shared/index.js';
+import { createClassExtractor } from '../class-extractors/generic.js';
 import { defineLanguage } from '../language-provider.js';
 import { typeConfig as pythonConfig } from '../type-extractors/python.js';
 import { pythonExportChecker } from '../export-detection.js';
@@ -18,6 +19,8 @@ import { extractPythonNamedBindings } from '../named-bindings/python.js';
 import { PYTHON_QUERIES } from '../tree-sitter-queries.js';
 import { createFieldExtractor } from '../field-extractors/generic.js';
 import { pythonConfig as pythonFieldConfig } from '../field-extractors/configs/python.js';
+import { createMethodExtractor } from '../method-extractors/generic.js';
+import { pythonMethodConfig } from '../method-extractors/configs/python.js';
 const BUILT_INS = new Set([
     'print',
     'len',
@@ -58,5 +61,11 @@ export const pythonProvider = defineLanguage({
     importSemantics: 'namespace',
     mroStrategy: 'c3',
     fieldExtractor: createFieldExtractor(pythonFieldConfig),
+    methodExtractor: createMethodExtractor(pythonMethodConfig),
+    classExtractor: createClassExtractor({
+        language: SupportedLanguages.Python,
+        typeDeclarationNodes: ['class_definition'],
+        ancestorScopeNodeTypes: ['class_definition'],
+    }),
     builtInNames: BUILT_INS,
 });

package/dist/core/ingestion/languages/ruby.js

@@ -7,6 +7,7 @@
  * attr_reader/attr_writer (property definitions) as call expressions.
  */
 import { SupportedLanguages } from '../../../_shared/index.js';
+import { createClassExtractor } from '../class-extractors/generic.js';
 import { defineLanguage } from '../language-provider.js';
 import { typeConfig as rubyConfig } from '../type-extractors/ruby.js';
 import { routeRubyCall } from '../call-routing.js';
@@ -15,6 +16,24 @@ import { resolveRubyImport } from '../import-resolvers/ruby.js';
 import { RUBY_QUERIES } from '../tree-sitter-queries.js';
 import { createFieldExtractor } from '../field-extractors/generic.js';
 import { rubyConfig as rubyFieldConfig } from '../field-extractors/configs/ruby.js';
+import { createMethodExtractor } from '../method-extractors/generic.js';
+import { rubyMethodConfig } from '../method-extractors/configs/ruby.js';
+/** Ruby method/singleton_method: extract name from 'name' field, label as Method. */
+const rubyExtractFunctionName = (node) => {
+    if (node.type !== 'method' && node.type !== 'singleton_method')
+        return null;
+    let nameNode = node.childForFieldName?.('name');
+    if (!nameNode) {
+        for (let i = 0; i < node.childCount; i++) {
+            const c = node.child(i);
+            if (c?.type === 'identifier') {
+                nameNode = c;
+                break;
+            }
+        }
+    }
+    return { funcName: nameNode?.text ?? null, label: 'Method' };
+};
 const BUILT_INS = new Set([
     'puts',
     'p',
@@ -81,6 +100,30 @@ export const rubyProvider = defineLanguage({
     importResolver: resolveRubyImport,
     callRouter: routeRubyCall,
     importSemantics: 'wildcard',
+    resolveEnclosingOwner(node) {
+        // Ruby singleton_class (class << self) should resolve to the enclosing
+        // class or module for owner/container resolution (HAS_METHOD edges, class IDs).
+        if (node.type === 'singleton_class') {
+            let ancestor = node.parent;
+            while (ancestor) {
+                if (ancestor.type === 'class' || ancestor.type === 'module') {
+                    return ancestor;
+                }
+                ancestor = ancestor.parent;
+            }
+            return null; // no enclosing class/module — skip
+        }
+        return node; // use as-is for all other container types
+    },
     fieldExtractor: createFieldExtractor(rubyFieldConfig),
+    methodExtractor: createMethodExtractor({
+        ...rubyMethodConfig,
+        extractFunctionName: rubyExtractFunctionName,
+    }),
+    classExtractor: createClassExtractor({
+        language: SupportedLanguages.Ruby,
+        typeDeclarationNodes: ['class'],
+        ancestorScopeNodeTypes: ['module', 'class'],
+    }),
     builtInNames: BUILT_INS,
 });

package/dist/core/ingestion/languages/rust.js

@@ -10,6 +10,7 @@
  *   - namedBindingExtractor: present (use X::{a, b} extracts named bindings)
  */
 import { SupportedLanguages } from '../../../_shared/index.js';
+import { createClassExtractor } from '../class-extractors/generic.js';
 import { defineLanguage } from '../language-provider.js';
 import { typeConfig as rustConfig } from '../type-extractors/rust.js';
 import { rustExportChecker } from '../export-detection.js';
@@ -18,6 +19,34 @@ import { extractRustNamedBindings } from '../named-bindings/rust.js';
 import { RUST_QUERIES } from '../tree-sitter-queries.js';
 import { createFieldExtractor } from '../field-extractors/generic.js';
 import { rustConfig as rustFieldConfig } from '../field-extractors/configs/rust.js';
+import { createMethodExtractor } from '../method-extractors/generic.js';
+import { rustMethodConfig } from '../method-extractors/configs/rust.js';
+/** Rust impl_item: find the function_item child and extract its name as a Method. */
+const rustExtractFunctionName = (node) => {
+    if (node.type !== 'impl_item')
+        return null;
+    let funcItem = null;
+    for (let i = 0; i < node.childCount; i++) {
+        const c = node.child(i);
+        if (c?.type === 'function_item') {
+            funcItem = c;
+            break;
+        }
+    }
+    if (!funcItem)
+        return null;
+    let nameNode = funcItem.childForFieldName?.('name');
+    if (!nameNode) {
+        for (let i = 0; i < funcItem.childCount; i++) {
+            const c = funcItem.child(i);
+            if (c?.type === 'identifier') {
+                nameNode = c;
+                break;
+            }
+        }
+    }
+    return { funcName: nameNode?.text ?? null, label: 'Method' };
+};
 const BUILT_INS = new Set([
     'unwrap',
     'expect',
@@ -84,5 +113,14 @@ export const rustProvider = defineLanguage({
     namedBindingExtractor: extractRustNamedBindings,
     mroStrategy: 'qualified-syntax',
     fieldExtractor: createFieldExtractor(rustFieldConfig),
+    methodExtractor: createMethodExtractor({
+        ...rustMethodConfig,
+        extractFunctionName: rustExtractFunctionName,
+    }),
+    classExtractor: createClassExtractor({
+        language: SupportedLanguages.Rust,
+        typeDeclarationNodes: ['struct_item', 'enum_item'],
+        ancestorScopeNodeTypes: ['mod_item', 'struct_item', 'enum_item'],
+    }),
     builtInNames: BUILT_INS,
 });