arceus-s 1.6.4

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

@@ -0,0 +1,9 @@
+import type { VariableExtractionConfig } from '../../variable-types.js';
+/**
+ * C# variable extraction config.
+ *
+ * C# does not have true top-level variables (pre-C# 9). In C# 9+ top-level
+ * statements, local_declaration_statement can appear at program scope.
+ * Class-scoped fields are handled by the field extractor.
+ */
+export declare const csharpVariableConfig: VariableExtractionConfig;

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

@@ -0,0 +1,63 @@
+// arc/src/core/ingestion/variable-extractors/configs/csharp.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+import { collectModifierTexts } from '../../field-extractors/configs/helpers.js';
+import { extractSimpleTypeName } from '../../type-extractors/shared.js';
+/**
+ * C# variable extraction config.
+ *
+ * C# does not have true top-level variables (pre-C# 9). In C# 9+ top-level
+ * statements, local_declaration_statement can appear at program scope.
+ * Class-scoped fields are handled by the field extractor.
+ */
+export const csharpVariableConfig = {
+    language: SupportedLanguages.CSharp,
+    constNodeTypes: [],
+    staticNodeTypes: [],
+    variableNodeTypes: ['local_declaration_statement'],
+    extractName(node) {
+        // local_declaration_statement → variable_declaration → variable_declarator → identifier
+        const varDecl = node.namedChildren.find((c) => c.type === 'variable_declaration');
+        if (!varDecl)
+            return undefined;
+        const declarator = varDecl.namedChildren.find((c) => c.type === 'variable_declarator');
+        const name = declarator?.childForFieldName('name');
+        return name?.type === 'identifier' ? name.text : undefined;
+    },
+    extractType(node) {
+        const varDecl = node.namedChildren.find((c) => c.type === 'variable_declaration');
+        if (!varDecl)
+            return undefined;
+        const typeNode = varDecl.childForFieldName('type');
+        if (typeNode)
+            return extractSimpleTypeName(typeNode) ?? typeNode.text?.trim();
+        return undefined;
+    },
+    extractVisibility(node) {
+        const mods = collectModifierTexts(node);
+        if (mods.has('public'))
+            return 'public';
+        if (mods.has('private'))
+            return 'private';
+        if (mods.has('protected') && mods.has('internal'))
+            return 'protected internal';
+        if (mods.has('private') && mods.has('protected'))
+            return 'private protected';
+        if (mods.has('protected'))
+            return 'protected';
+        if (mods.has('internal'))
+            return 'internal';
+        return 'private';
+    },
+    isConst(node) {
+        const mods = collectModifierTexts(node);
+        return mods.has('const');
+    },
+    isStatic(node) {
+        const mods = collectModifierTexts(node);
+        return mods.has('static');
+    },
+    isMutable(node) {
+        const mods = collectModifierTexts(node);
+        return !mods.has('const') && !mods.has('readonly');
+    },
+};

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

@@ -0,0 +1,2 @@
+import type { VariableExtractionConfig } from '../../variable-types.js';
+export declare const dartVariableConfig: VariableExtractionConfig;

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

@@ -0,0 +1,94 @@
+// arc/src/core/ingestion/variable-extractors/configs/dart.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+import { extractSimpleTypeName } from '../../type-extractors/shared.js';
+/**
+ * Dart variable extraction config.
+ *
+ * Dart has top-level variable and constant declarations:
+ * - `const maxSize = 100;`
+ * - `final String name = "dart";`
+ * - `var counter = 0;`
+ * - `int x = 5;`
+ *
+ * tree-sitter-dart uses:
+ * - declaration (with initialized_identifier_list) for file-scope variables
+ */
+function extractDartVarName(node) {
+    // declaration → initialized_variable_definition → identifier
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child?.type === 'initialized_variable_definition') {
+            const name = child.childForFieldName('name');
+            if (name)
+                return name.text;
+            // Fallback: first identifier
+            for (let j = 0; j < child.namedChildCount; j++) {
+                const gc = child.namedChild(j);
+                if (gc?.type === 'identifier')
+                    return gc.text;
+            }
+        }
+        // declaration → initialized_identifier_list → initialized_identifier → identifier
+        if (child?.type === 'initialized_identifier_list') {
+            for (let j = 0; j < child.namedChildCount; j++) {
+                const gc = child.namedChild(j);
+                if (gc?.type === 'initialized_identifier') {
+                    const ident = gc.namedChildren.find((c) => c.type === 'identifier');
+                    if (ident)
+                        return ident.text;
+                }
+            }
+        }
+    }
+    return undefined;
+}
+function extractDartVarType(node) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child?.type === 'initialized_variable_definition') {
+            const typeNode = child.childForFieldName('type');
+            if (typeNode)
+                return extractSimpleTypeName(typeNode) ?? typeNode.text?.trim();
+        }
+    }
+    // Look for type_identifier directly on the node
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child?.type === 'type_identifier')
+            return child.text;
+    }
+    return undefined;
+}
+function hasDartKeyword(node, keyword) {
+    for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (child?.text === keyword)
+            return true;
+    }
+    return false;
+}
+export const dartVariableConfig = {
+    language: SupportedLanguages.Dart,
+    constNodeTypes: [],
+    staticNodeTypes: [],
+    variableNodeTypes: ['declaration'],
+    extractName: extractDartVarName,
+    extractType: extractDartVarType,
+    extractVisibility(node) {
+        const name = extractDartVarName(node);
+        if (!name)
+            return 'public';
+        // Dart convention: underscore prefix = library-private
+        return name.startsWith('_') ? 'private' : 'public';
+    },
+    isConst(node) {
+        return hasDartKeyword(node, 'const') || hasDartKeyword(node, 'final');
+    },
+    isStatic(_node) {
+        // Top-level Dart variables are not static
+        return false;
+    },
+    isMutable(node) {
+        return !hasDartKeyword(node, 'const') && !hasDartKeyword(node, 'final');
+    },
+};

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

