arceus-s 1.6.4

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

@@ -0,0 +1,76 @@
+// arc/src/core/ingestion/variable-extractors/configs/rust.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+import { extractSimpleTypeName } from '../../type-extractors/shared.js';
+/**
+ * Rust variable extraction config.
+ *
+ * Rust has module-scoped const, static, and let declarations:
+ * - `const MAX_SIZE: usize = 100;`
+ * - `static COUNTER: AtomicUsize = AtomicUsize::new(0);`
+ * - `static mut BUFFER: Vec<u8> = Vec::new();`
+ * - `let x = 5;` (block-scoped, but included for completeness)
+ *
+ * tree-sitter-rust uses:
+ * - const_item → identifier, type
+ * - static_item → identifier, type
+ * - let_declaration → identifier, type
+ */
+function hasVisibilityModifier(node) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child?.type === 'visibility_modifier')
+            return true;
+    }
+    return false;
+}
+function hasMutKeyword(node) {
+    for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (child?.text === 'mut')
+            return true;
+    }
+    return false;
+}
+export const rustVariableConfig = {
+    language: SupportedLanguages.Rust,
+    constNodeTypes: ['const_item'],
+    staticNodeTypes: ['static_item'],
+    variableNodeTypes: ['let_declaration'],
+    extractName(node) {
+        const name = node.childForFieldName('name');
+        if (name)
+            return name.text;
+        // Fallback: first identifier child
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child?.type === 'identifier')
+                return child.text;
+        }
+        return undefined;
+    },
+    extractType(node) {
+        const typeNode = node.childForFieldName('type');
+        if (typeNode)
+            return extractSimpleTypeName(typeNode) ?? typeNode.text?.trim();
+        return undefined;
+    },
+    extractVisibility(node) {
+        return hasVisibilityModifier(node) ? 'public' : 'private';
+    },
+    isConst(node) {
+        return node.type === 'const_item';
+    },
+    isStatic(node) {
+        return node.type === 'static_item';
+    },
+    isMutable(node) {
+        if (node.type === 'const_item')
+            return false;
+        if (node.type === 'static_item')
+            return hasMutKeyword(node);
+        // let_declaration: check for mut keyword
+        if (node.type === 'let_declaration')
+            return hasMutKeyword(node);
+        return true;
+    },
+};

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

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

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

@@ -0,0 +1,88 @@
+// arc/src/core/ingestion/variable-extractors/configs/swift.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+import { extractSimpleTypeName } from '../../type-extractors/shared.js';
+/**
+ * Swift variable extraction config.
+ *
+ * Swift has top-level let/var declarations:
+ * - `let maxSize = 100`
+ * - `var counter = 0`
+ * - `public let apiKey: String = "..."`
+ *
+ * tree-sitter-swift uses:
+ * - property_declaration for both class and top-level declarations
+ */
+function extractSwiftVarName(node) {
+    // property_declaration → pattern → ... → simple_identifier / identifier
+    const pattern = node.namedChildren.find((c) => c.type === 'pattern');
+    if (pattern) {
+        const ident = pattern.namedChildren.find((c) => c.type === 'simple_identifier' || c.type === 'identifier');
+        if (ident)
+            return ident.text;
+    }
+    // Fallback: look for simple_identifier directly
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child?.type === 'simple_identifier')
+            return child.text;
+    }
+    return undefined;
+}
+function extractSwiftVarType(node) {
+    // Look for type_annotation child
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child?.type === 'type_annotation') {
+            const typeNode = child.firstNamedChild;
+            if (typeNode)
+                return extractSimpleTypeName(typeNode) ?? typeNode.text?.trim();
+        }
+    }
+    return undefined;
+}
+function hasSwiftKeyword(node, keyword) {
+    for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (child?.text === keyword)
+            return true;
+    }
+    return false;
+}
+const SWIFT_VISIBILITY = new Set(['public', 'private', 'internal', 'fileprivate', 'open']);
+export const swiftVariableConfig = {
+    language: SupportedLanguages.Swift,
+    constNodeTypes: [],
+    staticNodeTypes: [],
+    variableNodeTypes: ['property_declaration'],
+    extractName: extractSwiftVarName,
+    extractType: extractSwiftVarType,
+    extractVisibility(node) {
+        // Check modifiers for visibility keywords
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child?.type === 'modifiers') {
+                for (let j = 0; j < child.childCount; j++) {
+                    const mod = child.child(j);
+                    if (mod && SWIFT_VISIBILITY.has(mod.text))
+                        return mod.text;
+                }
+            }
+        }
+        // Direct keyword check
+        for (let i = 0; i < node.childCount; i++) {
+            const child = node.child(i);
+            if (child && SWIFT_VISIBILITY.has(child.text))
+                return child.text;
+        }
+        return 'internal'; // Swift default visibility
+    },
+    isConst(node) {
+        return hasSwiftKeyword(node, 'let');
+    },
+    isStatic(node) {
+        return hasSwiftKeyword(node, 'static') || hasSwiftKeyword(node, 'class');
+    },
+    isMutable(node) {
+        return hasSwiftKeyword(node, 'var');
+    },
+};

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

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

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

