gitnexus 1.6.2-rc.9 → 1.6.2

package/dist/core/ingestion/call-types.d.ts

@@ -0,0 +1,135 @@
+/**
+ * Types for the language-agnostic call extraction pipeline.
+ *
+ * Mirrors method-types.ts / field-types.ts: defines the domain interfaces
+ * consumed by createCallExtractor() and the per-language configs.
+ */
+import type { SupportedLanguages } from '../../_shared/index.js';
+import type { SyntaxNode } from './utils/ast-helpers.js';
+import type { MixedChainStep } from './utils/call-analysis.js';
+/**
+ * Per-node call extraction result.  The parse worker enriches this with
+ * file-level context (filePath, sourceId, TypeEnv lookups, arg types) to
+ * produce the final `ExtractedCall` that enters the resolution pipeline.
+ */
+export interface ExtractedCallSite {
+    calledName: string;
+    callForm?: 'free' | 'member' | 'constructor';
+    receiverName?: string;
+    argCount?: number;
+    /** Unified mixed chain for complex receivers (field + call chains). */
+    receiverMixedChain?: MixedChainStep[];
+    /** When true, the type-as-receiver heuristic applies: if receiverName
+     *  starts with an uppercase letter and has no TypeEnv binding, treat it
+     *  as a type name (e.g. Java `User::getName`). */
+    typeAsReceiverHeuristic?: boolean;
+}
+export interface CallExtractor {
+    readonly language: SupportedLanguages;
+    /**
+     * Extract a call site from captured AST nodes.
+     *
+     * @param callNode     The @call capture (call_expression, method_invocation, …)
+     * @param callNameNode The @call.name capture (identifier inside the call).
+     *                     May be undefined when the call shape has no name capture
+     *                     (e.g. Java method_reference via `::`).
+     * @returns Extracted call site, or null when no call can be derived.
+     */
+    extract(callNode: SyntaxNode, callNameNode: SyntaxNode | undefined): ExtractedCallSite | null;
+}
+export interface CallExtractionConfig {
+    language: SupportedLanguages;
+    /**
+     * Language-specific call site extraction.  Called **before** the generic
+     * path.  If it returns non-null, the generic `inferCallForm` /
+     * `extractReceiverName` path is skipped entirely.
+     *
+     * Use this for call shapes that don't follow the standard `@call` /
+     * `@call.name` pattern (e.g. Java `method_reference` via `::`).
+     */
+    extractLanguageCallSite?: (callNode: SyntaxNode) => ExtractedCallSite | null;
+    /**
+     * Whether the type-as-receiver heuristic applies for this language.
+     * When true and the receiver name starts with an uppercase letter,
+     * the receiver is treated as a type name when no TypeEnv binding exists.
+     *
+     * Applies to JVM and C# languages where `Type.method()` and `Type::method`
+     * are common patterns.
+     */
+    typeAsReceiverHeuristic?: boolean;
+}
+/**
+ * DAG stage 3 output: call record with receiver type and source discriminant.
+ *
+ * `receiverTypeName` is resolved via TypeEnv → constructor-map → class-as-receiver →
+ * mixed-chain, or synthesized by `inferImplicitReceiver`. `receiverSource` tags
+ * which path won and drives MRO strategy selection in stage 4.
+ *
+ * Invariants:
+ * - `receiverSource` MUST match how `receiverTypeName` was resolved; every
+ *   discriminant must have a live reader and writer.
+ * - `hint` is opaque to shared stages; only the same provider's `selectDispatch` reads it.
+ *
+ * @see language-provider.ts § inferImplicitReceiver, selectDispatch
+ */
+export interface ReceiverEnriched {
+    readonly calledName: string;
+    readonly callForm: 'free' | 'member' | 'constructor' | undefined;
+    readonly receiverName: string | undefined;
+    readonly receiverTypeName: string | undefined;
+    readonly receiverSource: 'none' | 'typed-binding' | 'constructor-map' | 'class-as-receiver' | 'mixed-chain' | 'implicit-self';
+    /** Free-form hint from the provider hook; opaque to shared stages. */
+    readonly hint?: string;
+}
+/**
+ * Provider hook output for `LanguageProvider.inferImplicitReceiver` (DAG stage 3).
+ *
+ * Overlay applied to `ReceiverEnriched` when an implicit receiver is synthesized.
+ * Ruby example: bare `serialize` inside `Account#call_serialize` →
+ * `{ callForm: 'member', receiverName: 'self', receiverTypeName: 'Account',
+ *   receiverSource: 'implicit-self', hint: 'instance' }`
+ *
+ * Invariants:
+ * - `receiverSource` is always `'implicit-self'` — the only variant this type produces.
+ * - `callForm` is always `'member'` — the rewrite converts bare-call to method invocation.
+ * - `hint` is opaque to shared stages; consumed by the same language's `selectDispatch`.
+ */
+export interface ImplicitReceiverOverride {
+    readonly callForm: 'free' | 'member' | 'constructor';
+    readonly receiverName: string;
+    readonly receiverTypeName: string;
+    readonly receiverSource: Extract<ReceiverEnriched['receiverSource'], 'implicit-self'>;
+    /** Free-form language tag (e.g. Ruby sets 'singleton' for `def self.foo`
+     *  method bodies). Consumed by the same language's `selectDispatch` hook. */
+    readonly hint?: string;
+}
+/**
+ * DAG stage 4 output: dispatch strategy for resolving the target method.
+ *
+ * Encodes which resolver branch to try first and an optional fallback.
+ * Stage 5 delegates to `resolveMemberCall`, `resolveFreeCall`, or
+ * `resolveStaticCall` based on `primary`.
+ *
+ * - `primary`: `'owner-scoped'` = MRO walk, `'free'` = arity-tiered global lookup,
+ *   `'constructor'` = type instantiation.
+ * - `fallback`: Only `'free-arity-narrowed'` exists; used by Ruby implicit-self
+ *   to degrade to arity-tiered free lookup when the MRO walk misses.
+ * - `ancestryView`: Ruby `'ruby-mixin'` only. `'singleton'` walks extend providers
+ *   only; a miss NEVER falls through to file-scoped lookup (enforced in
+ *   resolveCallTarget). `'instance'` is the default.
+ *
+ * Common patterns:
+ *   - `{primary: 'constructor'}` — constructor call
+ *   - `{primary: 'owner-scoped'}` — member call with known type
+ *   - `{primary: 'owner-scoped', fallback: 'free-arity-narrowed', ancestryView: 'instance'}` — Ruby implicit-self
+ *   - `{primary: 'owner-scoped', ancestryView: 'singleton'}` — Ruby class-method call
+ *
+ * @see language-provider.ts § selectDispatch
+ * @see call-processor.ts § defaultDispatchDecision, resolveCallTarget
+ */
+export interface DispatchDecision {
+    readonly primary: 'owner-scoped' | 'free' | 'constructor';
+    readonly fallback?: 'free-arity-narrowed';
+    readonly ancestryView?: 'instance' | 'singleton';
+    readonly hint?: string;
+}