@@ -0,0 +1,2 @@
+import type { VariableExtractionConfig } from '../../variable-types.js';
+export declare const goVariableConfig: VariableExtractionConfig;

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

@@ -0,0 +1,83 @@
+// arc/src/core/ingestion/variable-extractors/configs/go.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+import { extractSimpleTypeName } from '../../type-extractors/shared.js';
+/**
+ * Go variable extraction config.
+ *
+ * Go has package-scoped var and const declarations:
+ * - `var x int = 5`
+ * - `const MaxSize = 100`
+ * - `var ( ... )` grouped declarations
+ *
+ * tree-sitter-go uses:
+ * - var_declaration → var_spec → identifier, type
+ * - const_declaration → const_spec → identifier, type
+ *
+ * Visibility: uppercase first letter = exported (public), lowercase = unexported (package).
+ */
+function extractGoVarName(node) {
+    // var_declaration/const_declaration → var_spec/const_spec → identifier
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child?.type === 'var_spec' || child?.type === 'const_spec') {
+            const name = child.childForFieldName('name');
+            if (name)
+                return name.text;
+            // Fallback: first identifier child
+            for (let j = 0; j < child.namedChildCount; j++) {
+                const gc = child.namedChild(j);
+                if (gc?.type === 'identifier')
+                    return gc.text;
+            }
+        }
+    }
+    // short_var_declaration: x := 5 → expression_list → identifier
+    if (node.type === 'short_var_declaration') {
+        const left = node.childForFieldName('left');
+        if (left?.type === 'expression_list') {
+            const firstIdent = left.namedChildren.find((c) => c.type === 'identifier');
+            if (firstIdent)
+                return firstIdent.text;
+        }
+    }
+    return undefined;
+}
+function extractGoVarType(node) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child?.type === 'var_spec' || child?.type === 'const_spec') {
+            const typeNode = child.childForFieldName('type');
+            if (typeNode)
+                return extractSimpleTypeName(typeNode) ?? typeNode.text?.trim();
+        }
+    }
+    return undefined;
+}
+export const goVariableConfig = {
+    language: SupportedLanguages.Go,
+    constNodeTypes: ['const_declaration'],
+    staticNodeTypes: [],
+    variableNodeTypes: ['var_declaration', 'short_var_declaration'],
+    extractName: extractGoVarName,
+    extractType: extractGoVarType,
+    extractVisibility(node) {
+        const name = extractGoVarName(node);
+        if (!name)
+            return 'package';
+        // Go visibility: uppercase first letter = exported
+        const firstChar = name.charAt(0);
+        return firstChar === firstChar.toUpperCase() && firstChar !== firstChar.toLowerCase()
+            ? 'public'
+            : 'package';
+    },
+    isConst(node) {
+        return node.type === 'const_declaration';
+    },
+    isStatic(_node) {
+        // Go does not have static declarations
+        return false;
+    },
+    isMutable(node) {
+        return node.type !== 'const_declaration';
+    },
+};

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

