gitnexus 1.4.10 → 1.5.0

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

@@ -0,0 +1,283 @@
+// gitnexus/src/core/ingestion/method-extractors/configs/csharp.ts
+import { SupportedLanguages } from 'gitnexus-shared';
+import { findVisibility, hasModifier, hasKeyword, collectModifierTexts, } from '../../field-extractors/configs/helpers.js';
+import { extractSimpleTypeName } from '../../type-extractors/shared.js';
+// ---------------------------------------------------------------------------
+// C# helpers
+// ---------------------------------------------------------------------------
+const CSHARP_VIS = new Set(['public', 'private', 'protected', 'internal']);
+/**
+ * Walk the parameter_list of a method or constructor and return typed ParameterInfo
+ * entries.
+ *
+ * In tree-sitter-c-sharp (verified against ^0.23.1), the `params` variadic keyword
+ * is NOT wrapped inside a `parameter` node.  It appears as a bare unnamed `params`
+ * token at the `parameter_list` level, followed by a type node and an identifier
+ * node that are also direct children of `parameter_list` (not of a `parameter` node).
+ *
+ * All other parameters are normal `parameter` named children of `parameter_list`:
+ *   - name comes from field 'name'
+ *   - type comes from field 'type'
+ *   - ref / out: modifier children inside the parameter node prefix the type string
+ *   - isOptional: an '=' token appears among the children (indicates a default value)
+ */
+function extractCSharpParameters(node) {
+    const paramList = node.childForFieldName('parameters');
+    if (!paramList)
+        return [];
+    return extractParametersFromList(paramList);
+}
+/** Extract parameters from a parameter_list node directly. */
+function extractParametersFromList(paramList) {
+    const params = [];
+    let i = 0;
+    while (i < paramList.childCount) {
+        const child = paramList.child(i);
+        if (!child) {
+            i++;
+            continue;
+        }
+        // `params` variadic: bare unnamed `params` keyword followed by type + identifier
+        // siblings at the parameter_list level (not wrapped in a `parameter` node).
+        if (!child.isNamed && child.type === 'params') {
+            let typeNode = null;
+            let nameText;
+            let j = i + 1;
+            while (j < paramList.childCount) {
+                const sibling = paramList.child(j);
+                if (!sibling) {
+                    j++;
+                    continue;
+                }
+                if (sibling.isNamed && sibling.type !== 'parameter') {
+                    if (!typeNode) {
+                        typeNode = sibling;
+                    }
+                    else if (sibling.type === 'identifier') {
+                        nameText = sibling.text;
+                        i = j;
+                        break;
+                    }
+                }
+                j++;
+            }
+            if (nameText) {
+                params.push({
+                    name: nameText,
+                    type: typeNode
+                        ? (extractSimpleTypeName(typeNode) ?? typeNode.text?.trim() ?? null)
+                        : null,
+                    isOptional: false,
+                    isVariadic: true,
+                });
+            }
+            i++;
+            continue;
+        }
+        // Regular named `parameter` node
+        if (child.isNamed && child.type === 'parameter') {
+            const nameNode = child.childForFieldName('name');
+            if (nameNode && nameNode.text.trim()) {
+                const typeNode = child.childForFieldName('type');
+                let typeName = typeNode
+                    ? (extractSimpleTypeName(typeNode) ?? typeNode.text?.trim() ?? null)
+                    : null;
+                // Detect ref / out modifiers inside the parameter node — prefix the type string
+                for (let j = 0; j < child.namedChildCount; j++) {
+                    const c = child.namedChild(j);
+                    if (!c || c.type !== 'modifier')
+                        continue;
+                    const modText = c.text.trim();
+                    if (modText === 'out' || modText === 'ref' || modText === 'in' || modText === 'this') {
+                        typeName = typeName ? `${modText} ${typeName}` : modText;
+                        break;
+                    }
+                }
+                // Detect optional (default value) — an '=' token among direct children
+                let isOptional = false;
+                for (let j = 0; j < child.childCount; j++) {
+                    const c = child.child(j);
+                    if (c && c.text.trim() === '=') {
+                        isOptional = true;
+                        break;
+                    }
+                }
+                params.push({
+                    name: nameNode.text,
+                    type: typeName,
+                    isOptional,
+                    isVariadic: false,
+                });
+            }
+        }
+        i++;
+    }
+    return params;
+}
+/**
+ * Collect C# attributes from attribute_list nodes on a method or constructor.
+ * Skips attribute lists with a target specifier (e.g. [return: NotNull],
+ * [param: Required]) — those target a different declaration element.
+ * Names are prefixed with '@' to mirror the JVM convention.
+ */
+function extractCSharpAnnotations(node) {
+    const annotations = [];
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (!child || child.type !== 'attribute_list')
+            continue;
+        // Skip targeted attribute lists (e.g. [return: ...], [method: ...])
+        let hasTarget = false;
+        for (let j = 0; j < child.namedChildCount; j++) {
+            if (child.namedChild(j)?.type === 'attribute_target_specifier') {
+                hasTarget = true;
+                break;
+            }
+        }
+        if (hasTarget)
+            continue;
+        for (let j = 0; j < child.namedChildCount; j++) {
+            const attr = child.namedChild(j);
+            if (!attr || attr.type !== 'attribute')
+                continue;
+            const nameNode = attr.childForFieldName('name');
+            if (nameNode)
+                annotations.push('@' + nameNode.text);
+        }
+    }
+    return annotations;
+}
+// ---------------------------------------------------------------------------
+// C# config
+// ---------------------------------------------------------------------------
+export const csharpMethodConfig = {
+    language: SupportedLanguages.CSharp,
+    typeDeclarationNodes: [
+        'class_declaration',
+        'struct_declaration',
+        'interface_declaration',
+        'record_declaration',
+    ],
+    methodNodeTypes: [
+        'method_declaration',
+        'constructor_declaration',
+        'destructor_declaration',
+        'operator_declaration',
+        'conversion_operator_declaration',
+    ],
+    bodyNodeTypes: ['declaration_list'],
+    extractName(node) {
+        // destructor_declaration: prefix with ~ to distinguish from constructor
+        if (node.type === 'destructor_declaration') {
+            const name = node.childForFieldName('name')?.text;
+            return name ? `~${name}` : undefined;
+        }
+        // operator_declaration: no 'name' field — use 'operator' field (e.g., +, ==)
+        if (node.type === 'operator_declaration') {
+            const op = node.childForFieldName('operator');
+            return op ? `operator ${op.text.trim()}` : undefined;
+        }
+        // conversion_operator_declaration: no 'name' field — implicit/explicit + target type
+        if (node.type === 'conversion_operator_declaration') {
+            const typeNode = node.childForFieldName('type');
+            const typeName = typeNode
+                ? (extractSimpleTypeName(typeNode) ?? typeNode.text?.trim())
+                : undefined;
+            for (let i = 0; i < node.childCount; i++) {
+                const c = node.child(i);
+                if (c && !c.isNamed && (c.text === 'implicit' || c.text === 'explicit')) {
+                    return typeName ? `${c.text} operator ${typeName}` : undefined;
+                }
+            }
+            return typeName ? `operator ${typeName}` : undefined;
+        }
+        return node.childForFieldName('name')?.text;
+    },
+    extractReturnType(node) {
+        // Constructors and destructors have no return type
+        // operator_declaration and conversion_operator_declaration use 'type' field, not 'returns'
+        const returnsNode = node.childForFieldName('returns');
+        if (returnsNode)
+            return extractSimpleTypeName(returnsNode) ?? returnsNode.text?.trim();
+        // Fallback for operator/conversion declarations that use 'type' as return type field
+        if (node.type === 'operator_declaration' || node.type === 'conversion_operator_declaration') {
+            const typeNode = node.childForFieldName('type');
+            if (typeNode)
+                return extractSimpleTypeName(typeNode) ?? typeNode.text?.trim();
+        }
+        return undefined;
+    },
+    extractParameters: extractCSharpParameters,
+    extractVisibility(node) {
+        // Detect compound C# visibilities: protected internal, private protected
+        const mods = collectModifierTexts(node);
+        if (mods.has('protected') && mods.has('internal'))
+            return 'protected internal';
+        if (mods.has('private') && mods.has('protected'))
+            return 'private protected';
+        return findVisibility(node, CSHARP_VIS, 'private', 'modifier');
+    },
+    isStatic(node) {
+        return hasKeyword(node, 'static') || hasModifier(node, 'modifier', 'static');
+    },
+    isAbstract(node, ownerNode) {
+        if (hasKeyword(node, 'abstract') || hasModifier(node, 'modifier', 'abstract'))
+            return true;
+        // Interface methods are implicitly abstract when they have no body
+        if (ownerNode.type === 'interface_declaration') {
+            const body = node.childForFieldName('body');
+            return !body;
+        }
+        return false;
+    },
+    isFinal(node) {
+        // C# uses 'sealed' instead of 'final'
+        return hasKeyword(node, 'sealed') || hasModifier(node, 'modifier', 'sealed');
+    },
+    extractAnnotations: extractCSharpAnnotations,
+    isVirtual(node) {
+        return hasKeyword(node, 'virtual') || hasModifier(node, 'modifier', 'virtual');
+    },
+    isOverride(node) {
+        return hasKeyword(node, 'override') || hasModifier(node, 'modifier', 'override');
+    },
+    isAsync(node) {
+        return hasKeyword(node, 'async') || hasModifier(node, 'modifier', 'async');
+    },
+    isPartial(node) {
+        return hasKeyword(node, 'partial') || hasModifier(node, 'modifier', 'partial');
+    },
+    extractPrimaryConstructor(ownerNode, context) {
+        // C# 12 primary constructors: class Point(int x, int y) { }
+        // The parameter_list is a direct named child of class_declaration/record_declaration
+        // but has NO field name — it must be found by iterating named children.
+        let paramList = null;
+        for (let i = 0; i < ownerNode.namedChildCount; i++) {
+            const child = ownerNode.namedChild(i);
+            if (child?.type === 'parameter_list') {
+                paramList = child;
+                break;
+            }
+        }
+        if (!paramList)
+            return null;
+        const name = ownerNode.childForFieldName('name')?.text;
+        if (!name)
+            return null;
+        const parameters = extractParametersFromList(paramList);
+        return {
+            name,
+            receiverType: null,
+            returnType: null,
+            parameters,
+            // Reuse the config's extractVisibility on the owner declaration node
+            visibility: csharpMethodConfig.extractVisibility(ownerNode),
+            isStatic: false,
+            isAbstract: false,
+            isFinal: false,
+            annotations: [], // C# has no syntax for attributes on primary constructors
+            sourceFile: context.filePath,
+            line: paramList.startPosition.row + 1,
+        };
+    },
+};

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