@@ -0,0 +1,83 @@
+// arc/src/core/ingestion/variable-extractors/configs/typescript-javascript.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+import { hasKeyword, typeFromAnnotation } from '../../field-extractors/configs/helpers.js';
+/**
+ * TypeScript/JavaScript variable extraction config.
+ *
+ * Handles module-scoped const/let/var declarations:
+ * - `export const X = ...` → public, const
+ * - `const X = ...` → private, const
+ * - `let x = ...` → private, mutable
+ * - `var x = ...` → private, mutable
+ *
+ * tree-sitter node structure:
+ *   lexical_declaration (const/let) → variable_declarator → identifier (name)
+ *   variable_declaration (var) → variable_declarator → identifier (name)
+ */
+function extractNameFromDecl(node) {
+    // lexical_declaration / variable_declaration → variable_declarator → name
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child?.type === 'variable_declarator') {
+            const name = child.childForFieldName('name');
+            if (name?.type === 'identifier')
+                return name.text;
+        }
+    }
+    return undefined;
+}
+function extractTypeFromDecl(node) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child?.type === 'variable_declarator') {
+            return typeFromAnnotation(child);
+        }
+    }
+    return undefined;
+}
+function extractVisFromDecl(node) {
+    // Check parent for export_statement wrapper
+    const parent = node.parent;
+    if (parent?.type === 'export_statement')
+        return 'public';
+    // Check for 'export' keyword as direct child
+    if (hasKeyword(node, 'export'))
+        return 'public';
+    return 'private';
+}
+const shared = {
+    constNodeTypes: ['lexical_declaration'],
+    staticNodeTypes: [],
+    variableNodeTypes: ['variable_declaration'],
+    extractName: extractNameFromDecl,
+    extractType: extractTypeFromDecl,
+    extractVisibility: extractVisFromDecl,
+    isConst(node) {
+        // lexical_declaration with 'const' keyword
+        if (node.type === 'lexical_declaration') {
+            return hasKeyword(node, 'const');
+        }
+        return false;
+    },
+    isStatic(_node) {
+        // JS/TS module-level variables are not static in the class sense
+        return false;
+    },
+    isMutable(node) {
+        // var or let declarations are mutable; const is not
+        if (node.type === 'variable_declaration')
+            return true;
+        if (node.type === 'lexical_declaration') {
+            return hasKeyword(node, 'let');
+        }
+        return false;
+    },
+};
+export const typescriptVariableConfig = {
+    ...shared,
+    language: SupportedLanguages.TypeScript,
+};
+export const javascriptVariableConfig = {
+    ...shared,
+    language: SupportedLanguages.JavaScript,
+};

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

@@ -0,0 +1,5 @@
+import type { VariableExtractionConfig, VariableExtractor } from '../variable-types.js';
+/**
+ * Create a VariableExtractor from a declarative config.
+ */
+export declare function createVariableExtractor(config: VariableExtractionConfig): VariableExtractor;

package/dist/core/ingestion/variable-extractors/generic.js

