gitnexus 1.5.2 → 1.6.0

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

@@ -0,0 +1,285 @@
+// gitnexus/src/core/ingestion/method-extractors/configs/ruby.ts
+// Verified against tree-sitter-ruby 0.23.1
+import { SupportedLanguages } from '../../../../_shared/index.js';
+// ---------------------------------------------------------------------------
+// Ruby helpers
+// ---------------------------------------------------------------------------
+const VISIBILITY_MODIFIERS = new Set(['private', 'protected', 'public']);
+/** Regex to extract YARD `@return [Type]` annotations from comments. */
+const YARD_RETURN_RE = /@return\s+\[([^\]]+)\]/;
+/**
+ * Extract the simple type name from a YARD type string.
+ * Handles qualified types ("Models::User" -> "User"), generics ("Array<User>"
+ * -> "Array"), nullable ("String, nil" -> "String"), and rejects ambiguous
+ * unions ("String, Integer" -> undefined).
+ */
+function extractYardTypeName(yardType) {
+    const trimmed = yardType.trim();
+    // Bracket-balanced split on commas to handle generics like Hash<Symbol, User>
+    const parts = [];
+    let depth = 0, start = 0;
+    for (let i = 0; i < trimmed.length; i++) {
+        if (trimmed[i] === '<')
+            depth++;
+        else if (trimmed[i] === '>')
+            depth--;
+        else if (trimmed[i] === ',' && depth === 0) {
+            parts.push(trimmed.slice(start, i).trim());
+            start = i + 1;
+        }
+    }
+    parts.push(trimmed.slice(start).trim());
+    const filtered = parts.filter((p) => p !== '' && p !== 'nil');
+    if (filtered.length !== 1)
+        return undefined; // ambiguous union
+    const typePart = filtered[0];
+    // Qualified: "Models::User" -> "User"
+    const segments = typePart.split('::');
+    const last = segments[segments.length - 1];
+    // Generic: "Array<User>" -> "Array"
+    const genericMatch = last.match(/^(\w+)\s*[<{(]/);
+    if (genericMatch)
+        return genericMatch[1];
+    // Simple identifier
+    if (/^\w+$/.test(last))
+        return last;
+    return undefined;
+}
+/**
+ * Extract visibility for a Ruby method by walking backwards through the
+ * parent body_statement's named children from the method node's position.
+ *
+ * Ruby visibility modifiers (private, protected, public) appear as bare
+ * `identifier` nodes in the body_statement. The most recent modifier
+ * before the method determines its visibility. Default is public.
+ *
+ * Example AST for:
+ *   class Foo
+ *     private
+ *     def secret; end
+ *   end
+ *
+ *   body_statement
+ *     identifier "private"    ← index 0
+ *     method "def secret"     ← index 1
+ */
+function extractRubyVisibility(node) {
+    const parent = node.parent;
+    if (!parent)
+        return 'public';
+    // Find the index of this method node in the parent's named children
+    let methodIndex = -1;
+    for (let i = 0; i < parent.namedChildCount; i++) {
+        if (parent.namedChild(i) === node) {
+            methodIndex = i;
+            break;
+        }
+    }
+    if (methodIndex < 0)
+        return 'public';
+    // Walk backwards from the method node looking for a visibility modifier
+    for (let i = methodIndex - 1; i >= 0; i--) {
+        const sibling = parent.namedChild(i);
+        if (!sibling)
+            continue;
+        if (sibling.type === 'identifier' && VISIBILITY_MODIFIERS.has(sibling.text)) {
+            return sibling.text;
+        }
+        // module_function makes instance methods private
+        if (sibling.type === 'identifier' && sibling.text === 'module_function') {
+            return 'private';
+        }
+    }
+    return 'public';
+}
+/**
+ * Extract parameters from a Ruby method's method_parameters node.
+ *
+ * Handles: identifier, optional_parameter (default), splat_parameter (*args),
+ * hash_splat_parameter (**kwargs), block_parameter (&block), keyword_parameter.
+ */
+function extractRubyParameters(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 'identifier': {
+                // Plain parameter: def foo(x)
+                params.push({
+                    name: param.text,
+                    type: null,
+                    rawType: null,
+                    isOptional: false,
+                    isVariadic: false,
+                });
+                break;
+            }
+            case 'optional_parameter': {
+                // Default parameter: def foo(x = 10)
+                const nameNode = param.childForFieldName('name');
+                if (nameNode) {
+                    params.push({
+                        name: nameNode.text,
+                        type: null,
+                        rawType: null,
+                        isOptional: true,
+                        isVariadic: false,
+                    });
+                }
+                break;
+            }
+            case 'splat_parameter': {
+                // Splat: def foo(*args)
+                const nameNode = param.childForFieldName('name');
+                if (nameNode) {
+                    params.push({
+                        name: nameNode.text,
+                        type: null,
+                        rawType: null,
+                        isOptional: false,
+                        isVariadic: true,
+                    });
+                }
+                break;
+            }
+            case 'hash_splat_parameter': {
+                // Double splat: def foo(**kwargs)
+                const nameNode = param.childForFieldName('name');
+                if (nameNode) {
+                    params.push({
+                        name: nameNode.text,
+                        type: null,
+                        rawType: null,
+                        isOptional: false,
+                        isVariadic: true,
+                    });
+                }
+                break;
+            }
+            case 'block_parameter': {
+                // Block: def foo(&block)
+                const nameNode = param.childForFieldName('name');
+                if (nameNode) {
+                    params.push({
+                        name: nameNode.text,
+                        type: null,
+                        rawType: null,
+                        isOptional: false,
+                        isVariadic: false,
+                    });
+                }
+                break;
+            }
+            case 'keyword_parameter': {
+                // Keyword: def foo(name:) or def foo(name: "default")
+                const nameNode = param.childForFieldName('name');
+                const valueNode = param.childForFieldName('value');
+                if (nameNode) {
+                    params.push({
+                        name: nameNode.text,
+                        type: null,
+                        rawType: null,
+                        isOptional: !!valueNode,
+                        isVariadic: false,
+                    });
+                }
+                break;
+            }
+        }
+    }
+    return params;
+}
+// ---------------------------------------------------------------------------
+// Config
+// ---------------------------------------------------------------------------
+export const rubyMethodConfig = {
+    language: SupportedLanguages.Ruby,
+    typeDeclarationNodes: ['class', 'module', 'singleton_class'],
+    methodNodeTypes: ['method', 'singleton_method'],
+    bodyNodeTypes: ['body_statement'],
+    extractOwnerName(node) {
+        // singleton_class (class << self) inherits the enclosing class/module name
+        if (node.type === 'singleton_class') {
+            let ancestor = node.parent;
+            while (ancestor) {
+                if (ancestor.type === 'class' || ancestor.type === 'module') {
+                    const nameNode = ancestor.childForFieldName('name');
+                    return nameNode?.text;
+                }
+                ancestor = ancestor.parent;
+            }
+            return undefined;
+        }
+        return undefined; // use default resolution for class/module
+    },
+    extractName(node) {
+        const nameNode = node.childForFieldName('name');
+        return nameNode?.text;
+    },
+    extractReturnType(node) {
+        // Walk backwards through preceding siblings looking for YARD @return [Type].
+        // Try direct siblings first, then fall back to parent (body_statement) siblings
+        // for class methods where the comment may be a sibling of the body_statement.
+        const search = (startNode) => {
+            let sibling = startNode.previousSibling;
+            while (sibling) {
+                if (sibling.type === 'comment') {
+                    const match = YARD_RETURN_RE.exec(sibling.text);
+                    if (match)
+                        return extractYardTypeName(match[1]);
+                }
+                else if (sibling.isNamed) {
+                    break;
+                }
+                sibling = sibling.previousSibling;
+            }
+            return undefined;
+        };
+        const result = search(node);
+        if (result)
+            return result;
+        if (node.parent?.type === 'body_statement') {
+            return search(node.parent);
+        }
+        return undefined;
+    },
+    extractParameters: extractRubyParameters,
+    extractVisibility: extractRubyVisibility,
+    isStatic(node) {
+        if (node.type === 'singleton_method')
+            return true;
+        // module_function makes following methods callable at module level (static)
+        const parent = node.parent;
+        if (!parent)
+            return false;
+        let methodIndex = -1;
+        for (let i = 0; i < parent.namedChildCount; i++) {
+            if (parent.namedChild(i) === node) {
+                methodIndex = i;
+                break;
+            }
+        }
+        for (let i = methodIndex - 1; i >= 0; i--) {
+            const sibling = parent.namedChild(i);
+            if (!sibling)
+                continue;
+            if (sibling.type === 'identifier' && sibling.text === 'module_function')
+                return true;
+            // Other visibility modifiers override module_function
+            if (sibling.type === 'identifier' && VISIBILITY_MODIFIERS.has(sibling.text))
+                return false;
+        }
+        return false;
+    },
+    isAbstract(_node, _ownerNode) {
+        return false; // Ruby has no abstract methods
+    },
+    isFinal(_node) {
+        return false; // Ruby has no final methods
+    },
+};

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

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

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