@@ -0,0 +1,3 @@
+import type { MethodExtractionConfig } from '../../method-types.js';
+export declare const javaMethodConfig: MethodExtractionConfig;
+export declare const kotlinMethodConfig: MethodExtractionConfig;

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

@@ -0,0 +1,326 @@
+// gitnexus/src/core/ingestion/method-extractors/configs/jvm.ts
+import { SupportedLanguages } from 'gitnexus-shared';
+import { findVisibility, hasModifier } from '../../field-extractors/configs/helpers.js';
+import { extractSimpleTypeName } from '../../type-extractors/shared.js';
+// ---------------------------------------------------------------------------
+// Shared JVM helpers
+// ---------------------------------------------------------------------------
+const INTERFACE_OWNER_TYPES = new Set(['interface_declaration', 'annotation_type_declaration']);
+function extractReturnTypeFromField(node) {
+    const typeNode = node.childForFieldName('type');
+    if (!typeNode)
+        return undefined;
+    return extractSimpleTypeName(typeNode) ?? typeNode.text?.trim();
+}
+function extractAnnotations(node, modifierType) {
+    const annotations = [];
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child && child.type === modifierType) {
+            for (let j = 0; j < child.namedChildCount; j++) {
+                const mod = child.namedChild(j);
+                if (mod && (mod.type === 'marker_annotation' || mod.type === 'annotation')) {
+                    const nameNode = mod.childForFieldName('name') ?? mod.firstNamedChild;
+                    if (nameNode)
+                        annotations.push('@' + nameNode.text);
+                }
+            }
+        }
+    }
+    return annotations;
+}
+// ---------------------------------------------------------------------------
+// Java
+// ---------------------------------------------------------------------------
+const JAVA_VIS = new Set(['public', 'private', 'protected']);
+function extractJavaParameters(node) {
+    const params = [];
+    let paramList = node.childForFieldName('parameters');
+    // Compact constructors have no parameter list — inherit from parent record_declaration
+    if (!paramList && node.type === 'compact_constructor_declaration') {
+        const recordNode = node.parent?.parent; // compact_ctor → class_body → record_declaration
+        if (recordNode?.type === 'record_declaration') {
+            paramList = recordNode.childForFieldName('parameters');
+        }
+    }
+    if (!paramList)
+        return params;
+    for (let i = 0; i < paramList.namedChildCount; i++) {
+        const param = paramList.namedChild(i);
+        if (!param)
+            continue;
+        if (param.type === 'formal_parameter') {
+            const nameNode = param.childForFieldName('name');
+            const typeNode = param.childForFieldName('type');
+            if (nameNode) {
+                params.push({
+                    name: nameNode.text,
+                    type: typeNode ? (extractSimpleTypeName(typeNode) ?? typeNode.text?.trim()) : null,
+                    isOptional: false,
+                    isVariadic: false,
+                });
+            }
+        }
+        else if (param.type === 'spread_parameter') {
+            // Varargs: type_identifier + "..." + variable_declarator
+            let paramName;
+            let paramType = null;
+            for (let j = 0; j < param.namedChildCount; j++) {
+                const c = param.namedChild(j);
+                if (!c)
+                    continue;
+                if (c.type === 'variable_declarator') {
+                    const nameChild = c.childForFieldName('name');
+                    paramName = nameChild?.text ?? c.text;
+                }
+                else if (c.type === 'type_identifier' ||
+                    c.type === 'generic_type' ||
+                    c.type === 'scoped_type_identifier' ||
+                    c.type === 'integral_type' ||
+                    c.type === 'floating_point_type' ||
+                    c.type === 'boolean_type') {
+                    paramType = extractSimpleTypeName(c) ?? c.text?.trim();
+                }
+            }
+            if (paramName) {
+                params.push({
+                    name: paramName,
+                    type: paramType,
+                    isOptional: false,
+                    isVariadic: true,
+                });
+            }
+        }
+    }
+    return params;
+}
+export const javaMethodConfig = {
+    language: SupportedLanguages.Java,
+    typeDeclarationNodes: [
+        'class_declaration',
+        'interface_declaration',
+        'enum_declaration',
+        'record_declaration',
+        'annotation_type_declaration',
+    ],
+    methodNodeTypes: [
+        'method_declaration',
+        'constructor_declaration',
+        'compact_constructor_declaration',
+        'annotation_type_element_declaration',
+    ],
+    bodyNodeTypes: [
+        'class_body',
+        'interface_body',
+        'enum_body',
+        'enum_body_declarations',
+        'annotation_type_body',
+    ],
+    extractName(node) {
+        const nameNode = node.childForFieldName('name');
+        return nameNode?.text;
+    },
+    extractReturnType: extractReturnTypeFromField,
+    extractParameters: extractJavaParameters,
+    extractVisibility(node) {
+        return findVisibility(node, JAVA_VIS, 'package', 'modifiers');
+    },
+    isStatic(node) {
+        return hasModifier(node, 'modifiers', 'static');
+    },
+    isAbstract(node, ownerNode) {
+        if (hasModifier(node, 'modifiers', 'abstract'))
+            return true;
+        // Interface methods are implicitly abstract unless they have a body (default methods)
+        if (INTERFACE_OWNER_TYPES.has(ownerNode.type)) {
+            const body = node.childForFieldName('body');
+            return !body;
+        }
+        return false;
+    },
+    isFinal(node) {
+        return hasModifier(node, 'modifiers', 'final');
+    },
+    extractAnnotations(node) {
+        return extractAnnotations(node, 'modifiers');
+    },
+};
+// ---------------------------------------------------------------------------
+// Kotlin
+// ---------------------------------------------------------------------------
+const KOTLIN_VIS = new Set(['public', 'private', 'protected', 'internal']);
+function extractKotlinParameters(node) {
+    const params = [];
+    // Kotlin: function_declaration > function_value_parameters > parameter
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child && child.type === 'function_value_parameters') {
+            let nextIsVariadic = false;
+            for (let j = 0; j < child.namedChildCount; j++) {
+                const param = child.namedChild(j);
+                if (!param)
+                    continue;
+                // parameter_modifiers containing vararg precedes the parameter node
+                if (param.type === 'parameter_modifiers') {
+                    for (let m = 0; m < param.namedChildCount; m++) {
+                        const mod = param.namedChild(m);
+                        if (mod && mod.text === 'vararg')
+                            nextIsVariadic = true;
+                    }
+                    continue;
+                }
+                if (param.type !== 'parameter')
+                    continue;
+                let paramName;
+                let paramType = null;
+                let hasDefault = false;
+                const isVariadic = nextIsVariadic;
+                nextIsVariadic = false;
+                for (let k = 0; k < param.namedChildCount; k++) {
+                    const part = param.namedChild(k);
+                    if (!part)
+                        continue;
+                    if (part.type === 'simple_identifier') {
+                        paramName = part.text;
+                    }
+                    else if (part.type === 'user_type' ||
+                        part.type === 'nullable_type' ||
+                        part.type === 'function_type') {
+                        paramType = extractSimpleTypeName(part) ?? part.text?.trim();
+                    }
+                }
+                // Check for default value: `= expr`
+                for (let k = 0; k < param.childCount; k++) {
+                    const c = param.child(k);
+                    if (c && c.text === '=') {
+                        hasDefault = true;
+                        break;
+                    }
+                }
+                if (paramName) {
+                    params.push({
+                        name: paramName,
+                        type: paramType,
+                        isOptional: hasDefault,
+                        isVariadic: isVariadic,
+                    });
+                }
+            }
+            break;
+        }
+    }
+    return params;
+}
+function extractKotlinReturnType(node) {
+    // Kotlin: return type appears after `:` following the parameter list
+    // In tree-sitter-kotlin, it's a user_type/nullable_type child after function_value_parameters
+    let seenParams = false;
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (!child)
+            continue;
+        if (child.type === 'function_value_parameters') {
+            seenParams = true;
+            continue;
+        }
+        if (seenParams &&
+            (child.type === 'user_type' ||
+                child.type === 'nullable_type' ||
+                child.type === 'function_type')) {
+            return extractSimpleTypeName(child) ?? child.text?.trim();
+        }
+        if (child.type === 'function_body')
+            break;
+    }
+    return undefined;
+}
+export const kotlinMethodConfig = {
+    language: SupportedLanguages.Kotlin,
+    typeDeclarationNodes: ['class_declaration', 'object_declaration', 'companion_object'],
+    methodNodeTypes: ['function_declaration'],
+    bodyNodeTypes: ['class_body'],
+    extractName(node) {
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child?.type === 'simple_identifier')
+                return child.text;
+        }
+        return undefined;
+    },
+    extractReturnType: extractKotlinReturnType,
+    extractParameters: extractKotlinParameters,
+    extractVisibility(node) {
+        return findVisibility(node, KOTLIN_VIS, 'public', 'modifiers');
+    },
+    isStatic(_node) {
+        // Kotlin has no static — companion object members are separate
+        return false;
+    },
+    isAbstract(node, ownerNode) {
+        if (hasModifier(node, 'modifiers', 'abstract'))
+            return true;
+        // Interface methods without a body are abstract
+        // Kotlin interfaces: class_declaration with "interface" keyword child
+        for (let i = 0; i < ownerNode.childCount; i++) {
+            const child = ownerNode.child(i);
+            if (child && child.text === 'interface') {
+                const body = node.childForFieldName('body');
+                // function_declaration > function_body
+                let hasBody = !!body;
+                if (!hasBody) {
+                    for (let j = 0; j < node.namedChildCount; j++) {
+                        const c = node.namedChild(j);
+                        if (c && c.type === 'function_body') {
+                            hasBody = true;
+                            break;
+                        }
+                    }
+                }
+                return !hasBody;
+            }
+        }
+        return false;
+    },
+    isFinal(node) {
+        // Kotlin functions are closed (final) by default — only open/abstract/override makes them overridable
+        if (hasModifier(node, 'modifiers', 'open'))
+            return false;
+        if (hasModifier(node, 'modifiers', 'abstract'))
+            return false;
+        if (hasModifier(node, 'modifiers', 'override'))
+            return false;
+        return true;
+    },
+    extractAnnotations(node) {
+        const annotations = [];
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child && child.type === 'modifiers') {
+                for (let j = 0; j < child.namedChildCount; j++) {
+                    const mod = child.namedChild(j);
+                    if (mod && mod.type === 'annotation') {
+                        // Kotlin annotation text includes the @ prefix
+                        const text = mod.text.trim();
+                        annotations.push(text.startsWith('@') ? text : '@' + text);
+                    }
+                }
+            }
+        }
+        return annotations;
+    },
+    extractReceiverType(node) {
+        // Extension function: user_type appears before the simple_identifier (name)
+        // e.g., fun String.format(template: String) → receiver is "String"
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (!child)
+                continue;
+            if (child.type === 'simple_identifier')
+                break; // past the name — no receiver
+            if (child.type === 'user_type' || child.type === 'nullable_type') {
+                return extractSimpleTypeName(child) ?? child.text?.trim();
+            }
+        }
+        return undefined;
+    },
+};

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

@@ -0,0 +1,5 @@
+import type { MethodExtractor, MethodExtractionConfig } from '../method-types.js';
+/**
+ * Create a MethodExtractor from a declarative config.
+ */
+export declare function createMethodExtractor(config: MethodExtractionConfig): MethodExtractor;