gitnexus 1.4.8 → 1.4.10

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

@@ -0,0 +1,64 @@
+// gitnexus/src/core/ingestion/field-extractors/configs/go.ts
+import { SupportedLanguages } from '../../../../config/supported-languages.js';
+import { extractSimpleTypeName } from '../../type-extractors/shared.js';
+/**
+ * Go field extraction config.
+ *
+ * Go struct fields live inside type_declaration > type_spec > struct_type >
+ * field_declaration_list > field_declaration.
+ *
+ * Visibility in Go is based on the first character: uppercase = exported (public),
+ * lowercase = unexported (package).
+ */
+export const goConfig = {
+    language: SupportedLanguages.Go,
+    typeDeclarationNodes: [
+        'type_declaration',
+    ],
+    fieldNodeTypes: ['field_declaration'],
+    bodyNodeTypes: ['field_declaration_list'],
+    defaultVisibility: 'package',
+    extractName(node) {
+        // field_declaration > name:(field_identifier)
+        const name = node.childForFieldName('name');
+        if (name)
+            return name.text;
+        // fallback: first field_identifier child
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child?.type === 'field_identifier')
+                return child.text;
+        }
+        return undefined;
+    },
+    extractType(node) {
+        // field_declaration > type:(type_identifier | pointer_type | ...)
+        const typeNode = node.childForFieldName('type');
+        if (typeNode)
+            return extractSimpleTypeName(typeNode) ?? typeNode.text?.trim();
+        // fallback: second named child is usually the type
+        if (node.namedChildCount >= 2) {
+            const t = node.namedChild(1);
+            if (t)
+                return extractSimpleTypeName(t) ?? t.text?.trim();
+        }
+        return undefined;
+    },
+    extractVisibility(node) {
+        const name = node.childForFieldName('name');
+        const text = name?.text;
+        if (text && text.length > 0) {
+            const first = text.charAt(0);
+            return first === first.toUpperCase() && first !== first.toLowerCase()
+                ? 'public'
+                : 'package';
+        }
+        return 'package';
+    },
+    isStatic(_node) {
+        return false; // Go has no static fields
+    },
+    isReadonly(_node) {
+        return false; // Go fields are not readonly
+    },
+};

package/dist/core/ingestion/field-extractors/configs/helpers.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Shared AST-walking helpers used by multiple language configs.
+ * Keeps individual config files small.
+ */
+import type { SyntaxNode } from '../../utils/ast-helpers.js';
+import type { FieldVisibility } from '../../field-types.js';
+/**
+ * Check whether any child of `node` (named or unnamed) has .text matching
+ * one of the given `keywords`.
+ */
+export declare function hasKeyword(node: SyntaxNode, keyword: string): boolean;
+/**
+ * Check whether a named child of type `modifierType` contains `keyword`.
+ * Useful for languages that group modifiers under a wrapper node
+ * (e.g. Java 'modifiers', Kotlin 'modifiers').
+ */
+export declare function hasModifier(node: SyntaxNode, modifierType: string, keyword: string): boolean;
+/**
+ * Return the first matching visibility keyword found either as a direct keyword
+ * child or inside a modifier wrapper node.
+ */
+export declare function findVisibility(node: SyntaxNode, keywords: ReadonlySet<FieldVisibility>, defaultVis: FieldVisibility, modifierNodeType?: string): FieldVisibility;
+/**
+ * Extract the text of the first named child whose type is in `types`.
+ */
+export declare function firstChildText(node: SyntaxNode, types: ReadonlySet<string>): string | undefined;
+/**
+ * Extract the first named child node whose type is in `types`.
+ */
+export declare function firstChildOfType(node: SyntaxNode, types: ReadonlySet<string>): SyntaxNode | null;
+/**
+ * Get type text from a named field on the node, using extractSimpleTypeName.
+ * Falls back to raw .text of the field child if extractSimpleTypeName returns undefined.
+ */
+export declare function typeFromField(node: SyntaxNode, fieldName: string): string | undefined;
+/**
+ * Walk named children looking for a type_annotation node and extract its type.
+ */
+export declare function typeFromAnnotation(node: SyntaxNode): string | undefined;
+/**
+ * Find the first descendant (depth-first, one level) matching one of the given types
+ * and return its text via extractSimpleTypeName.
+ */
+export declare function typeFromDescendant(node: SyntaxNode, types: ReadonlySet<string>): string | undefined;

package/dist/core/ingestion/field-extractors/configs/helpers.js