package/dist/core/ingestion/call-types.js

@@ -0,0 +1,2 @@
+// gitnexus/src/core/ingestion/call-types.ts
+export {};

package/dist/core/ingestion/class-extractors/configs/c-cpp.d.ts

@@ -0,0 +1,3 @@
+import type { ClassExtractionConfig } from '../../class-types.js';
+export declare const cClassConfig: ClassExtractionConfig;
+export declare const cppClassConfig: ClassExtractionConfig;

package/dist/core/ingestion/class-extractors/configs/c-cpp.js

@@ -0,0 +1,11 @@
+// gitnexus/src/core/ingestion/class-extractors/configs/c-cpp.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+export const cClassConfig = {
+    language: SupportedLanguages.C,
+    typeDeclarationNodes: ['struct_specifier', 'enum_specifier'],
+};
+export const cppClassConfig = {
+    language: SupportedLanguages.CPlusPlus,
+    typeDeclarationNodes: ['class_specifier', 'struct_specifier', 'enum_specifier'],
+    ancestorScopeNodeTypes: ['namespace_definition', 'class_specifier', 'struct_specifier'],
+};

package/dist/core/ingestion/class-extractors/configs/csharp.d.ts

@@ -0,0 +1,2 @@
+import type { ClassExtractionConfig } from '../../class-types.js';
+export declare const csharpClassConfig: ClassExtractionConfig;