@@ -0,0 +1,80 @@
+// arc/src/core/ingestion/variable-extractors/generic.ts
+/**
+ * Create a VariableExtractor from a declarative config.
+ */
+export function createVariableExtractor(config) {
+    const staticNodeSet = new Set(config.staticNodeTypes);
+    // Combined set for fast isVariableDeclaration checks
+    const allNodeTypes = new Set([
+        ...config.constNodeTypes,
+        ...config.staticNodeTypes,
+        ...config.variableNodeTypes,
+    ]);
+    function determineScope(node) {
+        // Walk up to determine scope:
+        // - 'module': node is inside a top-level program/module/source_file container
+        // - 'block': node is inside a function, method, or block scope
+        // - 'file': fallback when no recognizable container is found (e.g., standalone snippets)
+        let current = node.parent;
+        while (current) {
+            const t = current.type;
+            // Top-level program/module nodes indicate module/file scope
+            if (t === 'program' ||
+                t === 'source_file' ||
+                t === 'module' ||
+                t === 'translation_unit' ||
+                t === 'compilation_unit') {
+                return 'module';
+            }
+            // Function/method/block boundaries indicate block scope
+            if (t === 'function_declaration' ||
+                t === 'function_definition' ||
+                t === 'function_item' ||
+                t === 'method_declaration' ||
+                t === 'method_definition' ||
+                t === 'arrow_function' ||
+                t === 'function_expression' ||
+                t === 'lambda' ||
+                t === 'block' ||
+                t === 'function_body' ||
+                t === 'compound_statement') {
+                return 'block';
+            }
+            current = current.parent;
+        }
+        return 'file';
+    }
+    return {
+        language: config.language,
+        isVariableDeclaration(node) {
+            return allNodeTypes.has(node.type);
+        },
+        extract(node, context) {
+            if (!allNodeTypes.has(node.type))
+                return null;
+            const name = config.extractName(node);
+            if (!name)
+                return null;
+            const type = config.extractType(node) ?? null;
+            const visibility = config.extractVisibility(node);
+            // isConst/isStatic: node type membership is a hint, but config.isConst/isStatic
+            // has final say. For languages where const and non-const share a node type
+            // (e.g., TS lexical_declaration for both const and let), config.isConst disambiguates.
+            const isConst = config.isConst(node);
+            const isStatic = staticNodeSet.has(node.type) || config.isStatic(node);
+            const isMutable = config.isMutable(node);
+            const scope = determineScope(node);
+            return {
+                name,
+                type,
+                visibility,
+                isConst,
+                isStatic,
+                isMutable,
+                scope,
+                sourceFile: context.filePath,
+                line: node.startPosition.row + 1,
+            };
+        },
+    };
+}

package/dist/core/ingestion/variable-types.d.ts

@@ -0,0 +1,82 @@
+import type { SupportedLanguages } from '../../_shared/index.js';
+import type { FieldVisibility } from './field-types.js';
+import type { SyntaxNode } from './utils/ast-helpers.js';
+export type VariableVisibility = FieldVisibility;
+/**
+ * Scope level for a variable declaration.
+ * - 'module': module/package scope (TypeScript `export const`, Go package-level)
+ * - 'file': file scope (C/C++ static file-scope, Python module-level)
+ * - 'block': block-scoped (JS `let`/`const` inside a function)
+ */
+export type VariableScope = 'module' | 'file' | 'block';
+/**
+ * Represents a module/file-scoped variable, constant, or static declaration.
+ */
+export interface VariableInfo {
+    /** Variable name */
+    name: string;
+    /** Declared type annotation (may be null if untyped) */
+    type: string | null;
+    /** Visibility modifier */
+    visibility: VariableVisibility;
+    /** Is this a constant (const, val, final)? */
+    isConst: boolean;
+    /** Is this a static declaration? */
+    isStatic: boolean;
+    /** Is this mutable (let, var vs const, val)? */
+    isMutable: boolean;
+    /** Scope of the declaration */
+    scope: VariableScope;
+    /** Source file path */
+    sourceFile: string;
+    /** Line number (1-based) */
+    line: number;
+}
+/**
+ * Context for variable extraction.
+ */
+export interface VariableExtractorContext {
+    /** Current file path */
+    filePath: string;
+    /** Language ID */
+    language: SupportedLanguages;
+}
+/**
+ * Variable extractor interface — extracts structured metadata from
+ * module/file-scoped variable, constant, and static declarations.
+ */
+export interface VariableExtractor {
+    /** Language this extractor handles */
+    language: SupportedLanguages;
+    /** Extract variable metadata from a declaration node.
+     *  Returns null if the node is not a recognized variable declaration. */
+    extract(node: SyntaxNode, context: VariableExtractorContext): VariableInfo | null;
+    /** Check if a node is a recognized variable declaration type. */
+    isVariableDeclaration(node: SyntaxNode): boolean;
+}
+/**
+ * Declarative config for building a variable extractor via the factory.
+ * Follows the same pattern as FieldExtractionConfig and MethodExtractionConfig.
+ */
+export interface VariableExtractionConfig {
+    /** Language this config applies to */
+    language: SupportedLanguages;
+    /** AST node types for const declarations (e.g., 'const_item', 'lexical_declaration') */
+    constNodeTypes: string[];
+    /** AST node types for static declarations (e.g., 'static_item') */
+    staticNodeTypes: string[];
+    /** AST node types for variable declarations (e.g., 'variable_declaration') */
+    variableNodeTypes: string[];
+    /** Extract the variable name from a declaration node */
+    extractName: (node: SyntaxNode) => string | undefined;
+    /** Extract type annotation from a declaration node */
+    extractType: (node: SyntaxNode) => string | undefined;
+    /** Extract visibility from a declaration node */
+    extractVisibility: (node: SyntaxNode) => VariableVisibility;
+    /** Check if a declaration is const/immutable */
+    isConst: (node: SyntaxNode) => boolean;
+    /** Check if a declaration is static */
+    isStatic: (node: SyntaxNode) => boolean;
+    /** Check if a declaration is mutable */
+    isMutable: (node: SyntaxNode) => boolean;
+}