@@ -0,0 +1,134 @@
+// gitnexus/src/core/ingestion/field-extractors/configs/helpers.ts
+import { extractSimpleTypeName } from '../../type-extractors/shared.js';
+// ---------------------------------------------------------------------------
+// Modifier scanning
+// ---------------------------------------------------------------------------
+/**
+ * Check whether any child of `node` (named or unnamed) has .text matching
+ * one of the given `keywords`.
+ */
+export function hasKeyword(node, keyword) {
+    for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (child && child.text.trim() === keyword)
+            return true;
+    }
+    return false;
+}
+/**
+ * Check whether a named child of type `modifierType` contains `keyword`.
+ * Useful for languages that group modifiers under a wrapper node
+ * (e.g. Java 'modifiers', Kotlin 'modifiers').
+ */
+export function hasModifier(node, modifierType, keyword) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child && child.type === modifierType) {
+            for (let j = 0; j < child.childCount; j++) {
+                const mod = child.child(j);
+                if (mod && mod.text.trim() === keyword)
+                    return true;
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Return the first matching visibility keyword found either as a direct keyword
+ * child or inside a modifier wrapper node.
+ */
+export function findVisibility(node, keywords, defaultVis, modifierNodeType) {
+    // Direct keyword children
+    for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        const text = child?.text.trim();
+        if (text && keywords.has(text))
+            return text;
+    }
+    // Modifier wrapper
+    if (modifierNodeType) {
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child && child.type === modifierNodeType) {
+                for (let j = 0; j < child.childCount; j++) {
+                    const mod = child.child(j);
+                    const modText = mod?.text.trim();
+                    if (modText && keywords.has(modText))
+                        return modText;
+                }
+            }
+        }
+    }
+    return defaultVis;
+}
+// ---------------------------------------------------------------------------
+// Name and type extraction
+// ---------------------------------------------------------------------------
+/**
+ * Extract the text of the first named child whose type is in `types`.
+ */
+export function firstChildText(node, types) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child && types.has(child.type))
+            return child.text;
+    }
+    return undefined;
+}
+/**
+ * Extract the first named child node whose type is in `types`.
+ */
+export function firstChildOfType(node, types) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child && types.has(child.type))
+            return child;
+    }
+    return null;
+}
+/**
+ * Get type text from a named field on the node, using extractSimpleTypeName.
+ * Falls back to raw .text of the field child if extractSimpleTypeName returns undefined.
+ */
+export function typeFromField(node, fieldName) {
+    const typeNode = node.childForFieldName(fieldName);
+    if (!typeNode)
+        return undefined;
+    return extractSimpleTypeName(typeNode) ?? typeNode.text?.trim();
+}
+/**
+ * Walk named children looking for a type_annotation node and extract its type.
+ */
+export function typeFromAnnotation(node) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child && child.type === 'type_annotation') {
+            const inner = child.firstNamedChild;
+            if (inner)
+                return extractSimpleTypeName(inner) ?? inner.text?.trim();
+        }
+    }
+    return undefined;
+}
+/**
+ * Find the first descendant (depth-first, one level) matching one of the given types
+ * and return its text via extractSimpleTypeName.
+ */
+export function typeFromDescendant(node, types) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (!child)
+            continue;
+        if (types.has(child.type)) {
+            return extractSimpleTypeName(child) ?? child.text?.trim();
+        }
+        // one more level
+        for (let j = 0; j < child.namedChildCount; j++) {
+            const grandchild = child.namedChild(j);
+            if (grandchild && types.has(grandchild.type)) {
+                return extractSimpleTypeName(grandchild) ?? grandchild.text?.trim();
+            }
+        }
+    }
+    return undefined;
+}

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

@@ -0,0 +1,3 @@
+import type { FieldExtractionConfig } from '../generic.js';
+export declare const javaConfig: FieldExtractionConfig;
+export declare const kotlinConfig: FieldExtractionConfig;

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

