gitnexus 1.6.2-rc.13 → 1.6.2-rc.15

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

@@ -0,0 +1,3 @@
+import type { CallExtractionConfig } from '../../call-types.js';
+export declare const cCallConfig: CallExtractionConfig;
+export declare const cppCallConfig: CallExtractionConfig;

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

@@ -0,0 +1,8 @@
+// gitnexus/src/core/ingestion/call-extractors/configs/c-cpp.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+export const cCallConfig = {
+    language: SupportedLanguages.C,
+};
+export const cppCallConfig = {
+    language: SupportedLanguages.CPlusPlus,
+};

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

@@ -0,0 +1,2 @@
+import type { CallExtractionConfig } from '../../call-types.js';
+export declare const csharpCallConfig: CallExtractionConfig;

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

@@ -0,0 +1,6 @@
+// gitnexus/src/core/ingestion/call-extractors/configs/csharp.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+export const csharpCallConfig = {
+    language: SupportedLanguages.CSharp,
+    typeAsReceiverHeuristic: true,
+};

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

@@ -0,0 +1,2 @@
+import type { CallExtractionConfig } from '../../call-types.js';
+export declare const dartCallConfig: CallExtractionConfig;

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

@@ -0,0 +1,5 @@
+// gitnexus/src/core/ingestion/call-extractors/configs/dart.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+export const dartCallConfig = {
+    language: SupportedLanguages.Dart,
+};

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

@@ -0,0 +1,2 @@
+import type { CallExtractionConfig } from '../../call-types.js';
+export declare const goCallConfig: CallExtractionConfig;

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

@@ -0,0 +1,5 @@
+// gitnexus/src/core/ingestion/call-extractors/configs/go.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+export const goCallConfig = {
+    language: SupportedLanguages.Go,
+};

package/dist/core/ingestion/call-extractors/configs/jvm.d.ts

@@ -0,0 +1,3 @@
+import type { CallExtractionConfig } from '../../call-types.js';
+export declare const javaCallConfig: CallExtractionConfig;
+export declare const kotlinCallConfig: CallExtractionConfig;

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

@@ -0,0 +1,51 @@
+// gitnexus/src/core/ingestion/call-extractors/configs/jvm.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+// ---------------------------------------------------------------------------
+// Java method_reference (::) parsing — absorbs call-sites/java.ts
+// ---------------------------------------------------------------------------
+/**
+ * Parse Java `method_reference` nodes (`expr::method`, `Type::new`,
+ * `this::m`, `super::m`).
+ */
+function parseJavaMethodReference(callNode) {
+    if (callNode.type !== 'method_reference')
+        return null;
+    const recv = callNode.namedChild(0);
+    if (!recv)
+        return null;
+    // Type::new  →  constructor call
+    for (const c of callNode.children) {
+        if (c.type === 'new') {
+            if (recv.type !== 'identifier')
+                return null;
+            return { calledName: recv.text, callForm: 'constructor' };
+        }
+    }
+    // expr::method  →  member call with receiver
+    const rhs = callNode.child(callNode.childCount - 1);
+    if (!rhs || rhs.type !== 'identifier')
+        return null;
+    const methodName = rhs.text;
+    if (recv.type === 'identifier') {
+        return { calledName: methodName, callForm: 'member', receiverName: recv.text };
+    }
+    if (recv.type === 'this') {
+        return { calledName: methodName, callForm: 'member', receiverName: 'this' };
+    }
+    if (recv.type === 'super') {
+        return { calledName: methodName, callForm: 'member', receiverName: 'super' };
+    }
+    return null;
+}
+// ---------------------------------------------------------------------------
+// Configs
+// ---------------------------------------------------------------------------
+export const javaCallConfig = {
+    language: SupportedLanguages.Java,
+    extractLanguageCallSite: parseJavaMethodReference,
+    typeAsReceiverHeuristic: true,
+};
+export const kotlinCallConfig = {
+    language: SupportedLanguages.Kotlin,
+    typeAsReceiverHeuristic: true,
+};

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

@@ -0,0 +1,2 @@
+import type { CallExtractionConfig } from '../../call-types.js';
+export declare const phpCallConfig: CallExtractionConfig;

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

@@ -0,0 +1,5 @@
+// gitnexus/src/core/ingestion/call-extractors/configs/php.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+export const phpCallConfig = {
+    language: SupportedLanguages.PHP,
+};

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

@@ -0,0 +1,2 @@
+import type { CallExtractionConfig } from '../../call-types.js';
+export declare const pythonCallConfig: CallExtractionConfig;

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

@@ -0,0 +1,5 @@
+// gitnexus/src/core/ingestion/call-extractors/configs/python.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+export const pythonCallConfig = {
+    language: SupportedLanguages.Python,
+};

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

@@ -0,0 +1,2 @@
+import type { CallExtractionConfig } from '../../call-types.js';
+export declare const rubyCallConfig: CallExtractionConfig;

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

@@ -0,0 +1,5 @@
+// gitnexus/src/core/ingestion/call-extractors/configs/ruby.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+export const rubyCallConfig = {
+    language: SupportedLanguages.Ruby,
+};

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