package/dist/core/ingestion/variable-types.js

@@ -0,0 +1,2 @@
+// arc/src/core/ingestion/variable-types.ts
+export {};

package/dist/core/ingestion/vue-sfc-extractor.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Vue SFC (Single File Component) script extractor.
+ *
+ * Extracts the <script> / <script setup> block content from .vue files
+ * so it can be parsed by the TypeScript tree-sitter grammar.
+ *
+ * Pure function — no tree-sitter dependency, safe for worker threads.
+ */
+export interface VueScriptExtraction {
+    /** Extracted script content (TypeScript/JavaScript) */
+    scriptContent: string;
+    /** 0-based line number in the .vue file where the script content starts */
+    lineOffset: number;
+    /** true if the primary block is <script setup> */
+    isSetup: boolean;
+}
+/**
+ * Extract script content from a Vue SFC.
+ *
+ * When both <script> and <script setup> are present, returns only the
+ * <script setup> block (the dominant pattern — 94% of Vue files in real
+ * projects use setup). The <script> (non-setup) block typically contains
+ * only `defineOptions` or legacy option merges and is less important for
+ * the knowledge graph.
+ */
+export declare function extractVueScript(vueContent: string): VueScriptExtraction | null;
+/**
+ * Vue <script setup>: all top-level bindings are implicitly exported.
+ * Returns true if the node (or any ancestor) has the `program` root as its
+ * direct parent — i.e. the node is at the top level of the script block.
+ *
+ * Shared between the worker and sequential parsing paths.
+ */
+export declare const isVueSetupTopLevel: (node: {
+    parent: {
+        type: string;
+        parent: unknown;
+    } | null;
+} | null) => boolean;
+/**
+ * Extract PascalCase component names used in <template>.
+ * Returns deduplicated component names (e.g., ["MyButton", "AppHeader"]).
+ */
+export declare function extractTemplateComponents(vueContent: string): string[];

package/dist/core/ingestion/vue-sfc-extractor.js