package/dist/core/ingestion/class-extractors/configs/csharp.js

@@ -0,0 +1,21 @@
+// gitnexus/src/core/ingestion/class-extractors/configs/csharp.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+export const csharpClassConfig = {
+    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',
+    ],
+};

package/dist/core/ingestion/class-extractors/configs/dart.d.ts

@@ -0,0 +1,2 @@
+import type { ClassExtractionConfig } from '../../class-types.js';
+export declare const dartClassConfig: ClassExtractionConfig;

package/dist/core/ingestion/class-extractors/configs/dart.js

@@ -0,0 +1,7 @@
+// gitnexus/src/core/ingestion/class-extractors/configs/dart.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+export const dartClassConfig = {
+    language: SupportedLanguages.Dart,
+    typeDeclarationNodes: ['class_definition', 'extension_declaration', 'enum_declaration'],
+    ancestorScopeNodeTypes: ['class_definition', 'extension_declaration', 'enum_declaration'],
+};

package/dist/core/ingestion/class-extractors/configs/go.d.ts

@@ -0,0 +1,2 @@
+import type { ClassExtractionConfig } from '../../class-types.js';
+export declare const goClassConfig: ClassExtractionConfig;

package/dist/core/ingestion/class-extractors/configs/go.js

@@ -0,0 +1,20 @@
+// gitnexus/src/core/ingestion/class-extractors/configs/go.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+export const goClassConfig = {
+    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/class-extractors/configs/jvm.d.ts

@@ -0,0 +1,3 @@
+import type { ClassExtractionConfig } from '../../class-types.js';
+export declare const javaClassConfig: ClassExtractionConfig;
+export declare const kotlinClassConfig: ClassExtractionConfig;

package/dist/core/ingestion/class-extractors/configs/jvm.js

@@ -0,0 +1,35 @@
+// gitnexus/src/core/ingestion/class-extractors/configs/jvm.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+// ---------------------------------------------------------------------------
+// Java
+// ---------------------------------------------------------------------------
+export const javaClassConfig = {
+    language: SupportedLanguages.Java,
+    typeDeclarationNodes: [
+        'class_declaration',
+        'interface_declaration',
+        'enum_declaration',
+        'record_declaration',
+    ],
+    fileScopeNodeTypes: ['package_declaration'],
+    ancestorScopeNodeTypes: [
+        'class_declaration',
+        'interface_declaration',
+        'enum_declaration',
+        'record_declaration',
+    ],
+};
+// ---------------------------------------------------------------------------
+// Kotlin
+// ---------------------------------------------------------------------------
+export const kotlinClassConfig = {
+    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';
+    },
+};

package/dist/core/ingestion/class-extractors/configs/php.d.ts

@@ -0,0 +1,2 @@
+import type { ClassExtractionConfig } from '../../class-types.js';
+export declare const phpClassConfig: ClassExtractionConfig;

package/dist/core/ingestion/class-extractors/configs/php.js

@@ -0,0 +1,7 @@
+// gitnexus/src/core/ingestion/class-extractors/configs/php.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+export const phpClassConfig = {
+    language: SupportedLanguages.PHP,
+    typeDeclarationNodes: ['class_declaration', 'interface_declaration', 'enum_declaration'],
+    ancestorScopeNodeTypes: ['namespace_definition'],
+};

package/dist/core/ingestion/class-extractors/configs/python.d.ts

@@ -0,0 +1,2 @@
+import type { ClassExtractionConfig } from '../../class-types.js';
+export declare const pythonClassConfig: ClassExtractionConfig;

package/dist/core/ingestion/class-extractors/configs/python.js

@@ -0,0 +1,7 @@
+// gitnexus/src/core/ingestion/class-extractors/configs/python.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+export const pythonClassConfig = {
+    language: SupportedLanguages.Python,
+    typeDeclarationNodes: ['class_definition'],
+    ancestorScopeNodeTypes: ['class_definition'],
+};

package/dist/core/ingestion/class-extractors/configs/ruby.d.ts

@@ -0,0 +1,2 @@
+import type { ClassExtractionConfig } from '../../class-types.js';
+export declare const rubyClassConfig: ClassExtractionConfig;

package/dist/core/ingestion/class-extractors/configs/ruby.js