@@ -0,0 +1,118 @@
+// gitnexus/src/core/ingestion/field-extractors/configs/jvm.ts
+import { SupportedLanguages } from '../../../../config/supported-languages.js';
+import { findVisibility, hasKeyword, hasModifier, typeFromField } from './helpers.js';
+import { extractSimpleTypeName } from '../../type-extractors/shared.js';
+// ---------------------------------------------------------------------------
+// Java
+// ---------------------------------------------------------------------------
+const JAVA_VIS = new Set(['public', 'private', 'protected']);
+export const javaConfig = {
+    language: SupportedLanguages.Java,
+    typeDeclarationNodes: [
+        'class_declaration',
+        'interface_declaration',
+        'enum_declaration',
+        'record_declaration',
+    ],
+    fieldNodeTypes: ['field_declaration'],
+    bodyNodeTypes: ['class_body', 'interface_body', 'enum_body'],
+    defaultVisibility: 'package',
+    extractName(node) {
+        // field_declaration > declarator:(variable_declarator name:(identifier))
+        const declarator = node.childForFieldName('declarator');
+        if (declarator) {
+            const name = declarator.childForFieldName('name');
+            return name?.text;
+        }
+        // fallback: walk children for variable_declarator
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child?.type === 'variable_declarator') {
+                const name = child.childForFieldName('name');
+                return name?.text;
+            }
+        }
+        return undefined;
+    },
+    extractType(node) {
+        // field_declaration > type:(type_identifier|generic_type|...)
+        const t = typeFromField(node, 'type');
+        if (t)
+            return t;
+        // fallback: first named child that looks like a type
+        const first = node.firstNamedChild;
+        if (first && first.type !== 'modifiers') {
+            return extractSimpleTypeName(first) ?? first.text?.trim();
+        }
+        return undefined;
+    },
+    extractVisibility(node) {
+        return findVisibility(node, JAVA_VIS, 'package', 'modifiers');
+    },
+    isStatic(node) {
+        return hasKeyword(node, 'static') || hasModifier(node, 'modifiers', 'static');
+    },
+    isReadonly(node) {
+        return hasKeyword(node, 'final') || hasModifier(node, 'modifiers', 'final');
+    },
+};
+// ---------------------------------------------------------------------------
+// Kotlin
+// ---------------------------------------------------------------------------
+const KOTLIN_VIS = new Set(['public', 'private', 'protected', 'internal']);
+export const kotlinConfig = {
+    language: SupportedLanguages.Kotlin,
+    typeDeclarationNodes: [
+        'class_declaration',
+        'object_declaration',
+    ],
+    fieldNodeTypes: ['property_declaration'],
+    bodyNodeTypes: ['class_body'],
+    defaultVisibility: 'public',
+    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') {
+                for (let j = 0; j < child.namedChildCount; j++) {
+                    const ident = child.namedChild(j);
+                    if (ident?.type === 'simple_identifier')
+                        return ident.text;
+                }
+            }
+            if (child?.type === 'simple_identifier')
+                return child.text;
+        }
+        return undefined;
+    },
+    extractType(node) {
+        // property_declaration may have a user_type or type_identifier under variable_declaration
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child?.type === 'variable_declaration') {
+                for (let j = 0; j < child.namedChildCount; j++) {
+                    const t = child.namedChild(j);
+                    if (t && (t.type === 'user_type' || t.type === 'type_identifier'
+                        || t.type === 'nullable_type' || t.type === 'generic_type')) {
+                        return extractSimpleTypeName(t) ?? t.text?.trim();
+                    }
+                }
+            }
+            if (child?.type === 'user_type' || child?.type === 'nullable_type') {
+                return extractSimpleTypeName(child) ?? child.text?.trim();
+            }
+        }
+        return undefined;
+    },
+    extractVisibility(node) {
+        return findVisibility(node, KOTLIN_VIS, 'public', 'modifiers');
+    },
+    isStatic(_node) {
+        // Kotlin doesn't have static; companion object members are handled separately
+        return false;
+    },
+    isReadonly(node) {
+        // 'val' = readonly, 'var' = mutable
+        return hasKeyword(node, 'val');
+    },
+};

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

@@ -0,0 +1,8 @@
+import type { FieldExtractionConfig } from '../generic.js';
+/**
+ * PHP field extraction config.
+ *
+ * Handles property_declaration inside class/interface/trait bodies.
+ * tree-sitter-php uses 'declaration_list' for the class body.
+ */
+export declare const phpConfig: FieldExtractionConfig;

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