@@ -0,0 +1,18 @@
+import type { VariableExtractionConfig } from '../../variable-types.js';
+/**
+ * Java variable extraction config.
+ *
+ * Java does not have true module-level variables — all declarations are
+ * class-scoped. However, `static final` fields at class scope act like
+ * constants. These are already handled by the field extractor. This config
+ * covers any rare local_variable_declaration captures at file scope
+ * (e.g., in scripts or top-level code blocks in JShell).
+ */
+export declare const javaVariableConfig: VariableExtractionConfig;
+/**
+ * Kotlin variable extraction config.
+ *
+ * Kotlin has true top-level val/var declarations outside classes.
+ * tree-sitter-kotlin uses 'property_declaration' for both.
+ */
+export declare const kotlinVariableConfig: VariableExtractionConfig;

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

@@ -0,0 +1,115 @@
+// arc/src/core/ingestion/variable-extractors/configs/jvm.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+import { hasModifier } from '../../field-extractors/configs/helpers.js';
+import { extractSimpleTypeName } from '../../type-extractors/shared.js';
+/**
+ * Java variable extraction config.
+ *
+ * Java does not have true module-level variables — all declarations are
+ * class-scoped. However, `static final` fields at class scope act like
+ * constants. These are already handled by the field extractor. This config
+ * covers any rare local_variable_declaration captures at file scope
+ * (e.g., in scripts or top-level code blocks in JShell).
+ */
+export const javaVariableConfig = {
+    language: SupportedLanguages.Java,
+    constNodeTypes: [],
+    staticNodeTypes: [],
+    variableNodeTypes: ['local_variable_declaration'],
+    extractName(node) {
+        const declarator = node.namedChildren.find((c) => c.type === 'variable_declarator');
+        const name = declarator?.childForFieldName('name');
+        return name?.type === 'identifier' ? name.text : undefined;
+    },
+    extractType(node) {
+        const typeNode = node.childForFieldName('type');
+        if (typeNode)
+            return extractSimpleTypeName(typeNode) ?? typeNode.text?.trim();
+        return undefined;
+    },
+    extractVisibility(node) {
+        if (hasModifier(node, 'modifiers', 'public'))
+            return 'public';
+        if (hasModifier(node, 'modifiers', 'private'))
+            return 'private';
+        if (hasModifier(node, 'modifiers', 'protected'))
+            return 'protected';
+        return 'package';
+    },
+    isConst(node) {
+        return hasModifier(node, 'modifiers', 'final');
+    },
+    isStatic(node) {
+        return hasModifier(node, 'modifiers', 'static');
+    },
+    isMutable(node) {
+        return !hasModifier(node, 'modifiers', 'final');
+    },
+};
+/**
+ * Kotlin variable extraction config.
+ *
+ * Kotlin has true top-level val/var declarations outside classes.
+ * tree-sitter-kotlin uses 'property_declaration' for both.
+ */
+export const kotlinVariableConfig = {
+    language: SupportedLanguages.Kotlin,
+    constNodeTypes: [],
+    staticNodeTypes: [],
+    variableNodeTypes: ['property_declaration'],
+    extractName(node) {
+        // property_declaration → variable_declaration → simple_identifier
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child?.type === 'variable_declaration') {
+                const ident = child.namedChildren.find((c) => c.type === 'simple_identifier');
+                return ident?.text;
+            }
+        }
+        return undefined;
+    },
+    extractType(node) {
+        // Look for type annotation in variable_declaration child
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child?.type === 'variable_declaration') {
+                const typeNode = child.namedChildren.find((c) => c.type === 'user_type' || c.type === 'nullable_type');
+                if (typeNode)
+                    return extractSimpleTypeName(typeNode) ?? typeNode.text?.trim();
+            }
+        }
+        return undefined;
+    },
+    extractVisibility(node) {
+        if (hasModifier(node, 'modifiers', 'public'))
+            return 'public';
+        if (hasModifier(node, 'modifiers', 'private'))
+            return 'private';
+        if (hasModifier(node, 'modifiers', 'protected'))
+            return 'protected';
+        if (hasModifier(node, 'modifiers', 'internal'))
+            return 'internal';
+        return 'public'; // Kotlin default is public
+    },
+    isConst(node) {
+        // val is immutable; also check for `const` modifier
+        for (let i = 0; i < node.childCount; i++) {
+            const child = node.child(i);
+            if (child?.text === 'val')
+                return true;
+        }
+        return hasModifier(node, 'modifiers', 'const');
+    },
+    isStatic(_node) {
+        // Top-level Kotlin properties are not static in the Java sense
+        return false;
+    },
+    isMutable(node) {
+        for (let i = 0; i < node.childCount; i++) {
+            const child = node.child(i);
+            if (child?.text === 'var')
+                return true;
+        }
+        return false;
+    },
+};

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