@@ -0,0 +1,7 @@
+// gitnexus/src/core/ingestion/class-extractors/configs/ruby.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+export const rubyClassConfig = {
+    language: SupportedLanguages.Ruby,
+    typeDeclarationNodes: ['class'],
+    ancestorScopeNodeTypes: ['module', 'class'],
+};

package/dist/core/ingestion/class-extractors/configs/rust.d.ts

@@ -0,0 +1,2 @@
+import type { ClassExtractionConfig } from '../../class-types.js';
+export declare const rustClassConfig: ClassExtractionConfig;

package/dist/core/ingestion/class-extractors/configs/rust.js

@@ -0,0 +1,7 @@
+// gitnexus/src/core/ingestion/class-extractors/configs/rust.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+export const rustClassConfig = {
+    language: SupportedLanguages.Rust,
+    typeDeclarationNodes: ['struct_item', 'enum_item'],
+    ancestorScopeNodeTypes: ['mod_item', 'struct_item', 'enum_item'],
+};

package/dist/core/ingestion/class-extractors/configs/swift.d.ts

@@ -0,0 +1,2 @@
+import type { ClassExtractionConfig } from '../../class-types.js';
+export declare const swiftClassConfig: ClassExtractionConfig;

package/dist/core/ingestion/class-extractors/configs/swift.js

@@ -0,0 +1,18 @@
+// gitnexus/src/core/ingestion/class-extractors/configs/swift.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+export const swiftClassConfig = {
+    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';
+    },
+};

package/dist/core/ingestion/class-extractors/configs/typescript-javascript.d.ts

@@ -0,0 +1,4 @@
+import type { ClassExtractionConfig } from '../../class-types.js';
+export declare const typescriptClassConfig: ClassExtractionConfig;
+export declare const javascriptClassConfig: ClassExtractionConfig;
+export declare const vueClassConfig: ClassExtractionConfig;

package/dist/core/ingestion/class-extractors/configs/typescript-javascript.js

@@ -0,0 +1,28 @@
+// gitnexus/src/core/ingestion/class-extractors/configs/typescript-javascript.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+const shared = {
+    typeDeclarationNodes: [
+        'class_declaration',
+        'abstract_class_declaration',
+        'interface_declaration',
+        'enum_declaration',
+    ],
+    ancestorScopeNodeTypes: [
+        'class_declaration',
+        'abstract_class_declaration',
+        'interface_declaration',
+        'enum_declaration',
+    ],
+};
+export const typescriptClassConfig = {
+    ...shared,
+    language: SupportedLanguages.TypeScript,
+};
+export const javascriptClassConfig = {
+    ...shared,
+    language: SupportedLanguages.JavaScript,
+};
+export const vueClassConfig = {
+    ...shared,
+    language: SupportedLanguages.Vue,
+};

package/dist/core/ingestion/field-types.d.ts

@@ -1,5 +1,5 @@
 import type { TypeEnvironment } from './type-env.js';
-import type { SymbolTableReader } from './model/symbol-table.js';
+import type { SymbolTableReader } from './model/index.js';
 import { SupportedLanguages } from '../../_shared/index.js';
 /**
  * Visibility levels used across all supported languages.

package/dist/core/ingestion/heritage-extractors/configs/go.d.ts

@@ -0,0 +1,13 @@
+import type { HeritageExtractionConfig } from '../../heritage-types.js';
+/**
+ * Go heritage extraction config.
+ *
+ * Go struct embedding: the tree-sitter query matches ALL field_declarations
+ * with type_identifier, but only anonymous fields (no name) are embedded.
+ * Named fields like `Breed string` also match — skip them.
+ *
+ * The shouldSkipExtends hook checks if the extends node's parent is a
+ * field_declaration with a named field child, indicating a regular
+ * (non-embedded) field that should not produce a heritage record.
+ */
+export declare const goHeritageConfig: HeritageExtractionConfig;

package/dist/core/ingestion/heritage-extractors/configs/go.js