@@ -0,0 +1,67 @@
+// gitnexus/src/core/ingestion/field-extractors/configs/php.ts
+import { SupportedLanguages } from '../../../../config/supported-languages.js';
+import { findVisibility, hasKeyword } from './helpers.js';
+import { extractSimpleTypeName } from '../../type-extractors/shared.js';
+const PHP_VIS = new Set(['public', 'private', 'protected']);
+/**
+ * PHP field extraction config.
+ *
+ * Handles property_declaration inside class/interface/trait bodies.
+ * tree-sitter-php uses 'declaration_list' for the class body.
+ */
+export const phpConfig = {
+    language: SupportedLanguages.PHP,
+    typeDeclarationNodes: [
+        'class_declaration',
+        'interface_declaration',
+        'trait_declaration',
+    ],
+    fieldNodeTypes: ['property_declaration'],
+    bodyNodeTypes: ['declaration_list'],
+    defaultVisibility: 'public',
+    extractName(node) {
+        // property_declaration > property_element > variable_name ($varName)
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child?.type === 'property_element') {
+                const varName = child.childForFieldName('name')
+                    ?? child.firstNamedChild;
+                if (varName) {
+                    // strip leading $ from PHP variable names
+                    const text = varName.text;
+                    return text.startsWith('$') ? text.slice(1) : text;
+                }
+            }
+            // fallback: variable_name direct child
+            if (child?.type === 'variable_name') {
+                const text = child.text;
+                return text.startsWith('$') ? text.slice(1) : text;
+            }
+        }
+        return undefined;
+    },
+    extractType(node) {
+        // property_declaration may have a type before the property_element
+        // tree-sitter-php: type can be union_type, named_type, optional_type, primitive_type
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (!child)
+                continue;
+            if (child.type === 'union_type' || child.type === 'named_type'
+                || child.type === 'optional_type' || child.type === 'primitive_type'
+                || child.type === 'intersection_type' || child.type === 'nullable_type') {
+                return extractSimpleTypeName(child) ?? child.text?.trim();
+            }
+        }
+        return undefined;
+    },
+    extractVisibility(node) {
+        return findVisibility(node, PHP_VIS, 'public');
+    },
+    isStatic(node) {
+        return hasKeyword(node, 'static');
+    },
+    isReadonly(node) {
+        return hasKeyword(node, 'readonly');
+    },
+};

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

@@ -0,0 +1,12 @@
+import type { FieldExtractionConfig } from '../generic.js';
+/**
+ * Python field extraction config.
+ *
+ * Python class fields appear as:
+ * - Annotated assignments: `name: str = ""`
+ * - Plain assignments in __init__: `self.name = value`
+ *
+ * For AST-level extraction we handle expression_statement containing
+ * assignment or type nodes inside a class body block.
+ */
+export declare const pythonConfig: FieldExtractionConfig;

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

@@ -0,0 +1,91 @@
+// gitnexus/src/core/ingestion/field-extractors/configs/python.ts
+import { SupportedLanguages } from '../../../../config/supported-languages.js';
+import { extractSimpleTypeName } from '../../type-extractors/shared.js';
+/**
+ * Python field extraction config.
+ *
+ * Python class fields appear as:
+ * - Annotated assignments: `name: str = ""`
+ * - Plain assignments in __init__: `self.name = value`
+ *
+ * For AST-level extraction we handle expression_statement containing
+ * assignment or type nodes inside a class body block.
+ */
+export const pythonConfig = {
+    language: SupportedLanguages.Python,
+    typeDeclarationNodes: ['class_definition'],
+    fieldNodeTypes: ['expression_statement'],
+    bodyNodeTypes: ['block'],
+    defaultVisibility: 'public',
+    extractName(node) {
+        // expression_statement wrapping an assignment or type
+        const inner = node.firstNamedChild;
+        if (!inner)
+            return undefined;
+        // Annotated assignment:  name: str = "default"
+        // tree-sitter node: type (expression_statement (type (identifier) (type) ...))
+        if (inner.type === 'type') {
+            const ident = inner.childForFieldName('name') ?? inner.firstNamedChild;
+            return ident?.type === 'identifier' ? ident.text : undefined;
+        }
+        // assignment: x = 5  (class variable)
+        if (inner.type === 'assignment') {
+            const left = inner.childForFieldName('left');
+            if (left?.type === 'identifier')
+                return left.text;
+        }
+        return undefined;
+    },
+    extractType(node) {
+        const inner = node.firstNamedChild;
+        if (!inner)
+            return undefined;
+        // Annotated assignment with value: `name: str = "default"`
+        // AST: expression_statement > type > [identifier, type, ...]
+        if (inner.type === 'type') {
+            const typeNode = inner.childForFieldName('type') ?? inner.namedChild(1);
+            if (typeNode)
+                return extractSimpleTypeName(typeNode) ?? typeNode.text?.trim();
+        }
+        // Annotation without value: `address: Address`
+        // AST: expression_statement > assignment > [identifier, type]
+        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;
+    },
+    extractVisibility(node) {
+        const inner = node.firstNamedChild;
+        let name;
+        if (inner?.type === 'type') {
+            const ident = inner.childForFieldName('name') ?? inner.firstNamedChild;
+            name = ident?.text;
+        }
+        else if (inner?.type === 'assignment') {
+            const left = inner.childForFieldName('left');
+            name = left?.text;
+        }
+        if (!name)
+            return 'public';
+        if (name.startsWith('__') && !name.endsWith('__'))
+            return 'private';
+        if (name.startsWith('_'))
+            return 'protected';
+        return 'public';
+    },
+    isStatic(_node) {
+        // Reports syntactic static keyword — Python class variables don't use explicit static keyword.
+        // Instance variables (self.x) live in __init__ and are not extracted here.
+        return false;
+    },
+    isReadonly(_node) {
+        return false;
+    },
+};

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

