gitnexus 1.6.2-rc.2 → 1.6.2-rc.21

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

@@ -0,0 +1,76 @@
+// gitnexus/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 @@
+// gitnexus/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 @@
+// gitnexus/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 @@
+// gitnexus/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 @@
+// gitnexus/src/core/ingestion/variable-types.ts
+export {};