gitnexus 1.6.2-rc.8 → 1.6.2

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

@@ -7,10 +7,12 @@
  */
 import { SupportedLanguages } from '../../../_shared/index.js';
 import { createClassExtractor } from '../class-extractors/generic.js';
+import { phpClassConfig } from '../class-extractors/configs/php.js';
 import { defineLanguage } from '../language-provider.js';
 import { typeConfig as phpConfig } from '../type-extractors/php.js';
 import { phpExportChecker } from '../export-detection.js';
-import { resolvePhpImport } from '../import-resolvers/php.js';
+import { createImportResolver } from '../import-resolvers/resolver-factory.js';
+import { phpImportConfig } from '../import-resolvers/configs/php.js';
 import { extractPhpNamedBindings } from '../named-bindings/php.js';
 import { PHP_QUERIES } from '../tree-sitter-queries.js';
 import { findDescendant, extractStringContent } from '../utils/ast-helpers.js';
@@ -18,6 +20,11 @@ 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';
+import { createVariableExtractor } from '../variable-extractors/generic.js';
+import { phpVariableConfig } from '../variable-extractors/configs/php.js';
+import { createCallExtractor } from '../call-extractors/generic.js';
+import { phpCallConfig } from '../call-extractors/configs/php.js';
+import { createHeritageExtractor } from '../heritage-extractors/generic.js';
 const BUILT_INS = new Set([
     'echo',
     'isset',
@@ -219,15 +226,14 @@ export const phpProvider = defineLanguage({
     treeSitterQueries: PHP_QUERIES,
     typeConfig: phpConfig,
     exportChecker: phpExportChecker,
-    importResolver: resolvePhpImport,
+    importResolver: createImportResolver(phpImportConfig),
     namedBindingExtractor: extractPhpNamedBindings,
+    callExtractor: createCallExtractor(phpCallConfig),
     fieldExtractor: createFieldExtractor(phpFieldConfig),
     methodExtractor: createMethodExtractor(phpMethodConfig),
-    classExtractor: createClassExtractor({
-        language: SupportedLanguages.PHP,
-        typeDeclarationNodes: ['class_declaration', 'interface_declaration', 'enum_declaration'],
-        ancestorScopeNodeTypes: ['namespace_definition'],
-    }),
+    variableExtractor: createVariableExtractor(phpVariableConfig),
+    classExtractor: createClassExtractor(phpClassConfig),
+    heritageExtractor: createHeritageExtractor(SupportedLanguages.PHP),
     descriptionExtractor: phpDescriptionExtractor,
     isRouteFile: isPhpRouteFile,
     builtInNames: BUILT_INS,

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

@@ -11,16 +11,23 @@
  */
 import { SupportedLanguages } from '../../../_shared/index.js';
 import { createClassExtractor } from '../class-extractors/generic.js';
+import { pythonClassConfig } from '../class-extractors/configs/python.js';
 import { defineLanguage } from '../language-provider.js';
 import { typeConfig as pythonConfig } from '../type-extractors/python.js';
 import { pythonExportChecker } from '../export-detection.js';
-import { resolvePythonImport } from '../import-resolvers/python.js';
+import { createImportResolver } from '../import-resolvers/resolver-factory.js';
+import { pythonImportConfig } from '../import-resolvers/configs/python.js';
 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';
+import { createVariableExtractor } from '../variable-extractors/generic.js';
+import { pythonVariableConfig } from '../variable-extractors/configs/python.js';
+import { createCallExtractor } from '../call-extractors/generic.js';
+import { pythonCallConfig } from '../call-extractors/configs/python.js';
+import { createHeritageExtractor } from '../heritage-extractors/generic.js';
 const BUILT_INS = new Set([
     'print',
     'len',
@@ -56,16 +63,15 @@ export const pythonProvider = defineLanguage({
     treeSitterQueries: PYTHON_QUERIES,
     typeConfig: pythonConfig,
     exportChecker: pythonExportChecker,
-    importResolver: resolvePythonImport,
+    importResolver: createImportResolver(pythonImportConfig),
     namedBindingExtractor: extractPythonNamedBindings,
     importSemantics: 'namespace',
     mroStrategy: 'c3',
+    callExtractor: createCallExtractor(pythonCallConfig),
     fieldExtractor: createFieldExtractor(pythonFieldConfig),
     methodExtractor: createMethodExtractor(pythonMethodConfig),
-    classExtractor: createClassExtractor({
-        language: SupportedLanguages.Python,
-        typeDeclarationNodes: ['class_definition'],
-        ancestorScopeNodeTypes: ['class_definition'],
-    }),
+    variableExtractor: createVariableExtractor(pythonVariableConfig),
+    classExtractor: createClassExtractor(pythonClassConfig),
+    heritageExtractor: createHeritageExtractor(SupportedLanguages.Python),
     builtInNames: BUILT_INS,
 });

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

@@ -8,16 +8,43 @@
  */
 import { SupportedLanguages } from '../../../_shared/index.js';
 import { createClassExtractor } from '../class-extractors/generic.js';
+import { rubyClassConfig } from '../class-extractors/configs/ruby.js';
 import { defineLanguage } from '../language-provider.js';
 import { typeConfig as rubyConfig } from '../type-extractors/ruby.js';
 import { routeRubyCall } from '../call-routing.js';
 import { rubyExportChecker } from '../export-detection.js';
-import { resolveRubyImport } from '../import-resolvers/ruby.js';
+import { createImportResolver } from '../import-resolvers/resolver-factory.js';
+import { rubyImportConfig } from '../import-resolvers/configs/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';
+import { createVariableExtractor } from '../variable-extractors/generic.js';
+import { rubyVariableConfig } from '../variable-extractors/configs/ruby.js';
+import { createCallExtractor } from '../call-extractors/generic.js';
+import { rubyCallConfig } from '../call-extractors/configs/ruby.js';
+import { createHeritageExtractor } from '../heritage-extractors/generic.js';
+import { rubyHeritageConfig } from '../heritage-extractors/configs/ruby.js';
+import { maybeRewriteRubyBareCallToSelf } from '../utils/ruby-self-call.js';
+import { findEnclosingClassInfo } from '../utils/ast-helpers.js';
+/**
+ * Ruby label override. Applied to:
+ *   - `definition.module` captures in the structure phase — remaps to `Trait`
+ *     so Ruby modules are registered in the class-like type registry and are
+ *     therefore resolvable by `lookupClassByName` during mixin heritage
+ *     resolution (`include`/`extend`/`prepend`).
+ *   - `definition.function` captures — Ruby has no bare "function" construct
+ *     (top-level `def` is a method on `main`); return the default so generic
+ *     logic continues to apply.
+ *
+ * Returning `null` means "skip this definition"; we never do that here.
+ */
+const rubyLabelOverride = (_node, defaultLabel) => {
+    if (defaultLabel === 'Module')
+        return 'Trait';
+    return defaultLabel;
+};
 /** Ruby method/singleton_method: extract name from 'name' field, label as Method. */
 const rubyExtractFunctionName = (node) => {
     if (node.type !== 'method' && node.type !== 'singleton_method')
@@ -91,39 +118,93 @@ const BUILT_INS = new Set([
     'flatten',
     'uniq',
 ]);
+/**
+ * Remaps `class << self` (singleton_class) to its enclosing class/module for
+ * receiver inference. A `singleton_class` node is not itself a type — walking
+ * up to the real owner lets `inferImplicitReceiver` set `hint='singleton'`.
+ * Returns null for orphaned singleton_class (no enclosing class/module found).
+ * All other container types are returned as-is.
+ */
+const rubyResolveEnclosingOwner = (node) => {
+    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
+};
 export const rubyProvider = defineLanguage({
     id: SupportedLanguages.Ruby,
     extensions: ['.rb', '.rake', '.gemspec'],
     treeSitterQueries: RUBY_QUERIES,
     typeConfig: rubyConfig,
     exportChecker: rubyExportChecker,
-    importResolver: resolveRubyImport,
+    importResolver: createImportResolver(rubyImportConfig),
     callRouter: routeRubyCall,
     importSemantics: 'wildcard-leaf',
-    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
-    },
+    callExtractor: createCallExtractor(rubyCallConfig),
+    resolveEnclosingOwner: rubyResolveEnclosingOwner,
     fieldExtractor: createFieldExtractor(rubyFieldConfig),
     methodExtractor: createMethodExtractor({
         ...rubyMethodConfig,
         extractFunctionName: rubyExtractFunctionName,
     }),
-    classExtractor: createClassExtractor({
-        language: SupportedLanguages.Ruby,
-        typeDeclarationNodes: ['class'],
-        ancestorScopeNodeTypes: ['module', 'class'],
-    }),
+    variableExtractor: createVariableExtractor(rubyVariableConfig),
+    classExtractor: createClassExtractor(rubyClassConfig),
+    heritageExtractor: createHeritageExtractor(rubyHeritageConfig),
+    labelOverride: rubyLabelOverride,
+    // Ruby MRO is kind-aware: prepend providers beat the class's own method,
+    // which in turn beats include providers. See `lookupMethodByOwnerWithMRO`
+    // in `model/resolve.ts` for the walk order.
+    mroStrategy: 'ruby-mixin',
+    // ── DAG hooks ────────────────────────────────────────────────────
+    //
+    // DAG stage 3: rewrite bare calls (e.g. `serialize` in Account#call_serialize)
+    // as `self.serialize` so they route through owner-scoped MRO instead of
+    // global free-call lookup. `dispatchKind` goes into `hint` for stage 4.
+    inferImplicitReceiver: ({ calledName, callForm, receiverName, receiverTypeName, callNode, filePath, }) => {
+        // Only fire when no receiver has been resolved already.
+        if (receiverName || receiverTypeName)
+            return null;
+        const enclosing = findEnclosingClassInfo(callNode, filePath, rubyResolveEnclosingOwner);
+        const rewrite = maybeRewriteRubyBareCallToSelf(calledName, callForm, callNode, enclosing?.className ?? null, { isBuiltInName: (n) => BUILT_INS.has(n), mroStrategy: 'ruby-mixin' });
+        if (!rewrite)
+            return null;
+        return {
+            callForm: rewrite.callForm,
+            receiverName: rewrite.receiverName,
+            receiverTypeName: rewrite.receiverTypeName,
+            receiverSource: 'implicit-self',
+            hint: rewrite.dispatchKind, // 'instance' | 'singleton'
+        };
+    },
+    // DAG stage 4: two Ruby dispatch overrides —
+    //   implicit-self: MRO walk first, fallback to free-arity-narrowed on miss.
+    //   class-as-receiver: singleton ancestry (extend providers only); miss null-routes.
+    selectDispatch: ({ receiverSource, hint }) => {
+        if (receiverSource === 'implicit-self') {
+            // hint='instance' → instance ancestry (prepend→direct→include, see mro-strategy.ts § 'ruby-mixin')
+            // hint='singleton' → singleton ancestry (extend providers only; miss null-routes)
+            const ancestryView = hint === 'singleton' ? 'singleton' : 'instance';
+            return {
+                primary: 'owner-scoped',
+                fallback: 'free-arity-narrowed',
+                ancestryView,
+            };
+        }
+        if (receiverSource === 'class-as-receiver') {
+            // Class constant receiver (e.g. Account.log): singleton ancestry only; miss null-routes.
+            return {
+                primary: 'owner-scoped',
+                ancestryView: 'singleton',
+            };
+        }
+        return null;
+    },
     builtInNames: BUILT_INS,
 });

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

@@ -11,16 +11,23 @@
  */
 import { SupportedLanguages } from '../../../_shared/index.js';
 import { createClassExtractor } from '../class-extractors/generic.js';
+import { rustClassConfig } from '../class-extractors/configs/rust.js';
 import { defineLanguage } from '../language-provider.js';
 import { typeConfig as rustConfig } from '../type-extractors/rust.js';
 import { rustExportChecker } from '../export-detection.js';
-import { resolveRustImport } from '../import-resolvers/rust.js';
+import { createImportResolver } from '../import-resolvers/resolver-factory.js';
+import { rustImportConfig } from '../import-resolvers/configs/rust.js';
 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';
+import { createVariableExtractor } from '../variable-extractors/generic.js';
+import { rustVariableConfig } from '../variable-extractors/configs/rust.js';
+import { createCallExtractor } from '../call-extractors/generic.js';
+import { rustCallConfig } from '../call-extractors/configs/rust.js';
+import { createHeritageExtractor } from '../heritage-extractors/generic.js';
 /** Rust impl_item: find the function_item child and extract its name as a Method. */
 const rustExtractFunctionName = (node) => {
     if (node.type !== 'impl_item')
@@ -109,18 +116,17 @@ export const rustProvider = defineLanguage({
     treeSitterQueries: RUST_QUERIES,
     typeConfig: rustConfig,
     exportChecker: rustExportChecker,
-    importResolver: resolveRustImport,
+    importResolver: createImportResolver(rustImportConfig),
     namedBindingExtractor: extractRustNamedBindings,
     mroStrategy: 'qualified-syntax',
+    callExtractor: createCallExtractor(rustCallConfig),
     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'],
-    }),
+    variableExtractor: createVariableExtractor(rustVariableConfig),
+    classExtractor: createClassExtractor(rustClassConfig),
+    heritageExtractor: createHeritageExtractor(SupportedLanguages.Rust),
     builtInNames: BUILT_INS,
 });

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

@@ -11,15 +11,22 @@
  */
 import { SupportedLanguages } from '../../../_shared/index.js';
 import { createClassExtractor } from '../class-extractors/generic.js';
+import { swiftClassConfig } from '../class-extractors/configs/swift.js';
 import { defineLanguage } from '../language-provider.js';
 import { typeConfig as swiftConfig } from '../type-extractors/swift.js';
 import { swiftExportChecker } from '../export-detection.js';
-import { resolveSwiftImport } from '../import-resolvers/swift.js';
+import { createImportResolver } from '../import-resolvers/resolver-factory.js';
+import { swiftImportConfig } from '../import-resolvers/configs/swift.js';
 import { SWIFT_QUERIES } from '../tree-sitter-queries.js';
 import { createFieldExtractor } from '../field-extractors/generic.js';
 import { swiftConfig as swiftFieldConfig } from '../field-extractors/configs/swift.js';
 import { createMethodExtractor } from '../method-extractors/generic.js';
 import { swiftMethodConfig } from '../method-extractors/configs/swift.js';
+import { createVariableExtractor } from '../variable-extractors/generic.js';
+import { swiftVariableConfig } from '../variable-extractors/configs/swift.js';
+import { createCallExtractor } from '../call-extractors/generic.js';
+import { swiftCallConfig } from '../call-extractors/configs/swift.js';
+import { createHeritageExtractor } from '../heritage-extractors/generic.js';
 /**
  * Group Swift files by SPM target for implicit module visibility.
  * If SwiftPackageConfig is available, use target -> directory mappings.
@@ -220,30 +227,18 @@ export const swiftProvider = defineLanguage({
     treeSitterQueries: SWIFT_QUERIES,
     typeConfig: swiftConfig,
     exportChecker: swiftExportChecker,
-    importResolver: resolveSwiftImport,
+    importResolver: createImportResolver(swiftImportConfig),
     importSemantics: 'wildcard-leaf',
     heritageDefaultEdge: 'IMPLEMENTS',
+    callExtractor: createCallExtractor(swiftCallConfig),
     fieldExtractor: createFieldExtractor(swiftFieldConfig),
     methodExtractor: createMethodExtractor({
         ...swiftMethodConfig,
         extractFunctionName: swiftExtractFunctionName,
     }),
-    classExtractor: createClassExtractor({
-        language: SupportedLanguages.Swift,
-        typeDeclarationNodes: ['class_declaration', 'protocol_declaration'],
-        ancestorScopeNodeTypes: ['class_declaration', 'protocol_declaration'],
-        extractType(node) {
-            if (node.type === 'protocol_declaration')
-                return 'Interface';
-            if (node.type !== 'class_declaration')
-                return undefined;
-            if (node.children.some((child) => child?.text === 'struct'))
-                return 'Struct';
-            if (node.children.some((child) => child?.text === 'enum'))
-                return 'Enum';
-            return 'Class';
-        },
-    }),
+    variableExtractor: createVariableExtractor(swiftVariableConfig),
+    classExtractor: createClassExtractor(swiftClassConfig),
+    heritageExtractor: createHeritageExtractor(SupportedLanguages.Swift),
     implicitImportWirer: wireSwiftImplicitImports,
     builtInNames: BUILT_INS,
 });

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

@@ -9,9 +9,11 @@
 import { SupportedLanguages } from '../../../_shared/index.js';
 import { defineLanguage } from '../language-provider.js';
 import { createClassExtractor } from '../class-extractors/generic.js';
+import { typescriptClassConfig, javascriptClassConfig, } from '../class-extractors/configs/typescript-javascript.js';
 import { typeConfig as typescriptConfig } from '../type-extractors/typescript.js';
 import { tsExportChecker } from '../export-detection.js';
-import { resolveTypescriptImport, resolveJavascriptImport } from '../import-resolvers/standard.js';
+import { createImportResolver } from '../import-resolvers/resolver-factory.js';
+import { typescriptImportConfig, javascriptImportConfig, } from '../import-resolvers/configs/typescript-javascript.js';
 import { extractTsNamedBindings } from '../named-bindings/typescript.js';
 import { TYPESCRIPT_QUERIES, JAVASCRIPT_QUERIES } from '../tree-sitter-queries.js';
 import { typescriptFieldExtractor } from '../field-extractors/typescript.js';
@@ -19,6 +21,11 @@ import { createFieldExtractor } from '../field-extractors/generic.js';
 import { javascriptConfig } from '../field-extractors/configs/typescript-javascript.js';
 import { createMethodExtractor } from '../method-extractors/generic.js';
 import { typescriptMethodConfig, javascriptMethodConfig, } from '../method-extractors/configs/typescript-javascript.js';
+import { createVariableExtractor } from '../variable-extractors/generic.js';
+import { typescriptVariableConfig, javascriptVariableConfig, } from '../variable-extractors/configs/typescript-javascript.js';
+import { createCallExtractor } from '../call-extractors/generic.js';
+import { typescriptCallConfig, javascriptCallConfig, } from '../call-extractors/configs/typescript-javascript.js';
+import { createHeritageExtractor } from '../heritage-extractors/generic.js';
 /**
  * TypeScript/JavaScript: arrow_function and function_expression get their name
  * from the parent variable_declarator (e.g. `const foo = () => {}`).
@@ -137,35 +144,23 @@ export const BUILT_INS = new Set([
     'toString',
     'valueOf',
 ]);
-const tsJsClassConfig = {
-    language: SupportedLanguages.TypeScript,
-    typeDeclarationNodes: [
-        'class_declaration',
-        'abstract_class_declaration',
-        'interface_declaration',
-        'enum_declaration',
-    ],
-    ancestorScopeNodeTypes: [
-        'class_declaration',
-        'abstract_class_declaration',
-        'interface_declaration',
-        'enum_declaration',
-    ],
-};
 export const typescriptProvider = defineLanguage({
     id: SupportedLanguages.TypeScript,
     extensions: ['.ts', '.tsx'],
     treeSitterQueries: TYPESCRIPT_QUERIES,
     typeConfig: typescriptConfig,
     exportChecker: tsExportChecker,
-    importResolver: resolveTypescriptImport,
+    importResolver: createImportResolver(typescriptImportConfig),
     namedBindingExtractor: extractTsNamedBindings,
+    callExtractor: createCallExtractor(typescriptCallConfig),
     fieldExtractor: typescriptFieldExtractor,
     methodExtractor: createMethodExtractor({
         ...typescriptMethodConfig,
         extractFunctionName: tsExtractFunctionName,
     }),
-    classExtractor: createClassExtractor(tsJsClassConfig),
+    variableExtractor: createVariableExtractor(typescriptVariableConfig),
+    classExtractor: createClassExtractor(typescriptClassConfig),
+    heritageExtractor: createHeritageExtractor(SupportedLanguages.TypeScript),
     builtInNames: BUILT_INS,
 });
 export const javascriptProvider = defineLanguage({
@@ -174,16 +169,16 @@ export const javascriptProvider = defineLanguage({
     treeSitterQueries: JAVASCRIPT_QUERIES,
     typeConfig: typescriptConfig,
     exportChecker: tsExportChecker,
-    importResolver: resolveJavascriptImport,
+    importResolver: createImportResolver(javascriptImportConfig),
     namedBindingExtractor: extractTsNamedBindings,
+    callExtractor: createCallExtractor(javascriptCallConfig),
     fieldExtractor: createFieldExtractor(javascriptConfig),
     methodExtractor: createMethodExtractor({
         ...javascriptMethodConfig,
         extractFunctionName: tsExtractFunctionName,
     }),
-    classExtractor: createClassExtractor({
-        ...tsJsClassConfig,
-        language: SupportedLanguages.JavaScript,
-    }),
+    variableExtractor: createVariableExtractor(javascriptVariableConfig),
+    classExtractor: createClassExtractor(javascriptClassConfig),
+    heritageExtractor: createHeritageExtractor(SupportedLanguages.JavaScript),
     builtInNames: BUILT_INS,
 });

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

@@ -12,14 +12,21 @@
  */
 import { SupportedLanguages } from '../../../_shared/index.js';
 import { createClassExtractor } from '../class-extractors/generic.js';
+import { vueClassConfig } from '../class-extractors/configs/typescript-javascript.js';
 import { defineLanguage } from '../language-provider.js';
 import { typeConfig as typescriptConfig } from '../type-extractors/typescript.js';
 import { tsExportChecker } from '../export-detection.js';
-import { resolveVueImport } from '../import-resolvers/vue.js';
+import { createImportResolver } from '../import-resolvers/resolver-factory.js';
+import { vueImportConfig } from '../import-resolvers/configs/typescript-javascript.js';
 import { extractTsNamedBindings } from '../named-bindings/typescript.js';
 import { TYPESCRIPT_QUERIES } from '../tree-sitter-queries.js';
 import { typescriptFieldExtractor } from '../field-extractors/typescript.js';
 import { BUILT_INS as TS_BUILT_INS } from './typescript.js';
+import { createVariableExtractor } from '../variable-extractors/generic.js';
+import { typescriptVariableConfig } from '../variable-extractors/configs/typescript-javascript.js';
+import { createCallExtractor } from '../call-extractors/generic.js';
+import { typescriptCallConfig } from '../call-extractors/configs/typescript-javascript.js';
+import { createHeritageExtractor } from '../heritage-extractors/generic.js';
 const VUE_SPECIFIC_BUILT_INS = [
     'ref',
     'reactive',
@@ -52,30 +59,19 @@ const VUE_SPECIFIC_BUILT_INS = [
     'useAttrs',
 ];
 const VUE_BUILT_INS = new Set([...TS_BUILT_INS, ...VUE_SPECIFIC_BUILT_INS]);
-const vueClassExtractor = createClassExtractor({
-    language: SupportedLanguages.Vue,
-    typeDeclarationNodes: [
-        'class_declaration',
-        'abstract_class_declaration',
-        'interface_declaration',
-        'enum_declaration',
-    ],
-    ancestorScopeNodeTypes: [
-        'class_declaration',
-        'abstract_class_declaration',
-        'interface_declaration',
-        'enum_declaration',
-    ],
-});
+const vueClassExtractor = createClassExtractor(vueClassConfig);
 export const vueProvider = defineLanguage({
     id: SupportedLanguages.Vue,
     extensions: ['.vue'],
     treeSitterQueries: TYPESCRIPT_QUERIES,
     typeConfig: typescriptConfig,
     exportChecker: tsExportChecker,
-    importResolver: resolveVueImport,
+    importResolver: createImportResolver(vueImportConfig),
     namedBindingExtractor: extractTsNamedBindings,
+    callExtractor: createCallExtractor(typescriptCallConfig),
     fieldExtractor: typescriptFieldExtractor,
+    variableExtractor: createVariableExtractor(typescriptVariableConfig),
     classExtractor: vueClassExtractor,
+    heritageExtractor: createHeritageExtractor(SupportedLanguages.TypeScript),
     builtInNames: VUE_BUILT_INS,
 });

package/dist/core/ingestion/model/heritage-map.d.ts

@@ -43,11 +43,46 @@ export declare const resolveExtendsType: (parentName: string, currentFilePath: s
     type: "EXTENDS" | "IMPLEMENTS";
     idPrefix: string;
 };
+/**
+ * Direct parent entry with the heritage kind that produced it. Preserved
+ * so kind-aware consumers (Ruby MRO, see `lookupMethodByOwnerWithMRO`) can
+ * walk prepend/include providers in the correct order. Flat-string consumers
+ * use `getParents` / `getAncestors` and see only the parent nodeIds.
+ */
+export interface ParentEntry {
+    readonly parentId: string;
+    /** 'extends' | 'implements' | 'trait-impl' | 'include' | 'extend' | 'prepend' */
+    readonly kind: string;
+}
 export interface HeritageMap {
     /** Direct parents of `childNodeId` (extends + implements + trait-impl). */
     getParents(childNodeId: string): string[];
     /** Full ancestor chain (BFS, bounded depth, cycle-safe). */
     getAncestors(childNodeId: string): string[];
+    /**
+     * Direct parents with heritage kind preserved, insertion-ordered. Used by
+     * kind-aware consumers (Ruby MRO) that need to distinguish prepend /
+     * include / extend / extends for walk-order decisions.
+     *
+     * Insertion order mirrors the order `ExtractedHeritage` records were fed
+     * into `buildHeritageMap`, which in turn mirrors tree-sitter match order.
+     * For Ruby, this matches source declaration order for `prepend` / `include`
+     * statements — the MRO walk reverses this (last-declared-first) at the
+     * consumer side.
+     */
+    getParentEntries(childNodeId: string): readonly ParentEntry[];
+    /**
+     * Ordered ancestry for instance method dispatch (Ruby-aware): includes
+     * `extends`, `implements`, `trait-impl`, `include`, `prepend` kinds.
+     * Excludes `extend` (singleton-only). Order is caller-determined in Unit 3.
+     * For non-Ruby callers (first-wins, c3, etc.), this matches `getAncestors`.
+     */
+    getInstanceAncestry(childNodeId: string): readonly ParentEntry[];
+    /**
+     * Ordered ancestry for singleton / class-method dispatch (Ruby-aware):
+     * only `extend` kind parents. For non-Ruby languages this is always empty.
+     */
+    getSingletonAncestry(childNodeId: string): readonly ParentEntry[];
     /**
      * File paths of classes that directly implement or extend-as-interface the
      * given interface/abstract-class **name**. Replaces the standalone