@@ -0,0 +1,16 @@
+import type { FieldExtractionConfig } from '../generic.js';
+/**
+ * Ruby field extraction config.
+ *
+ * Ruby is unusual: there are no field declarations in the traditional sense.
+ * Fields are instance variables (@var) created by assignment, or declared
+ * via attr_accessor / attr_reader / attr_writer calls.
+ *
+ * We detect:
+ * - `call` nodes for attr_accessor / attr_reader / attr_writer
+ *   (their arguments are symbol names → field names)
+ *
+ * For simplicity we focus on attr_* calls in the class body.
+ * Instance variable assignments (self.x = ...) would require deeper analysis.
+ */
+export declare const rubyConfig: FieldExtractionConfig;

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

@@ -0,0 +1,75 @@
+// gitnexus/src/core/ingestion/field-extractors/configs/ruby.ts
+import { SupportedLanguages } from '../../../../config/supported-languages.js';
+/**
+ * Collect all field names declared by an `attr_accessor`, `attr_reader`, or
+ * `attr_writer` call node.  A single call may list multiple symbols:
+ *   attr_accessor :foo, :bar, :baz
+ */
+function extractAttrNames(node) {
+    const method = node.childForFieldName('method');
+    if (!method)
+        return [];
+    const methodName = method.text;
+    if (methodName !== 'attr_accessor' && methodName !== 'attr_reader'
+        && methodName !== 'attr_writer') {
+        return [];
+    }
+    const args = node.childForFieldName('arguments');
+    if (!args)
+        return [];
+    const names = [];
+    for (let i = 0; i < args.namedChildCount; i++) {
+        const arg = args.namedChild(i);
+        if (!arg)
+            continue;
+        // simple_symbol text is :name — strip the leading colon
+        const text = arg.text;
+        names.push(text.startsWith(':') ? text.slice(1) : text);
+    }
+    return names;
+}
+/**
+ * Ruby field extraction config.
+ *
+ * Ruby is unusual: there are no field declarations in the traditional sense.
+ * Fields are instance variables (@var) created by assignment, or declared
+ * via attr_accessor / attr_reader / attr_writer calls.
+ *
+ * We detect:
+ * - `call` nodes for attr_accessor / attr_reader / attr_writer
+ *   (their arguments are symbol names → field names)
+ *
+ * For simplicity we focus on attr_* calls in the class body.
+ * Instance variable assignments (self.x = ...) would require deeper analysis.
+ */
+export const rubyConfig = {
+    language: SupportedLanguages.Ruby,
+    typeDeclarationNodes: ['class'],
+    fieldNodeTypes: ['call'],
+    bodyNodeTypes: ['body_statement'],
+    defaultVisibility: 'public',
+    extractName(node) {
+        // Returns the first symbol name for interface compatibility.
+        // Use extractNames to obtain all names from a single attr_* call.
+        return extractAttrNames(node)[0];
+    },
+    extractNames(node) {
+        return extractAttrNames(node);
+    },
+    extractType(_node) {
+        // Ruby is dynamically typed; no type annotations in standard Ruby
+        return undefined;
+    },
+    extractVisibility(_node) {
+        // attr_accessor/attr_writer fields are effectively public
+        // attr_reader fields are read-only from outside but still public
+        return 'public';
+    },
+    isStatic(_node) {
+        return false;
+    },
+    isReadonly(node) {
+        const method = node.childForFieldName('method');
+        return method?.text === 'attr_reader';
+    },
+};

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

@@ -0,0 +1,9 @@
+import type { FieldExtractionConfig } from '../generic.js';
+/**
+ * Rust field extraction config.
+ *
+ * Handles struct fields (named and tuple variants are out of scope).
+ * Visibility: `pub` keyword = public, otherwise private (crate-private).
+ * All fields are immutable by default in Rust (mutability is on the binding).
+ */
+export declare const rustConfig: FieldExtractionConfig;