@@ -0,0 +1,2 @@
+import type { CallExtractionConfig } from '../../call-types.js';
+export declare const rustCallConfig: CallExtractionConfig;

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

@@ -0,0 +1,5 @@
+// gitnexus/src/core/ingestion/call-extractors/configs/rust.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+export const rustCallConfig = {
+    language: SupportedLanguages.Rust,
+};

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

@@ -0,0 +1,2 @@
+import type { CallExtractionConfig } from '../../call-types.js';
+export declare const swiftCallConfig: CallExtractionConfig;

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

@@ -0,0 +1,5 @@
+// gitnexus/src/core/ingestion/call-extractors/configs/swift.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+export const swiftCallConfig = {
+    language: SupportedLanguages.Swift,
+};

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

@@ -0,0 +1,3 @@
+import type { CallExtractionConfig } from '../../call-types.js';
+export declare const typescriptCallConfig: CallExtractionConfig;
+export declare const javascriptCallConfig: CallExtractionConfig;

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

@@ -0,0 +1,8 @@
+// gitnexus/src/core/ingestion/call-extractors/configs/typescript-javascript.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+export const typescriptCallConfig = {
+    language: SupportedLanguages.TypeScript,
+};
+export const javascriptCallConfig = {
+    language: SupportedLanguages.JavaScript,
+};

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

@@ -0,0 +1,5 @@
+import type { CallExtractor, CallExtractionConfig } from '../call-types.js';
+/**
+ * Create a CallExtractor from a declarative config.
+ */
+export declare function createCallExtractor(config: CallExtractionConfig): CallExtractor;

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

@@ -0,0 +1,59 @@
+// gitnexus/src/core/ingestion/call-extractors/generic.ts
+import { inferCallForm, extractReceiverName, extractReceiverNode, extractMixedChain, countCallArguments, } from '../utils/call-analysis.js';
+/**
+ * Create a CallExtractor from a declarative config.
+ */
+export function createCallExtractor(config) {
+    return {
+        language: config.language,
+        extract(callNode, callNameNode) {
+            // ── Path 1: Language-specific call site ──────────────────────────
+            // Non-standard call shapes (e.g. Java `::` method references) are
+            // handled entirely by the config hook.  When it returns a result,
+            // the generic path is skipped — no argCount, no mixed chain.
+            //
+            // Note: `extractLanguageCallSite` is called on every `extract()`
+            // invocation — both `extract(callNode, undefined)` (parse-worker
+            // Path 1) and `extract(callNode, callNameNode)` (Path 2).
+            // Language hooks must therefore be idempotent and cheap (e.g. a
+            // single node-type check).
+            if (config.extractLanguageCallSite) {
+                const seed = config.extractLanguageCallSite(callNode);
+                if (seed) {
+                    return {
+                        ...seed,
+                        ...(config.typeAsReceiverHeuristic ? { typeAsReceiverHeuristic: true } : {}),
+                    };
+                }
+            }
+            // ── Path 2: Generic extraction via @call.name ────────────────────
+            if (!callNameNode)
+                return null;
+            const calledName = callNameNode.text;
+            const callForm = inferCallForm(callNode, callNameNode);
+            let receiverName = callForm === 'member' ? extractReceiverName(callNameNode) : undefined;
+            let receiverMixedChain;
+            // When the receiver is a complex expression (call chain, field chain,
+            // or mixed), extractReceiverName returns undefined.  Walk the receiver
+            // node to build a unified mixed chain for deferred resolution.
+            if (callForm === 'member' && receiverName === undefined) {
+                const receiverNode = extractReceiverNode(callNameNode);
+                if (receiverNode) {
+                    const extracted = extractMixedChain(receiverNode);
+                    if (extracted && extracted.chain.length > 0) {
+                        receiverMixedChain = extracted.chain;
+                        receiverName = extracted.baseReceiverName;
+                    }
+                }
+            }
+            return {
+                calledName,
+                ...(callForm !== undefined ? { callForm } : {}),
+                ...(receiverName !== undefined ? { receiverName } : {}),
+                argCount: countCallArguments(callNode),
+                ...(receiverMixedChain !== undefined ? { receiverMixedChain } : {}),
+                ...(config.typeAsReceiverHeuristic ? { typeAsReceiverHeuristic: true } : {}),
+            };
+        },
+    };
+}

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

@@ -15,7 +15,6 @@ import { getTreeSitterBufferSize } from './constants.js';
 import { normalizeFetchURL, routeMatches } from './route-extractors/nextjs.js';
 import { extractTemplateComponents } from './vue-sfc-extractor.js';
 import { extractReturnTypeName, stripNullable } from './type-extractors/shared.js';