@@ -0,0 +1,195 @@
+// gitnexus/src/core/ingestion/method-extractors/configs/rust.ts
+// Verified against tree-sitter-rust 0.23.1
+import { SupportedLanguages } from '../../../../_shared/index.js';
+import { extractSimpleTypeName } from '../../type-extractors/shared.js';
+// ---------------------------------------------------------------------------
+// Rust helpers
+// ---------------------------------------------------------------------------
+/**
+ * Extract method name from function_item or function_signature_item.
+ * Both use a `name` field containing an identifier.
+ */
+function extractRustMethodName(node) {
+    const nameNode = node.childForFieldName('name');
+    return nameNode?.text;
+}
+/**
+ * Extract return type from the `return_type` field.
+ * tree-sitter-rust puts the return type (after `->`) as the `return_type` field.
+ */
+function extractRustReturnType(node) {
+    const typeNode = node.childForFieldName('return_type');
+    if (!typeNode)
+        return undefined;
+    return typeNode.text?.trim();
+}
+/**
+ * Extract parameters, skipping the self_parameter (handled by extractReceiverType).
+ *
+ * Rust parameters use `pattern` and `type` fields:
+ *   parameter { pattern: identifier, type: primitive_type }
+ */
+function extractRustParameters(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;
+        // Skip self_parameter — it is the receiver, not a regular parameter
+        if (param.type === 'self_parameter')
+            continue;
+        if (param.type === 'parameter') {
+            const patternNode = param.childForFieldName('pattern');
+            const typeNode = param.childForFieldName('type');
+            params.push({
+                name: patternNode?.text ?? '?',
+                type: typeNode ? (extractSimpleTypeName(typeNode) ?? typeNode.text?.trim() ?? null) : null,
+                rawType: typeNode?.text?.trim() ?? null,
+                isOptional: false,
+                isVariadic: false,
+            });
+        }
+    }
+    return params;
+}
+/**
+ * Detect visibility from visibility_modifier named child.
+ * `pub`, `pub(crate)`, `pub(super)`, `pub(in path)` → public.
+ * Absence → private (Rust default).
+ */
+function extractRustVisibility(node) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child?.type === 'visibility_modifier')
+            return 'public';
+    }
+    return 'private';
+}
+/**
+ * Detect receiver type from the first parameter if it is a self_parameter.
+ *
+ * Variants:
+ *   - `self`       → "self"
+ *   - `&self`      → "&self"
+ *   - `&mut self`  → "&mut self"
+ *   - `mut self`   → "mut self"
+ *   - `self: Box<Self>` → "Box<Self>" (explicit self type)
+ */
+function extractRustReceiverType(node) {
+    const paramList = node.childForFieldName('parameters');
+    if (!paramList)
+        return undefined;
+    const first = paramList.namedChild(0);
+    if (!first || first.type !== 'self_parameter')
+        return undefined;
+    return first.text;
+}
+/**
+ * Check whether a function_item has the `async` keyword.
+ * tree-sitter-rust wraps it in a `function_modifiers` named child.
+ */
+function isRustAsync(node) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child?.type === 'function_modifiers' && child.text.includes('async'))
+            return true;
+    }
+    return false;
+}
+/**
+ * Extract attributes from preceding sibling attribute_item nodes.
+ *
+ * In tree-sitter-rust, `#[inline]` is an `attribute_item` sibling that precedes
+ * the function_item in the declaration_list, not a child of the function_item.
+ */
+function extractRustAnnotations(node) {
+    const annotations = [];
+    let sibling = node.previousNamedSibling;
+    while (sibling) {
+        if (sibling.type === 'attribute_item') {
+            annotations.unshift(sibling.text);
+        }
+        else {
+            // Stop at the first non-attribute sibling — attributes are contiguous
+            break;
+        }
+        sibling = sibling.previousNamedSibling;
+    }
+    return annotations;
+}
+// ---------------------------------------------------------------------------
+// Rust config
+// ---------------------------------------------------------------------------
+// Rust methods live inside `impl` blocks (concrete implementations) or
+// `trait` blocks (trait definitions with required/default methods).
+//
+// `impl_item` body contains `function_item` nodes for concrete methods.
+// `trait_item` body contains `function_item` (default methods) and
+// `function_signature_item` (required/abstract methods without a body).
+//
+// ownerName resolution: `impl_item` has no `name` field — the generic
+// extractor falls back to the first `type_identifier` child, which is the
+// implementing type (e.g. `impl MyStruct { ... }` → "MyStruct").
+// `trait_item` uses the standard `name` field.
+//
+// Known gaps:
+//   - Macro-generated methods (e.g. derive) are not visible in the AST.
+//   - Unsafe methods are not distinguished (no isUnsafe field in schema).
+export const rustMethodConfig = {
+    language: SupportedLanguages.Rust,
+    typeDeclarationNodes: ['impl_item', 'trait_item'],
+    methodNodeTypes: ['function_item', 'function_signature_item'],
+    bodyNodeTypes: ['declaration_list'],
+    // For `impl Trait for Struct`, resolve owner to the concrete Struct (after `for`).
+    // For plain `impl Struct`, resolve to Struct (first type_identifier).
+    // For `trait Foo`, let the default name-field resolution handle it.
+    extractOwnerName(node) {
+        if (node.type !== 'impl_item')
+            return undefined;
+        const children = node.children ?? [];
+        const forIdx = children.findIndex((c) => c.text === 'for');
+        if (forIdx !== -1) {
+            // impl Trait for Struct — pick the type after `for`
+            const typeNode = children
+                .slice(forIdx + 1)
+                .find((c) => c.type === 'type_identifier' || c.type === 'scoped_type_identifier');
+            if (typeNode)
+                return typeNode.text;
+        }
+        // Plain `impl Struct` — pick the first type_identifier
+        const first = children.find((c) => c.type === 'type_identifier');
+        return first?.text;
+    },
+    extractName: extractRustMethodName,
+    extractReturnType: extractRustReturnType,
+    extractParameters: extractRustParameters,
+    extractVisibility: extractRustVisibility,
+    isStatic(node) {
+        // A Rust method is an "associated function" (static) if it lacks a
+        // self_parameter as first parameter.
+        const paramList = node.childForFieldName('parameters');
+        if (!paramList)
+            return true;
+        const first = paramList.namedChild(0);
+        return !first || first.type !== 'self_parameter';
+    },
+    isAbstract(node, ownerNode) {
+        // Only trait methods without a body (function_signature_item) are abstract.
+        // function_signature_item never has a body field.
+        if (ownerNode.type === 'trait_item' && node.type === 'function_signature_item') {
+            return true;
+        }
+        return false;
+    },
+    isFinal() {
+        // Rust has no `final` concept — all methods are effectively sealed
+        // (traits cannot be "overridden" the way Java methods can).
+        return false;
+    },
+    extractAnnotations: extractRustAnnotations,
+    extractReceiverType: extractRustReceiverType,
+    isAsync: isRustAsync,
+};

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

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