gitnexus 1.5.2 → 1.6.0

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

@@ -0,0 +1,277 @@
+// gitnexus/src/core/ingestion/method-extractors/configs/swift.ts
+// Verified against tree-sitter-swift 0.6.0
+import { SupportedLanguages } from '../../../../_shared/index.js';
+import { findVisibility, hasKeyword, hasModifier } from '../../field-extractors/configs/helpers.js';
+import { extractSimpleTypeName } from '../../type-extractors/shared.js';
+// ---------------------------------------------------------------------------
+// Swift helpers
+// ---------------------------------------------------------------------------
+const SWIFT_VIS = new Set([
+    'public',
+    'private',
+    'fileprivate',
+    'internal',
+    'open',
+]);
+/**
+ * Extract the method name from a function_declaration or protocol_function_declaration.
+ *
+ * In tree-sitter-swift, the name is stored in a `simple_identifier` child
+ * (not a 'name' field) on both function_declaration and protocol_function_declaration.
+ */
+function extractSwiftName(node) {
+    // Try field-based name first
+    const nameField = node.childForFieldName('name');
+    if (nameField)
+        return nameField.text;
+    // Walk named children for simple_identifier (the function name)
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child?.type === 'simple_identifier')
+            return child.text;
+    }
+    return undefined;
+}
+/**
+ * Extract the return type from a Swift function declaration.
+ *
+ * In tree-sitter-swift, the return type appears in a `type_annotation` child
+ * that follows the parameter list (after `->` in source). It may also appear
+ * as a direct type child (user_type, optional_type, tuple_type, array_type).
+ */
+function extractSwiftReturnType(node) {
+    // Look for the return type — typically the last type_annotation or a type node
+    // that appears after the parameter list.
+    // tree-sitter-swift places the return type inside a type child after '->'
+    let seenParams = false;
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (!child)
+            continue;
+        if (child.type === 'parameter') {
+            seenParams = true;
+            continue;
+        }
+        // The parameter list may be unnamed children; track when we pass ')'
+        if (seenParams || child.type === 'type_annotation') {
+            if (child.type === 'type_annotation') {
+                const inner = child.firstNamedChild;
+                if (inner)
+                    return inner.text?.trim();
+            }
+            if (child.type === 'user_type' ||
+                child.type === 'optional_type' ||
+                child.type === 'tuple_type' ||
+                child.type === 'array_type' ||
+                child.type === 'dictionary_type' ||
+                child.type === 'function_type') {
+                return child.text?.trim();
+            }
+        }
+    }
+    // Fallback: scan all children (named + unnamed) for '->' then grab the next named child
+    let seenArrow = false;
+    for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (!child)
+            continue;
+        if (!child.isNamed && child.text.trim() === '->') {
+            seenArrow = true;
+            continue;
+        }
+        if (seenArrow && child.isNamed) {
+            return child.text?.trim();
+        }
+    }
+    return undefined;
+}
+/**
+ * Extract parameters from a Swift function declaration.
+ *
+ * In tree-sitter-swift, parameters are `parameter` named children directly on
+ * the function_declaration node. Each parameter has:
+ *   - An external name (label) and/or internal name as simple_identifier children
+ *   - A type_annotation child containing the type
+ *   - An optional default value after '='
+ *   - A possible `...` for variadic parameters
+ */
+function extractSwiftParameters(node) {
+    const params = [];
+    // In tree-sitter-swift 0.6.0, parameters are direct children of function_declaration.
+    // Default value tokens ('=', literal) are siblings of the parameter node at the
+    // function_declaration level, not children of the parameter node.
+    for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (!child?.isNamed || child.type !== 'parameter')
+            continue;
+        // Extract parameter name — the last simple_identifier is the internal name
+        let paramName;
+        for (let j = 0; j < child.namedChildCount; j++) {
+            const part = child.namedChild(j);
+            if (part?.type === 'simple_identifier') {
+                paramName = part.text;
+            }
+        }
+        if (!paramName)
+            continue;
+        // Extract type — tree-sitter-swift uses user_type (not type_annotation)
+        let typeName = null;
+        let rawTypeName = null;
+        for (let j = 0; j < child.namedChildCount; j++) {
+            const part = child.namedChild(j);
+            if (part?.type === 'user_type' || part?.type === 'type_annotation') {
+                rawTypeName = part.text?.trim() ?? null;
+                const inner = part.firstNamedChild;
+                if (inner) {
+                    typeName = extractSimpleTypeName(inner) ?? inner.text?.trim() ?? null;
+                }
+                else {
+                    typeName = rawTypeName;
+                }
+                break;
+            }
+            // Handle built-in types (array_type, dictionary_type, optional_type, tuple_type)
+            if (part?.type.endsWith('_type') && part.type !== 'simple_identifier') {
+                rawTypeName = part.text?.trim() ?? null;
+                typeName = extractSimpleTypeName(part) ?? rawTypeName;
+                break;
+            }
+        }
+        // Check for default value: '=' token appears as a sibling after the parameter node
+        let isOptional = false;
+        const nextSibling = node.child(i + 1);
+        if (nextSibling && !nextSibling.isNamed && nextSibling.text.trim() === '=') {
+            isOptional = true;
+        }
+        // Check for variadic: '...' token among parameter children
+        let isVariadic = false;
+        for (let j = 0; j < child.childCount; j++) {
+            const c = child.child(j);
+            if (c && c.text.trim() === '...') {
+                isVariadic = true;
+                break;
+            }
+        }
+        params.push({
+            name: paramName,
+            type: typeName,
+            rawType: rawTypeName,
+            isOptional,
+            isVariadic,
+        });
+    }
+    return params;
+}
+/**
+ * Check if a method is inside a protocol.
+ *
+ * A protocol_function_declaration is always abstract. For function_declaration
+ * inside a protocol_body (if it appears there), it's also abstract when it has
+ * no body.
+ */
+function isSwiftAbstract(node, ownerNode) {
+    // protocol_function_declaration nodes are inherently abstract
+    if (node.type === 'protocol_function_declaration')
+        return true;
+    // function_declaration inside a protocol is abstract if it has no body
+    if (ownerNode.type === 'protocol_declaration') {
+        const body = node.childForFieldName('body');
+        if (!body) {
+            // Also check for function_body named child
+            for (let i = 0; i < node.namedChildCount; i++) {
+                const child = node.namedChild(i);
+                if (child?.type === 'function_body')
+                    return false;
+            }
+            return true;
+        }
+        return false;
+    }
+    return false;
+}
+/**
+ * Collect attribute nodes from a Swift function declaration.
+ *
+ * In tree-sitter-swift, attributes appear as `attribute` named children
+ * directly on the function_declaration node, or inside a `modifiers` wrapper.
+ * Each attribute node text starts with '@'.
+ */
+function extractSwiftAnnotations(node) {
+    const annotations = [];
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (!child)
+            continue;
+        if (child.type === 'attribute') {
+            const text = child.text?.trim();
+            if (text) {
+                // Normalize: strip arguments, keep just the name
+                // e.g. "@objc(myMethod)" -> "@objc", "@available(iOS 13, *)" -> "@available"
+                const match = text.match(/^@(\w+)/);
+                if (match) {
+                    annotations.push('@' + match[1]);
+                }
+                else {
+                    annotations.push(text);
+                }
+            }
+        }
+        // Also check inside modifiers wrapper
+        if (child.type === 'modifiers') {
+            for (let j = 0; j < child.namedChildCount; j++) {
+                const mod = child.namedChild(j);
+                if (mod?.type === 'attribute') {
+                    const text = mod.text?.trim();
+                    if (text) {
+                        const match = text.match(/^@(\w+)/);
+                        if (match) {
+                            annotations.push('@' + match[1]);
+                        }
+                        else {
+                            annotations.push(text);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return annotations;
+}
+// ---------------------------------------------------------------------------
+// Swift config
+// ---------------------------------------------------------------------------
+export const swiftMethodConfig = {
+    language: SupportedLanguages.Swift,
+    // tree-sitter-swift 0.6.0 may use class_declaration for classes, structs, enums, extensions,
+    // and actors — but this cannot be verified until the grammar installs on Node 22+.
+    // TODO: Verify struct_declaration, enum_declaration, extension_declaration, actor_declaration
+    // node types once tree-sitter-swift loads on Node 22, and add them here if they are distinct.
+    // protocol_declaration is a separate, confirmed node type.
+    typeDeclarationNodes: ['class_declaration', 'protocol_declaration'],
+    // function_declaration for class/struct methods, protocol_function_declaration for protocol methods
+    methodNodeTypes: ['function_declaration', 'protocol_function_declaration'],
+    bodyNodeTypes: ['class_body', 'protocol_body'],
+    extractName: extractSwiftName,
+    extractReturnType: extractSwiftReturnType,
+    extractParameters: extractSwiftParameters,
+    extractVisibility(node) {
+        return findVisibility(node, SWIFT_VIS, 'internal', 'modifiers');
+    },
+    isStatic(node) {
+        return (hasKeyword(node, 'static') ||
+            hasKeyword(node, 'class') ||
+            hasModifier(node, 'modifiers', 'static') ||
+            hasModifier(node, 'modifiers', 'class'));
+    },
+    isAbstract: isSwiftAbstract,
+    isFinal(node) {
+        return hasKeyword(node, 'final') || hasModifier(node, 'modifiers', 'final');
+    },
+    isAsync(node) {
+        return hasKeyword(node, 'async') || hasModifier(node, 'modifiers', 'async');
+    },
+    isOverride(node) {
+        return hasKeyword(node, 'override') || hasModifier(node, 'modifiers', 'override');
+    },
+    extractAnnotations: extractSwiftAnnotations,
+};

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

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

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

@@ -0,0 +1,338 @@
+// gitnexus/src/core/ingestion/method-extractors/configs/typescript-javascript.ts
+// Verified against tree-sitter-typescript ^0.23.2, tree-sitter-javascript ^0.23.0
+import { SupportedLanguages } from '../../../../_shared/index.js';
+import { hasKeyword } from '../../field-extractors/configs/helpers.js';
+import { extractSimpleTypeName } from '../../type-extractors/shared.js';
+// ---------------------------------------------------------------------------
+// TS/JS helpers
+// ---------------------------------------------------------------------------
+const VISIBILITY_KEYWORDS = new Set(['public', 'private', 'protected']);
+/**
+ * Extract parameters from formal_parameters.
+ *
+ * Handles both TS node types (required_parameter, optional_parameter, rest_parameter)
+ * and JS node types (identifier, assignment_pattern, rest_pattern), plus destructured
+ * parameters (object_pattern, array_pattern) in both grammars.
+ */
+function extractTsJsParameters(node) {
+    const paramList = node.childForFieldName('parameters');
+    if (!paramList)
+        return [];
+    const params = [];
+    for (let i = 0; i < paramList.namedChildCount; i++) {
+        const param = paramList.namedChild(i);
+        if (!param)
+            continue;
+        switch (param.type) {
+            case 'required_parameter': {
+                const patternNode = param.childForFieldName('pattern');
+                if (!patternNode)
+                    break;
+                // Skip TS `this` parameter — it's a compile-time type constraint, not a real param
+                if (patternNode.type === 'this')
+                    break;
+                // Rest parameter: pattern is a rest_pattern (...args) — extract inner identifier
+                const isRest = patternNode.type === 'rest_pattern';
+                const nameNode = isRest ? patternNode.firstNamedChild : patternNode;
+                if (!nameNode)
+                    break;
+                // type field is a type_annotation — unwrap to get the inner type node
+                const typeAnnotation = param.childForFieldName('type');
+                const typeNode = typeAnnotation?.firstNamedChild;
+                // Default value: presence of a 'value' field means isOptional
+                const hasDefault = !!param.childForFieldName('value');
+                params.push({
+                    name: nameNode.text,
+                    type: typeNode
+                        ? (extractSimpleTypeName(typeNode) ?? typeNode.text?.trim() ?? null)
+                        : null,
+                    rawType: typeNode?.text?.trim() ?? null,
+                    isOptional: hasDefault,
+                    isVariadic: isRest,
+                });
+                break;
+            }
+            case 'optional_parameter': {
+                const nameNode = param.childForFieldName('pattern');
+                if (!nameNode)
+                    break;
+                const typeAnnotation = param.childForFieldName('type');
+                const typeNode = typeAnnotation?.firstNamedChild;
+                params.push({
+                    name: nameNode.text,
+                    type: typeNode
+                        ? (extractSimpleTypeName(typeNode) ?? typeNode.text?.trim() ?? null)
+                        : null,
+                    rawType: typeNode?.text?.trim() ?? null,
+                    isOptional: true,
+                    isVariadic: false,
+                });
+                break;
+            }
+            case 'rest_parameter': {
+                const nameNode = param.childForFieldName('pattern');
+                if (!nameNode)
+                    break;
+                const typeAnnotation = param.childForFieldName('type');
+                const typeNode = typeAnnotation?.firstNamedChild;
+                params.push({
+                    name: nameNode.text,
+                    type: typeNode
+                        ? (extractSimpleTypeName(typeNode) ?? typeNode.text?.trim() ?? null)
+                        : null,
+                    rawType: typeNode?.text?.trim() ?? null,
+                    isOptional: false,
+                    isVariadic: true,
+                });
+                break;
+            }
+            case 'identifier': {
+                // JS: bare parameter name, no type info
+                params.push({
+                    name: param.text,
+                    type: null,
+                    rawType: null,
+                    isOptional: false,
+                    isVariadic: false,
+                });
+                break;
+            }
+            case 'assignment_pattern': {
+                // JS: param = defaultValue — the left side is the name, isOptional = true
+                const left = param.childForFieldName('left');
+                if (left) {
+                    params.push({
+                        name: left.text,
+                        type: null,
+                        rawType: null,
+                        isOptional: true,
+                        isVariadic: false,
+                    });
+                }
+                break;
+            }
+            case 'rest_pattern': {
+                // JS: ...args
+                const inner = param.firstNamedChild;
+                if (inner) {
+                    params.push({
+                        name: inner.text,
+                        type: null,
+                        rawType: null,
+                        isOptional: false,
+                        isVariadic: true,
+                    });
+                }
+                break;
+            }
+            case 'object_pattern':
+            case 'array_pattern': {
+                // Destructured parameter — use full text as name
+                params.push({
+                    name: param.text,
+                    type: null,
+                    rawType: null,
+                    isOptional: false,
+                    isVariadic: false,
+                });
+                break;
+            }
+        }
+    }
+    return params;
+}
+/** Regex to extract @returns or @return from JSDoc comments: `@returns {Type}` */
+const JSDOC_RETURN_RE = /@returns?\s*\{([^}]+)\}/;
+/**
+ * Minimal sanitization for JSDoc return types — preserves generic wrappers
+ * (e.g. `Promise<User>`) so that extractReturnTypeName in call-processor
+ * can apply WRAPPER_GENERICS unwrapping. Only strips JSDoc-specific syntax markers.
+ */
+function sanitizeJsDocReturnType(raw) {
+    let type = raw.trim();
+    // Strip JSDoc nullable/non-nullable prefixes: ?User → User, !User → User
+    if (type.startsWith('?') || type.startsWith('!'))
+        type = type.slice(1);
+    // Strip module: prefix — module:models.User → models.User
+    if (type.startsWith('module:'))
+        type = type.slice(7);
+    // Reject unions (ambiguous)
+    if (type.includes('|'))
+        return undefined;
+    if (!type)
+        return undefined;
+    return type;
+}
+/**
+ * Walk backwards through preceding siblings looking for a JSDoc comment containing
+ * `@returns {Type}` or `@return {Type}`. Stops at the first non-comment named node
+ * (excluding decorators, which precede methods in TS/JS).
+ */
+function extractJsDocReturnType(node) {
+    let sibling = node.previousSibling;
+    while (sibling) {
+        if (sibling.type === 'comment') {
+            const match = JSDOC_RETURN_RE.exec(sibling.text);
+            if (match)
+                return sanitizeJsDocReturnType(match[1]);
+        }
+        else if (sibling.isNamed && sibling.type !== 'decorator')
+            break;
+        sibling = sibling.previousSibling;
+    }
+    return undefined;
+}
+/**
+ * Extract return type from return_type field, unwrapping type_annotation.
+ * Falls back to JSDoc `@returns {Type}` when the AST has no return type annotation.
+ *
+ * tree-sitter-typescript uses `return_type` as the field name (not `type` like JVM).
+ * The return_type field points to a type_annotation node that must be unwrapped.
+ */
+function extractTsJsReturnType(node) {
+    const returnType = node.childForFieldName('return_type');
+    if (returnType) {
+        if (returnType.type === 'type_annotation') {
+            const inner = returnType.firstNamedChild;
+            if (inner)
+                return inner.text?.trim();
+        }
+        return returnType.text?.trim();
+    }
+    // AST has no return type annotation — try JSDoc fallback
+    return extractJsDocReturnType(node);
+}
+/**
+ * Extract visibility from accessibility_modifier or #private name.
+ *
+ * tree-sitter-typescript emits accessibility_modifier as a named child of method nodes
+ * (not as a modifiers wrapper like JVM). Pass 1 scans for that child; pass 2 checks for
+ * ES2022 private_property_identifier (#name). Default: public.
+ */
+function extractTsJsVisibility(node) {
+    // Pass 1: check for accessibility_modifier named child (TS-specific)
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child && child.type === 'accessibility_modifier') {
+            const t = child.text.trim();
+            if (VISIBILITY_KEYWORDS.has(t))
+                return t;
+        }
+    }
+    // Pass 2: ES2022 private methods (#name) are inherently private
+    const nameNode = node.childForFieldName('name');
+    if (nameNode && nameNode.type === 'private_property_identifier')
+        return 'private';
+    // No accessibility_modifier found — default to public.
+    // Note: tree-sitter-typescript does not wrap modifiers in a 'modifiers' node
+    // (unlike JVM), so there is no wrapper to scan.
+    return 'public';
+}
+/**
+ * Extract decorator names, prefixed with '@'.
+ *
+ * In tree-sitter-typescript, decorators are **siblings** of the method_definition in the
+ * class_body — they are NOT children of the method node. We find them by walking backwards
+ * from the method node through its preceding siblings in the parent body.
+ */
+function extractTsJsDecorators(node) {
+    const decorators = [];
+    // Walk backwards via previousNamedSibling to collect consecutive decorator siblings.
+    // This avoids the O(N) index-finding scan through the parent's children.
+    let sibling = node.previousNamedSibling;
+    while (sibling && sibling.type === 'decorator') {
+        const name = extractDecoratorName(sibling);
+        if (name)
+            decorators.unshift(name);
+        sibling = sibling.previousNamedSibling;
+    }
+    return decorators;
+}
+function extractDecoratorName(decorator) {
+    const expr = decorator.firstNamedChild;
+    if (!expr)
+        return undefined;
+    if (expr.type === 'call_expression') {
+        const fn = expr.childForFieldName('function');
+        return fn ? '@' + fn.text : undefined;
+    }
+    if (expr.type === 'identifier')
+        return '@' + expr.text;
+    if (expr.type === 'member_expression')
+        return '@' + expr.text;
+    return undefined;
+}
+// ---------------------------------------------------------------------------
+// Config
+// ---------------------------------------------------------------------------
+// TS and JS share the same config base. TS-only node types (abstract_class_declaration,
+// interface_declaration, abstract_method_signature, method_signature, interface_body) are
+// included because the JS grammar never produces these nodes — they are harmless no-ops.
+// This mirrors the field extractor's typescript-javascript.ts shared pattern.
+//
+// Note: TS and JS share a method config but NOT a field extractor because the TS field
+// extractor needs a hand-written class for type_alias_declaration object literals and
+// nested type discovery. Methods have no such requirement.
+const shared = {
+    typeDeclarationNodes: [
+        'class_declaration',
+        'abstract_class_declaration',
+        'interface_declaration',
+    ],
+    // Note: TS constructors are method_definition nodes (name = 'constructor'), so no
+    // explicit constructor_declaration entry is needed (unlike JVM/C# configs).
+    // Known gaps:
+    //   - call_signature and construct_signature (e.g., interface Fn { (x: string): void; })
+    //     are not extracted — they have no name field and are uncommon in practice.
+    //   - class_expression (const Foo = class { ... }) — methods inside class expressions
+    //     are not discovered because class_expression is not in typeDeclarationNodes.
+    //   - declare module / declare global augmentations — methods inside ambient_module_declaration
+    //     wrappers are not surfaced because the top-level walker doesn't descend into them.
+    methodNodeTypes: [
+        'method_definition',
+        'method_signature',
+        'abstract_method_signature',
+        'function_declaration',
+        'generator_function_declaration',
+        'function_signature',
+    ],
+    bodyNodeTypes: ['class_body', 'interface_body'],
+    extractName(node) {
+        const nameNode = node.childForFieldName('name');
+        return nameNode?.text;
+    },
+    extractReturnType: extractTsJsReturnType,
+    extractParameters: extractTsJsParameters,
+    extractVisibility: extractTsJsVisibility,
+    isStatic(node) {
+        return hasKeyword(node, 'static');
+    },
+    isAbstract(node, ownerNode) {
+        // Explicit abstract keyword on the method itself
+        if (hasKeyword(node, 'abstract'))
+            return true;
+        // Interface methods are implicitly abstract — TS interfaces never have method bodies
+        // (unlike Java default methods), so no !body check needed
+        if (ownerNode.type === 'interface_declaration')
+            return true;
+        return false;
+    },
+    isFinal(_node) {
+        return false; // TS/JS has no final/sealed methods
+    },
+    extractAnnotations: extractTsJsDecorators,
+    isAsync(node) {
+        return hasKeyword(node, 'async');
+    },
+    isOverride(node) {
+        return hasKeyword(node, 'override');
+    },
+};
+export const typescriptMethodConfig = {
+    ...shared,
+    language: SupportedLanguages.TypeScript,
+};
+export const javascriptMethodConfig = {
+    ...shared,
+    language: SupportedLanguages.JavaScript,
+};