@@ -0,0 +1,14 @@
+import type { VariableExtractionConfig } from '../../variable-types.js';
+/**
+ * PHP variable extraction config.
+ *
+ * PHP has const declarations at namespace/file scope and global variables:
+ * - `const MAX_SIZE = 100;`
+ * - `define('MAX_SIZE', 100);`
+ * - `$variable = value;`
+ *
+ * tree-sitter-php uses:
+ * - const_declaration at namespace/program scope
+ * - expression_statement containing assignment_expression for variables
+ */
+export declare const phpVariableConfig: VariableExtractionConfig;

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

@@ -0,0 +1,58 @@
+// arc/src/core/ingestion/variable-extractors/configs/php.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+import { hasKeyword } from '../../field-extractors/configs/helpers.js';
+/**
+ * PHP variable extraction config.
+ *
+ * PHP has const declarations at namespace/file scope and global variables:
+ * - `const MAX_SIZE = 100;`
+ * - `define('MAX_SIZE', 100);`
+ * - `$variable = value;`
+ *
+ * tree-sitter-php uses:
+ * - const_declaration at namespace/program scope
+ * - expression_statement containing assignment_expression for variables
+ */
+export const phpVariableConfig = {
+    language: SupportedLanguages.PHP,
+    constNodeTypes: ['const_declaration'],
+    staticNodeTypes: [],
+    variableNodeTypes: ['expression_statement'],
+    extractName(node) {
+        if (node.type === 'const_declaration') {
+            // const_declaration → const_element → name (identifier)
+            for (let i = 0; i < node.namedChildCount; i++) {
+                const child = node.namedChild(i);
+                if (child?.type === 'const_element') {
+                    const name = child.childForFieldName('name');
+                    return name?.text;
+                }
+            }
+            return undefined;
+        }
+        // expression_statement → assignment_expression → variable_name
+        const inner = node.firstNamedChild;
+        if (inner?.type === 'assignment_expression') {
+            const left = inner.childForFieldName('left');
+            if (left?.type === 'variable_name')
+                return left.text;
+        }
+        return undefined;
+    },
+    extractType(_node) {
+        // PHP is dynamically typed — no inline type annotations for variables
+        return undefined;
+    },
+    extractVisibility(_node) {
+        return 'public';
+    },
+    isConst(node) {
+        return node.type === 'const_declaration';
+    },
+    isStatic(node) {
+        return hasKeyword(node, 'static');
+    },
+    isMutable(node) {
+        return node.type !== 'const_declaration';
+    },
+};

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

@@ -0,0 +1,2 @@
+import type { VariableExtractionConfig } from '../../variable-types.js';
+export declare const pythonVariableConfig: VariableExtractionConfig;

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