@@ -0,0 +1,20 @@
+// gitnexus/src/core/ingestion/heritage-extractors/configs/go.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+/**
+ * Go heritage extraction config.
+ *
+ * Go struct embedding: the tree-sitter query matches ALL field_declarations
+ * with type_identifier, but only anonymous fields (no name) are embedded.
+ * Named fields like `Breed string` also match — skip them.
+ *
+ * The shouldSkipExtends hook checks if the extends node's parent is a
+ * field_declaration with a named field child, indicating a regular
+ * (non-embedded) field that should not produce a heritage record.
+ */
+export const goHeritageConfig = {
+    language: SupportedLanguages.Go,
+    shouldSkipExtends(extendsNode) {
+        const fieldDecl = extendsNode.parent;
+        return fieldDecl?.type === 'field_declaration' && fieldDecl.childForFieldName?.('name') != null;
+    },
+};

package/dist/core/ingestion/heritage-extractors/configs/ruby.d.ts

@@ -0,0 +1,18 @@
+import type { HeritageExtractionConfig } from '../../heritage-types.js';
+/**
+ * Ruby heritage extraction config.
+ *
+ * Ruby expresses inheritance in two ways, and only one of them has
+ * dedicated tree-sitter heritage captures:
+ *
+ * 1. Class inheritance (`class A < B`) produces standard
+ *    `@heritage.extends` captures and flows through the generic
+ *    capture-based `extract` hook (not defined here — the factory
+ *    handles it).
+ * 2. Mixin calls (`include`/`extend`/`prepend`) have no dedicated
+ *    heritage captures; they surface as ordinary call sites. The
+ *    `callBasedHeritage` hook below intercepts them before the call
+ *    router, absorbing the mixin routing logic that previously lived
+ *    in call-routing.ts (routeRubyCall).
+ */
+export declare const rubyHeritageConfig: HeritageExtractionConfig;

package/dist/core/ingestion/heritage-extractors/configs/ruby.js

@@ -0,0 +1,65 @@
+// gitnexus/src/core/ingestion/heritage-extractors/configs/ruby.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+/**
+ * Maximum parent depth for enclosing class/module walk.
+ * Prevents runaway walks on malformed/deeply-nested ASTs.
+ */
+const MAX_PARENT_DEPTH = 50;
+/**
+ * Walk up the AST from a call node to find the enclosing class or module name.
+ * Ruby include/extend/prepend calls must be inside a class or module body.
+ */
+function findEnclosingClassName(callNode) {
+    let current = callNode.parent;
+    let depth = 0;
+    while (current && ++depth <= MAX_PARENT_DEPTH) {
+        if (current.type === 'class' || current.type === 'module') {
+            const nameNode = current.childForFieldName?.('name');
+            if (nameNode)
+                return nameNode.text;
+        }
+        current = current.parent;
+    }
+    return null;
+}
+/** Ruby heritage call names that express mixin inclusion. */
+const RUBY_HERITAGE_CALL_NAMES = new Set(['include', 'extend', 'prepend']);
+/**
+ * Ruby heritage extraction config.
+ *
+ * Ruby expresses inheritance in two ways, and only one of them has
+ * dedicated tree-sitter heritage captures:
+ *
+ * 1. Class inheritance (`class A < B`) produces standard
+ *    `@heritage.extends` captures and flows through the generic
+ *    capture-based `extract` hook (not defined here — the factory
+ *    handles it).
+ * 2. Mixin calls (`include`/`extend`/`prepend`) have no dedicated
+ *    heritage captures; they surface as ordinary call sites. The
+ *    `callBasedHeritage` hook below intercepts them before the call
+ *    router, absorbing the mixin routing logic that previously lived
+ *    in call-routing.ts (routeRubyCall).
+ */
+export const rubyHeritageConfig = {
+    language: SupportedLanguages.Ruby,
+    callBasedHeritage: {
+        callNames: RUBY_HERITAGE_CALL_NAMES,
+        extract(calledName, callNode, _filePath) {
+            const enclosingClass = findEnclosingClassName(callNode);
+            if (!enclosingClass)
+                return [];
+            const results = [];
+            const argList = callNode.childForFieldName?.('arguments');
+            for (const arg of argList?.children ?? []) {
+                if (arg.type === 'constant' || arg.type === 'scope_resolution') {
+                    results.push({
+                        className: enclosingClass,
+                        parentName: arg.text,
+                        kind: calledName, // 'include' | 'extend' | 'prepend'
+                    });
+                }
+            }
+            return results;
+        },
+    },
+};