-import { extractParsedCallSite } from './call-sites/extract-language-call-site.js';
 import { lookupMethodByOwnerWithMRO } from './model/resolve.js';
 /**
  * Type labels treated as class-like **method-dispatch receivers** by the call
@@ -733,52 +732,56 @@ importedRawReturnTypesMap, heritageMap, bindingAccumulator) => {
             if (!captureMap['call'])
                 return;
             const callNode = captureMap['call'];
-            const languageSeed = extractParsedCallSite(language, callNode);
-            if (languageSeed) {
-                if (provider.isBuiltInName(languageSeed.calledName))
-                    return;
-                const sourceId = findEnclosingFunction(callNode, file.path, ctx, provider) ||
-                    generateId('File', file.path);
-                const receiverName = languageSeed.callForm === 'member' ? languageSeed.receiverName : undefined;
-                let receiverTypeName = receiverName && typeEnv ? typeEnv.lookup(receiverName, callNode) : undefined;
-                if (receiverName !== undefined &&
-                    receiverTypeName === undefined &&
-                    languageSeed.callForm === 'member' &&
-                    (language === 'java' || language === 'csharp' || language === 'kotlin')) {
-                    const c0 = receiverName.charCodeAt(0);
-                    if (c0 >= 65 && c0 <= 90)
-                        receiverTypeName = receiverName;
-                }
-                const resolved = resolveCallTarget({
-                    calledName: languageSeed.calledName,
-                    callForm: languageSeed.callForm,
-                    ...(receiverTypeName !== undefined ? { receiverTypeName } : {}),
-                    ...(receiverName !== undefined ? { receiverName } : {}),
-                }, file.path, ctx, undefined, widenCache, undefined, heritageMap);
-                if (!resolved)
-                    return;
-                graph.addRelationship({
-                    id: generateId('CALLS', `${sourceId}:${languageSeed.calledName}->${resolved.nodeId}`),
-                    sourceId,
-                    targetId: resolved.nodeId,
-                    type: 'CALLS',
-                    confidence: resolved.confidence,
-                    reason: resolved.reason,
-                });
-                if (heritageMap && languageSeed.callForm === 'member' && receiverTypeName) {
-                    const implTargets = findInterfaceDispatchTargets(languageSeed.calledName, receiverTypeName, file.path, ctx, heritageMap, resolved.nodeId);
-                    for (const impl of implTargets) {
-                        graph.addRelationship({
-                            id: generateId('CALLS', `${sourceId}:${languageSeed.calledName}->${impl.nodeId}`),
-                            sourceId,
-                            targetId: impl.nodeId,
-                            type: 'CALLS',
-                            confidence: impl.confidence,
-                            reason: impl.reason,
-                        });
+            const callExtractor = provider.callExtractor;
+            // ── Language-specific call site (e.g. Java :: method references) ──
+            if (callExtractor) {
+                const langCallSite = callExtractor.extract(callNode, undefined);
+                if (langCallSite) {
+                    if (provider.isBuiltInName(langCallSite.calledName))
+                        return;
+                    const sourceId = findEnclosingFunction(callNode, file.path, ctx, provider) ||
+                        generateId('File', file.path);
+                    const receiverName = langCallSite.callForm === 'member' ? langCallSite.receiverName : undefined;
+                    let receiverTypeName = receiverName && typeEnv ? typeEnv.lookup(receiverName, callNode) : undefined;
+                    if (langCallSite.typeAsReceiverHeuristic &&
+                        receiverName !== undefined &&
+                        receiverTypeName === undefined &&
+                        langCallSite.callForm === 'member') {
+                        const c0 = receiverName.charCodeAt(0);
+                        if (c0 >= 65 && c0 <= 90)
+                            receiverTypeName = receiverName;
                     }
+                    const resolved = resolveCallTarget({
+                        calledName: langCallSite.calledName,
+                        callForm: langCallSite.callForm,
+                        ...(receiverTypeName !== undefined ? { receiverTypeName } : {}),
+                        ...(receiverName !== undefined ? { receiverName } : {}),
+                    }, file.path, ctx, undefined, widenCache, undefined, heritageMap);
+                    if (!resolved)
+                        return;
+                    graph.addRelationship({
+                        id: generateId('CALLS', `${sourceId}:${langCallSite.calledName}->${resolved.nodeId}`),
+                        sourceId,
+                        targetId: resolved.nodeId,
+                        type: 'CALLS',
+                        confidence: resolved.confidence,
+                        reason: resolved.reason,
+                    });
+                    if (heritageMap && langCallSite.callForm === 'member' && receiverTypeName) {
+                        const implTargets = findInterfaceDispatchTargets(langCallSite.calledName, receiverTypeName, file.path, ctx, heritageMap, resolved.nodeId);
+                        for (const impl of implTargets) {
+                            graph.addRelationship({
+                                id: generateId('CALLS', `${sourceId}:${langCallSite.calledName}->${impl.nodeId}`),
+                                sourceId,
+                                targetId: impl.nodeId,
+                                type: 'CALLS',
+                                confidence: impl.confidence,
+                                reason: impl.reason,
+                            });
+                        }
+                    }
+                    return;
                 }
-                return;
             }
             const nameNode = captureMap['call.name'];
             if (!nameNode)

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

@@ -0,0 +1,60 @@
+/**
+ * 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;
+}

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';
+    },
+};