@@ -0,0 +1,101 @@
+// arc/src/core/ingestion/variable-extractors/configs/python.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+import { extractSimpleTypeName } from '../../type-extractors/shared.js';
+/**
+ * Python variable extraction config.
+ *
+ * Handles module-level assignments and annotated assignments:
+ * - `MAX_SIZE = 100` → const by UPPER_CASE convention
+ * - `name: str = "default"` → annotated assignment with type
+ * - `_private_var = 42` → protected by convention
+ * - `__private_var = 42` → private by convention
+ *
+ * tree-sitter-python uses:
+ * - expression_statement containing assignment or type nodes
+ */
+function extractNameFromPython(node) {
+    const inner = node.firstNamedChild;
+    if (!inner)
+        return undefined;
+    // Annotated assignment: name: str = "default"
+    // AST: expression_statement > type > identifier
+    if (inner.type === 'type') {
+        const ident = inner.childForFieldName('name') ?? inner.firstNamedChild;
+        return ident?.type === 'identifier' ? ident.text : undefined;
+    }
+    // Plain assignment: x = 5
+    if (inner.type === 'assignment') {
+        const left = inner.childForFieldName('left');
+        if (left?.type === 'identifier')
+            return left.text;
+    }
+    return undefined;
+}
+function extractTypeFromPython(node) {
+    const inner = node.firstNamedChild;
+    if (!inner)
+        return undefined;
+    // Standalone annotated type without assignment: `name: str`
+    if (inner.type === 'type') {
+        const typeNode = inner.childForFieldName('type') ?? inner.namedChild(1);
+        if (typeNode)
+            return extractSimpleTypeName(typeNode) ?? typeNode.text?.trim();
+    }
+    // Annotated assignment: `name: str = "hello"`
+    // AST: expression_statement > assignment > [identifier, type > identifier, ...]
+    if (inner.type === 'assignment') {
+        for (let i = 0; i < inner.childCount; i++) {
+            const child = inner.child(i);
+            if (child?.type === 'type') {
+                const typeId = child.firstNamedChild;
+                if (typeId)
+                    return extractSimpleTypeName(typeId) ?? typeId.text?.trim();
+            }
+        }
+    }
+    return undefined;
+}
+function extractVisFromPython(node) {
+    const name = extractNameFromPython(node);
+    if (!name)
+        return 'public';
+    // Dunder names (__name__, __all__) are public Python conventions
+    if (name.startsWith('__') && name.endsWith('__'))
+        return 'public';
+    // Double underscore prefix (name mangled) = private
+    if (name.startsWith('__'))
+        return 'private';
+    // Single underscore prefix = protected by convention
+    if (name.startsWith('_'))
+        return 'protected';
+    return 'public';
+}
+export const pythonVariableConfig = {
+    language: SupportedLanguages.Python,
+    constNodeTypes: [],
+    staticNodeTypes: [],
+    // expression_statement is broad — isVariableDeclaration returns true for
+    // all expression_statement nodes, but extract() safely filters non-assignments
+    // by returning null when extractNameFromPython finds no assignment target.
+    variableNodeTypes: ['expression_statement'],
+    extractName: extractNameFromPython,
+    extractType: extractTypeFromPython,
+    extractVisibility: extractVisFromPython,
+    isConst(node) {
+        // Python convention: UPPER_CASE names are constants
+        const name = extractNameFromPython(node);
+        if (!name)
+            return false;
+        return name === name.toUpperCase() && /^[A-Z][A-Z0-9_]*$/.test(name);
+    },
+    isStatic(_node) {
+        return false;
+    },
+    isMutable(node) {
+        const name = extractNameFromPython(node);
+        if (!name)
+            return true;
+        // By convention, UPPER_CASE names are immutable constants
+        return !(name === name.toUpperCase() && /^[A-Z][A-Z0-9_]*$/.test(name));
+    },
+};

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

@@ -0,0 +1,11 @@
+import type { VariableExtractionConfig } from '../../variable-types.js';
+/**
+ * Ruby variable extraction config.
+ *
+ * Ruby module-level constants use UPPER_CASE identifiers or start with
+ * an uppercase letter. Ruby uses:
+ * - assignment for variable declarations at module scope
+ * - Constants: `MAX_SIZE = 100` or `Config = ...`
+ * - Global variables: `$global = ...`
+ */
+export declare const rubyVariableConfig: VariableExtractionConfig;

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

@@ -0,0 +1,52 @@
+// arc/src/core/ingestion/variable-extractors/configs/ruby.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+/**
+ * Ruby variable extraction config.
+ *
+ * Ruby module-level constants use UPPER_CASE identifiers or start with
+ * an uppercase letter. Ruby uses:
+ * - assignment for variable declarations at module scope
+ * - Constants: `MAX_SIZE = 100` or `Config = ...`
+ * - Global variables: `$global = ...`
+ */
+export const rubyVariableConfig = {
+    language: SupportedLanguages.Ruby,
+    constNodeTypes: [],
+    staticNodeTypes: [],
+    variableNodeTypes: ['assignment'],
+    extractName(node) {
+        const left = node.childForFieldName('left');
+        if (!left)
+            return undefined;
+        if (left.type === 'identifier' || left.type === 'constant')
+            return left.text;
+        if (left.type === 'global_variable')
+            return left.text;
+        return undefined;
+    },
+    extractType(_node) {
+        // Ruby is dynamically typed — no type annotations at module level
+        return undefined;
+    },
+    extractVisibility(_node) {
+        const left = _node.childForFieldName('left');
+        if (!left)
+            return 'public';
+        // Constants (uppercase start) and global variables are effectively public
+        if (left.type === 'constant' || left.type === 'global_variable')
+            return 'public';
+        return 'private';
+    },
+    isConst(node) {
+        const left = node.childForFieldName('left');
+        return left?.type === 'constant';
+    },
+    isStatic(_node) {
+        return false;
+    },
+    isMutable(node) {
+        const left = node.childForFieldName('left');
+        // Constants are immutable by convention
+        return left?.type !== 'constant';
+    },
+};

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

@@ -0,0 +1,2 @@
+import type { VariableExtractionConfig } from '../../variable-types.js';
+export declare const rustVariableConfig: VariableExtractionConfig;