package/dist/core/ingestion/heritage-extractors/generic.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Generic table-driven heritage extractor factory.
+ *
+ * Follows the same config+factory pattern as method-extractors/generic.ts,
+ * field-extractors/generic.ts, call-extractors/generic.ts, and
+ * variable-extractors/generic.ts.
+ *
+ * Languages with custom extraction hooks (Go: shouldSkipExtends, Ruby:
+ * callBasedHeritage) pass a full HeritageExtractionConfig.  Languages
+ * that use the default capture-based extraction can pass just the
+ * SupportedLanguages enum value — no per-language config file needed.
+ */
+import type { SupportedLanguages } from '../../../_shared/index.js';
+import type { HeritageExtractionConfig, HeritageExtractor } from '../heritage-types.js';
+/**
+ * Create a HeritageExtractor from a declarative config or a language enum.
+ *
+ * When a full HeritageExtractionConfig is provided, custom hooks
+ * (shouldSkipExtends, callBasedHeritage) drive the extraction.
+ * When only a SupportedLanguages value is provided, the factory produces
+ * a default extractor that handles the standard @heritage.* captures.
+ */
+export declare function createHeritageExtractor(config: HeritageExtractionConfig | SupportedLanguages): HeritageExtractor;

package/dist/core/ingestion/heritage-extractors/generic.js

@@ -0,0 +1,47 @@
+// gitnexus/src/core/ingestion/heritage-extractors/generic.ts
+/**
+ * Create a HeritageExtractor from a declarative config or a language enum.
+ *
+ * When a full HeritageExtractionConfig is provided, custom hooks
+ * (shouldSkipExtends, callBasedHeritage) drive the extraction.
+ * When only a SupportedLanguages value is provided, the factory produces
+ * a default extractor that handles the standard @heritage.* captures.
+ */
+export function createHeritageExtractor(config) {
+    const actualConfig = typeof config === 'string' ? { language: config } : config;
+    const callNameSet = actualConfig.callBasedHeritage?.callNames;
+    return {
+        language: actualConfig.language,
+        extract(captureMap, context) {
+            const classNode = captureMap['heritage.class'];
+            if (!classNode)
+                return [];
+            const className = classNode.text;
+            const results = [];
+            const extendsNode = captureMap['heritage.extends'];
+            if (extendsNode) {
+                if (!actualConfig.shouldSkipExtends?.(extendsNode)) {
+                    results.push({ className, parentName: extendsNode.text, kind: 'extends' });
+                }
+            }
+            const implementsNode = captureMap['heritage.implements'];
+            if (implementsNode) {
+                results.push({ className, parentName: implementsNode.text, kind: 'implements' });
+            }
+            const traitNode = captureMap['heritage.trait'];
+            if (traitNode) {
+                results.push({ className, parentName: traitNode.text, kind: 'trait-impl' });
+            }
+            return results;
+        },
+        ...(callNameSet
+            ? {
+                extractFromCall(calledName, callNode, context) {
+                    if (!callNameSet.has(calledName))
+                        return null;
+                    return actualConfig.callBasedHeritage.extract(calledName, callNode, context.filePath);
+                },
+            }
+            : {}),
+    };
+}

package/dist/core/ingestion/heritage-processor.d.ts

@@ -38,6 +38,15 @@ export declare const processHeritageFromExtracted: (graph: KnowledgeGraph, extra
  * {@link ExtractedHeritage} rows without mutating the graph. Used on the
  * sequential pipeline path so `buildHeritageMap(..., ctx)` can run before
  * `processCalls` (worker path defers calls until heritage from all chunks exists).
+ *
+ * This prepass extracts BOTH capture-based heritage (`@heritage.*` — extends /
+ * implements / trait-impl) AND call-based heritage (`@call.name` routed through
+ * `heritageExtractor.extractFromCall` — Ruby `include` / `extend` / `prepend`).
+ * Without the second pass, sequential-mode `sequentialHeritageMap` would not
+ * know about Ruby mixin ancestry before `processCalls` resolves calls against
+ * it, silently dropping mixed-in methods from the graph. This function stays
+ * read-only — `processCalls` still owns emission of heritage graph edges via
+ * its `rubyHeritage` return path.
  */
 export declare function extractExtractedHeritageFromFiles(files: {
     path: string;