arceus-s 1.6.4

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

@@ -0,0 +1,309 @@
+// arc/src/core/ingestion/method-extractors/configs/python.ts
+// Verified against tree-sitter-python 0.23.4
+import { SupportedLanguages } from '../../../../_shared/index.js';
+import { hasKeyword } from '../../field-extractors/configs/helpers.js';
+import { extractSimpleTypeName } from '../../type-extractors/shared.js';
+// ---------------------------------------------------------------------------
+// Python helpers
+// ---------------------------------------------------------------------------
+/** Names that represent the instance/class receiver — not real parameters. */
+const SELF_NAMES = new Set(['self', 'cls']);
+/**
+ * Unwrap a decorated_definition to its inner function_definition.
+ *
+ * tree-sitter-python wraps decorated functions/methods in a `decorated_definition`
+ * node that contains the decorators as children followed by the function_definition.
+ * This is different from TS/JS where decorators are siblings.
+ */
+function unwrapDecorated(node) {
+    if (node.type === 'decorated_definition') {
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child && child.type === 'function_definition')
+                return child;
+        }
+    }
+    return node;
+}
+/**
+ * Collect decorator names from a decorated_definition wrapper.
+ *
+ * Returns decorator names prefixed with '@'. If the node is a plain
+ * function_definition (no decorators), check if its parent is a
+ * decorated_definition and collect from there.
+ */
+function collectDecorators(node) {
+    let wrapper = null;
+    if (node.type === 'decorated_definition') {
+        wrapper = node;
+    }
+    else if (node.parent?.type === 'decorated_definition') {
+        wrapper = node.parent;
+    }
+    if (!wrapper)
+        return [];
+    const decorators = [];
+    for (let i = 0; i < wrapper.namedChildCount; i++) {
+        const child = wrapper.namedChild(i);
+        if (child && child.type === 'decorator') {
+            decorators.push(child);
+        }
+    }
+    return decorators;
+}
+function extractDecoratorName(decorator) {
+    // decorator > identifier (simple)
+    // decorator > call > identifier (call-style, e.g. @lru_cache())
+    // decorator > attribute (dotted, e.g. @abc.abstractmethod)
+    const expr = decorator.firstNamedChild;
+    if (!expr)
+        return undefined;
+    if (expr.type === 'identifier')
+        return '@' + expr.text;
+    if (expr.type === 'attribute')
+        return '@' + expr.text;
+    if (expr.type === 'call') {
+        const fn = expr.childForFieldName('function');
+        return fn ? '@' + fn.text : undefined;
+    }
+    return undefined;
+}
+function hasDecorator(node, name) {
+    const decorators = collectDecorators(node);
+    for (const dec of decorators) {
+        const decName = extractDecoratorName(dec);
+        if (decName === '@' + name || decName?.endsWith('.' + name))
+            return true;
+    }
+    return false;
+}
+/**
+ * Extract parameters from a Python function_definition.
+ *
+ * Handles: identifier, default_parameter, typed_parameter, typed_default_parameter,
+ * list_splat_pattern (*args), dictionary_splat_pattern (**kwargs), and typed variants.
+ * Skips `self` and `cls` first parameters.
+ */
+function extractPythonParameters(node) {
+    const funcNode = unwrapDecorated(node);
+    const paramList = funcNode.childForFieldName('parameters');
+    if (!paramList)
+        return [];
+    const params = [];
+    let isFirst = true;
+    for (let i = 0; i < paramList.namedChildCount; i++) {
+        const param = paramList.namedChild(i);
+        if (!param)
+            continue;
+        switch (param.type) {
+            case 'identifier': {
+                // Bare parameter: `self`, `cls`, or untyped `x`
+                if (isFirst && SELF_NAMES.has(param.text)) {
+                    isFirst = false;
+                    continue;
+                }
+                isFirst = false;
+                params.push({
+                    name: param.text,
+                    type: null,
+                    rawType: null,
+                    isOptional: false,
+                    isVariadic: false,
+                });
+                break;
+            }
+            case 'default_parameter': {
+                // `x = value` — untyped with default
+                isFirst = false;
+                const nameNode = param.childForFieldName('name');
+                if (nameNode) {
+                    params.push({
+                        name: nameNode.text,
+                        type: null,
+                        rawType: null,
+                        isOptional: true,
+                        isVariadic: false,
+                    });
+                }
+                break;
+            }
+            case 'typed_parameter': {
+                // `x: int` or `*args: str` or `**kwargs: int`
+                // The first named child can be identifier, list_splat_pattern, or dictionary_splat_pattern
+                const inner = param.firstNamedChild;
+                if (!inner)
+                    break;
+                if (isFirst && inner.type === 'identifier' && SELF_NAMES.has(inner.text)) {
+                    isFirst = false;
+                    continue;
+                }
+                isFirst = false;
+                const typeNode = param.childForFieldName('type');
+                const typeText = typeNode
+                    ? (extractSimpleTypeName(typeNode) ?? typeNode.text?.trim() ?? null)
+                    : null;
+                const rawTypeText = typeNode?.text?.trim() ?? null;
+                if (inner.type === 'list_splat_pattern') {
+                    const nameId = inner.firstNamedChild;
+                    if (nameId) {
+                        params.push({
+                            name: nameId.text,
+                            type: typeText,
+                            rawType: rawTypeText,
+                            isOptional: false,
+                            isVariadic: true,
+                        });
+                    }
+                }
+                else if (inner.type === 'dictionary_splat_pattern') {
+                    const nameId = inner.firstNamedChild;
+                    if (nameId) {
+                        params.push({
+                            name: nameId.text,
+                            type: typeText,
+                            rawType: rawTypeText,
+                            isOptional: false,
+                            isVariadic: true,
+                        });
+                    }
+                }
+                else {
+                    params.push({
+                        name: inner.text,
+                        type: typeText,
+                        rawType: rawTypeText,
+                        isOptional: false,
+                        isVariadic: false,
+                    });
+                }
+                break;
+            }
+            case 'typed_default_parameter': {
+                // `x: int = 5` — typed with default
+                isFirst = false;
+                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)
+                            : null,
+                        rawType: typeNode?.text?.trim() ?? null,
+                        isOptional: true,
+                        isVariadic: false,
+                    });
+                }
+                break;
+            }
+            case 'list_splat_pattern': {
+                // `*args` (untyped)
+                isFirst = false;
+                const nameId = param.firstNamedChild;
+                if (nameId) {
+                    params.push({
+                        name: nameId.text,
+                        type: null,
+                        rawType: null,
+                        isOptional: false,
+                        isVariadic: true,
+                    });
+                }
+                break;
+            }
+            case 'dictionary_splat_pattern': {
+                // `**kwargs` (untyped)
+                isFirst = false;
+                const nameId = param.firstNamedChild;
+                if (nameId) {
+                    params.push({
+                        name: nameId.text,
+                        type: null,
+                        rawType: null,
+                        isOptional: false,
+                        isVariadic: true,
+                    });
+                }
+                break;
+            }
+            default:
+                isFirst = false;
+                break;
+        }
+    }
+    return params;
+}
+/**
+ * Extract return type from the `return_type` field.
+ *
+ * tree-sitter-python uses a `type` field on function_definition for the return
+ * type annotation (e.g. `-> str`). The field contains a type node.
+ */
+function extractPythonReturnType(node) {
+    const funcNode = unwrapDecorated(node);
+    const returnType = funcNode.childForFieldName('return_type');
+    if (!returnType)
+        return undefined;
+    // Use .text to preserve full generic types (e.g. list[User], Dict[str, User])
+    // that the call resolver needs for for-loop iterable and return-type inference.
+    return returnType.text?.trim();
+}
+/**
+ * Extract visibility based on Python name-mangling convention.
+ * `__name` (not dunder) = private, `_name` = protected, else public.
+ */
+function extractPythonVisibility(node) {
+    const funcNode = unwrapDecorated(node);
+    const nameNode = funcNode.childForFieldName('name');
+    const name = nameNode?.text;
+    if (!name)
+        return 'public';
+    if (name.startsWith('__') && !name.endsWith('__'))
+        return 'private';
+    if (name.startsWith('_') && !(name.startsWith('__') && name.endsWith('__')))
+        return 'protected';
+    return 'public';
+}
+// ---------------------------------------------------------------------------
+// Config
+// ---------------------------------------------------------------------------
+export const pythonMethodConfig = {
+    language: SupportedLanguages.Python,
+    typeDeclarationNodes: ['class_definition'],
+    // Both function_definition and decorated_definition must be listed:
+    // decorated methods appear as decorated_definition in the class body block,
+    // while undecorated methods appear as function_definition directly.
+    methodNodeTypes: ['function_definition', 'decorated_definition'],
+    bodyNodeTypes: ['block'],
+    extractName(node) {
+        const funcNode = unwrapDecorated(node);
+        const nameNode = funcNode.childForFieldName('name');
+        return nameNode?.text;
+    },
+    extractReturnType: extractPythonReturnType,
+    extractParameters: extractPythonParameters,
+    extractVisibility: extractPythonVisibility,
+    isStatic(node) {
+        return hasDecorator(node, 'staticmethod') || hasDecorator(node, 'classmethod');
+    },
+    isAbstract(node, _ownerNode) {
+        return hasDecorator(node, 'abstractmethod');
+    },
+    isFinal(_node) {
+        return false; // @typing.final (PEP 591) is captured in annotations; isFinal not modeled
+    },
+    extractAnnotations(node) {
+        const decorators = collectDecorators(node);
+        const annotations = [];
+        for (const dec of decorators) {
+            const name = extractDecoratorName(dec);
+            if (name)
+                annotations.push(name);
+        }
+        return annotations;
+    },
+    isAsync(node) {
+        const funcNode = unwrapDecorated(node);
+        return hasKeyword(funcNode, 'async');
+    },
+};

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

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

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

@@ -0,0 +1,286 @@
+// arc/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'],
+    staticOwnerTypes: new Set(['singleton_class']),
+    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;