@@ -0,0 +1,111 @@
+/**
+ * Vue SFC (Single File Component) script extractor.
+ *
+ * Extracts the <script> / <script setup> block content from .vue files
+ * so it can be parsed by the TypeScript tree-sitter grammar.
+ *
+ * Pure function — no tree-sitter dependency, safe for worker threads.
+ */
+// Closing-tag pattern accepts:
+//   - whitespace before `>`            — `</script >`, `</script\t\n>`
+//   - attribute-like junk after `script` — `</script foo="bar">`,
+//                                          `</script\t\n bar>`
+//   - any case                          — `</SCRIPT>`, `</Script>`
+//
+// HTML5 parses `</script foo>` as a valid close tag (attributes on
+// close tags are ignored by the parser but still terminate the script
+// block). A strict `<\/script\s*>` would miss those forms and let a
+// crafted Vue file hide content from this extractor — exactly the
+// CodeQL `js/bad-tag-filter` failure mode (the published test cases
+// it checks include `</script foo="bar">` and `</script\t\n bar>`).
+//
+// `[^>]*` after `</script` accepts everything up to the next `>`,
+// matching the HTML parser's actual close-tag behaviour. The `i` flag
+// covers the case axis. PR #1330 CI surfaced both the case and
+// attribute axes; this expression closes both at once.
+const SCRIPT_RE = /<script(\s[^>]*)?>([^]*?)<\/script[^>]*>/gi;
+const TEMPLATE_COMPONENT_RE = /<([A-Z][A-Za-z0-9]+)/g;
+// Greedy: matches from the first <template> to the *last* </template>.
+// This is intentional — nested <template v-slot:...> tags are valid Vue
+// syntax and we want the entire outermost template body.
+const TEMPLATE_RE = /<template(\s[^>]*)?>([^]*)<\/template>/;
+function countNewlines(text) {
+    let count = 0;
+    for (let i = 0; i < text.length; i++) {
+        if (text.charCodeAt(i) === 10)
+            count++;
+    }
+    return count;
+}
+function parseScriptBlock(attrs, content, precedingText) {
+    const isSetup = attrs != null && /\bsetup\b/.test(attrs);
+    const langMatch = attrs?.match(/\blang\s*=\s*["']([^"']+)["']/);
+    const lang = langMatch ? langMatch[1] : '';
+    // +1 for the newline after the opening <script...> tag
+    const lineOffset = countNewlines(precedingText) + 1;
+    return { content, lineOffset, isSetup, lang };
+}
+/**
+ * Extract script content from a Vue SFC.
+ *
+ * When both <script> and <script setup> are present, returns only the
+ * <script setup> block (the dominant pattern — 94% of Vue files in real
+ * projects use setup). The <script> (non-setup) block typically contains
+ * only `defineOptions` or legacy option merges and is less important for
+ * the knowledge graph.
+ */
+export function extractVueScript(vueContent) {
+    const blocks = [];
+    let match;
+    // Reset lastIndex for reuse of the global regex
+    SCRIPT_RE.lastIndex = 0;
+    while ((match = SCRIPT_RE.exec(vueContent)) !== null) {
+        const precedingText = vueContent.slice(0, match.index + match[0].indexOf(match[2]));
+        blocks.push(parseScriptBlock(match[1], match[2], precedingText));
+    }
+    if (blocks.length === 0)
+        return null;
+    // Prefer <script setup> if present
+    const setupBlock = blocks.find((b) => b.isSetup);
+    const primary = setupBlock ?? blocks[0];
+    return {
+        scriptContent: primary.content,
+        lineOffset: primary.lineOffset,
+        isSetup: primary.isSetup,
+    };
+}
+/**
+ * Vue <script setup>: all top-level bindings are implicitly exported.
+ * Returns true if the node (or any ancestor) has the `program` root as its
+ * direct parent — i.e. the node is at the top level of the script block.
+ *
+ * Shared between the worker and sequential parsing paths.
+ */
+export const isVueSetupTopLevel = (node) => {
+    if (!node)
+        return false;
+    let current = node;
+    while (current) {
+        if (current.parent?.type === 'program')
+            return true;
+        current = current.parent;
+    }
+    return false;
+};
+/**
+ * Extract PascalCase component names used in <template>.
+ * Returns deduplicated component names (e.g., ["MyButton", "AppHeader"]).
+ */
+export function extractTemplateComponents(vueContent) {
+    const templateMatch = TEMPLATE_RE.exec(vueContent);
+    if (!templateMatch)
+        return [];
+    const templateContent = templateMatch[2];
+    const components = new Set();
+    let componentMatch;
+    TEMPLATE_COMPONENT_RE.lastIndex = 0;
+    while ((componentMatch = TEMPLATE_COMPONENT_RE.exec(templateContent)) !== null) {
+        components.add(componentMatch[1]);
+    }
+    return [...components];
+}