gitnexus 1.4.7 → 1.4.9

package/dist/core/ingestion/entry-point-scoring.d.ts

@@ -10,6 +10,23 @@
  * This module is language-agnostic - language-specific patterns are defined per language.
  */
 import { SupportedLanguages } from '../../config/supported-languages.js';
+export declare const ENTRY_POINT_PATTERNS: {
+    javascript: RegExp[];
+    typescript: RegExp[];
+    python: RegExp[];
+    java: RegExp[];
+    kotlin: RegExp[];
+    csharp: RegExp[];
+    go: RegExp[];
+    rust: RegExp[];
+    c: RegExp[];
+    cpp: RegExp[];
+    swift: RegExp[];
+    php: RegExp[];
+    ruby: RegExp[];
+    dart: RegExp[];
+    cobol: any[];
+};
 export interface EntryPointScoreResult {
     score: number;
     reasons: string[];

package/dist/core/ingestion/entry-point-scoring.js

@@ -12,28 +12,31 @@
 import { detectFrameworkFromPath } from './framework-detection.js';
 import { SupportedLanguages } from '../../config/supported-languages.js';
 // ============================================================================
-// NAME PATTERNS - All 11 supported languages
+// NAME PATTERNS - All 13 supported languages
 // ============================================================================
 /**
- * Common entry point naming patterns by language
- * These patterns indicate functions that are likely feature entry points
+ * Common entry point naming patterns by language.
+ * These patterns indicate functions that are likely feature entry points.
+ *
+ * Universal patterns are separated from per-language patterns so the per-language
+ * table can use `satisfies Record<SupportedLanguages, RegExp[]>` for compile-time
+ * exhaustiveness — the compiler catches any missing language entry.
  */
-const ENTRY_POINT_PATTERNS = {
-    // Universal patterns (apply to all languages)
-    '*': [
-        /^(main|init|bootstrap|start|run|setup|configure)$/i,
-        /^handle[A-Z]/, // handleLogin, handleSubmit
-        /^on[A-Z]/, // onClick, onSubmit
-        /Handler$/, // RequestHandler
-        /Controller$/, // UserController
-        /^process[A-Z]/, // processPayment
-        /^execute[A-Z]/, // executeQuery
-        /^perform[A-Z]/, // performAction
-        /^dispatch[A-Z]/, // dispatchEvent
-        /^trigger[A-Z]/, // triggerAction
-        /^fire[A-Z]/, // fireEvent
-        /^emit[A-Z]/, // emitEvent
-    ],
+const UNIVERSAL_ENTRY_POINT_PATTERNS = [
+    /^(main|init|bootstrap|start|run|setup|configure)$/i,
+    /^handle[A-Z]/, // handleLogin, handleSubmit
+    /^on[A-Z]/, // onClick, onSubmit
+    /Handler$/, // RequestHandler
+    /Controller$/, // UserController
+    /^process[A-Z]/, // processPayment
+    /^execute[A-Z]/, // executeQuery
+    /^perform[A-Z]/, // performAction
+    /^dispatch[A-Z]/, // dispatchEvent
+    /^trigger[A-Z]/, // triggerAction
+    /^fire[A-Z]/, // fireEvent
+    /^emit[A-Z]/, // emitEvent
+];
+export const ENTRY_POINT_PATTERNS = {
     // JavaScript/TypeScript
     [SupportedLanguages.JavaScript]: [
         /^use[A-Z]/, // React hooks (useEffect, etc.)
@@ -55,6 +58,16 @@ const ENTRY_POINT_PATTERNS = {
         /^build[A-Z]/, // Builder patterns
         /Service$/, // UserService
     ],
+    // Kotlin
+    [SupportedLanguages.Kotlin]: [
+        /^on(Create|Start|Resume|Pause|Stop|Destroy)$/, // Android lifecycle
+        /^do[A-Z]/, // doGet, doPost (shared JVM Servlet pattern)
+        /^create[A-Z]/, // Factory patterns
+        /^build[A-Z]/, // Builder patterns
+        /ViewModel$/, // MVVM pattern (Android)
+        /^module$/, // Ktor module entry point
+        /Service$/, // Service classes
+    ],
     // C#
     [SupportedLanguages.CSharp]: [
         /^(Get|Post|Put|Delete|Patch)/, // ASP.NET action methods
@@ -184,15 +197,26 @@ const ENTRY_POINT_PATTERNS = {
         /^perform$/, // Background jobs (Sidekiq, ActiveJob)
         /^execute$/, // Command pattern
     ],
+    // Dart / Flutter
+    [SupportedLanguages.Dart]: [
+        /^main$/, // App entry
+        /^build$/, // Widget.build — fundamental Flutter render entry point
+        /^createState$/, // StatefulWidget.createState
+        /^initState$/, // State lifecycle initialization
+        /^dispose$/, // State lifecycle teardown
+        /^didChangeDependencies$/, // State lifecycle — InheritedWidget changes
+        /^didUpdateWidget$/, // State lifecycle — widget rebuild with new config
+        /^runApp$/, // App entry point
+        /^onEvent$/, // BLoC event handler
+        /^mapEventToState$/, // Legacy BLoC pattern
+    ],
+    [SupportedLanguages.Cobol]: [], // Standalone regex processor — no tree-sitter entry points
 };
 /** Pre-computed merged patterns (universal + language-specific) to avoid per-call array allocation. */
-const MERGED_ENTRY_POINT_PATTERNS = {};
-const UNIVERSAL_PATTERNS = ENTRY_POINT_PATTERNS['*'] || [];
-for (const [lang, patterns] of Object.entries(ENTRY_POINT_PATTERNS)) {
-    if (lang === '*')
-        continue;
-    MERGED_ENTRY_POINT_PATTERNS[lang] = [...UNIVERSAL_PATTERNS, ...patterns];
-}
+const MERGED_ENTRY_POINT_PATTERNS = Object.fromEntries(Object.values(SupportedLanguages).map(lang => [
+    lang,
+    [...UNIVERSAL_ENTRY_POINT_PATTERNS, ...(ENTRY_POINT_PATTERNS[lang] ?? [])],
+]));
 // ============================================================================
 // UTILITY PATTERNS - Functions that should be penalized
 // ============================================================================
@@ -258,8 +282,8 @@ export function calculateEntryPointScore(name, language, isExported, callerCount
     }
     else {
         // Check positive patterns
-        const allPatterns = MERGED_ENTRY_POINT_PATTERNS[language] || UNIVERSAL_PATTERNS;
-        if (allPatterns.some(p => p.test(name))) {
+        const allPatterns = MERGED_ENTRY_POINT_PATTERNS[language];
+        if (allPatterns?.some(p => p.test(name))) {
             nameMultiplier = 1.5; // Bonus for matching entry point pattern
             reasons.push('entry-pattern');
         }

package/dist/core/ingestion/export-detection.d.ts

@@ -6,13 +6,52 @@
  *
  * Shared between parse-worker.ts (worker pool) and parsing-processor.ts (sequential fallback).
  */
-import { SyntaxNode } from './utils.js';
-import { SupportedLanguages } from '../../config/supported-languages.js';
+import { type SyntaxNode } from './utils/ast-helpers.js';
+/** Handler type: given a node and symbol name, return true if the symbol is exported/public. */
+export type ExportChecker = (node: SyntaxNode, name: string) => boolean;
+/** JS/TS: walk ancestors looking for export_statement or export_specifier. */
+export declare const tsExportChecker: ExportChecker;
+/** Python: public if no leading underscore (convention). */
+export declare const pythonExportChecker: ExportChecker;
+/** Java: check for 'public' modifier — modifiers are siblings of the name node, not parents. */
+export declare const javaExportChecker: ExportChecker;
 /**
- * Check if a tree-sitter node is exported/public in its language.
- * @param node - The tree-sitter AST node
- * @param name - The symbol name
- * @param language - The programming language
- * @returns true if the symbol is exported/public
+ * C#: modifier nodes are SIBLINGS of the name node inside the declaration.
+ * Walk up to the declaration node, then scan its direct children.
  */
-export declare const isNodeExported: (node: SyntaxNode, name: string, language: SupportedLanguages) => boolean;
+export declare const csharpExportChecker: ExportChecker;
+/** Go: uppercase first letter = exported. */
+export declare const goExportChecker: ExportChecker;
+/**
+ * Rust: visibility_modifier is a SIBLING of the name node within the declaration node
+ * (function_item, struct_item, etc.), not a parent. Walk up to the declaration node,
+ * then scan its direct children.
+ */
+export declare const rustExportChecker: ExportChecker;
+/**
+ * Kotlin: default visibility is public (unlike Java).
+ * visibility_modifier is inside modifiers, a sibling of the name node within the declaration.
+ */
+export declare const kotlinExportChecker: ExportChecker;
+/**
+ * C/C++: functions without 'static' storage class have external linkage by default,
+ * making them globally accessible (equivalent to exported). Only functions explicitly
+ * marked 'static' are file-scoped (not exported). C++ anonymous namespaces
+ * (namespace { ... }) also give internal linkage.
+ */
+export declare const cCppExportChecker: ExportChecker;
+/** PHP: check for visibility modifier or top-level scope. */
+export declare const phpExportChecker: ExportChecker;
+/**
+ * Swift: treat symbols as exported unless explicitly marked private/fileprivate.
+ *
+ * Swift's default access level is `internal`, which means visible to all files
+ * in the same module/target. Since GitNexus indexes at the target level,
+ * `internal` symbols should be treated as exported (cross-file visible).
+ * Only `private` and `fileprivate` symbols are truly file-scoped.
+ */
+export declare const swiftExportChecker: ExportChecker;
+/** Ruby: all top-level definitions are public (no export syntax). */
+export declare const rubyExportChecker: ExportChecker;
+/** Dart: public if no leading underscore (convention, same as Python). */
+export declare const dartExportChecker: ExportChecker;

package/dist/core/ingestion/export-detection.js

@@ -6,13 +6,12 @@
  *
  * Shared between parse-worker.ts (worker pool) and parsing-processor.ts (sequential fallback).
  */
-import { findSiblingChild } from './utils.js';
-import { SupportedLanguages } from '../../config/supported-languages.js';
+import { findSiblingChild } from './utils/ast-helpers.js';
 // ============================================================================
 // Per-language export checkers
 // ============================================================================
 /** JS/TS: walk ancestors looking for export_statement or export_specifier. */
-const tsExportChecker = (node, _name) => {
+export const tsExportChecker = (node, _name) => {
     let current = node;
     while (current) {
         const type = current.type;
@@ -30,9 +29,9 @@ const tsExportChecker = (node, _name) => {
     return false;
 };
 /** Python: public if no leading underscore (convention). */
-const pythonExportChecker = (_node, name) => !name.startsWith('_');
+export const pythonExportChecker = (_node, name) => !name.startsWith('_');
 /** Java: check for 'public' modifier — modifiers are siblings of the name node, not parents. */
-const javaExportChecker = (node, _name) => {
+export const javaExportChecker = (node, _name) => {
     let current = node;
     while (current) {
         if (current.parent) {
@@ -66,7 +65,7 @@ const CSHARP_DECL_TYPES = new Set([
  * C#: modifier nodes are SIBLINGS of the name node inside the declaration.
  * Walk up to the declaration node, then scan its direct children.
  */
-const csharpExportChecker = (node, _name) => {
+export const csharpExportChecker = (node, _name) => {
     let current = node;
     while (current) {
         if (CSHARP_DECL_TYPES.has(current.type)) {
@@ -82,7 +81,7 @@ const csharpExportChecker = (node, _name) => {
     return false;
 };
 /** Go: uppercase first letter = exported. */
-const goExportChecker = (_node, name) => {
+export const goExportChecker = (_node, name) => {
     if (name.length === 0)
         return false;
     const first = name[0];
@@ -99,7 +98,7 @@ const RUST_DECL_TYPES = new Set([
  * (function_item, struct_item, etc.), not a parent. Walk up to the declaration node,
  * then scan its direct children.
  */
-const rustExportChecker = (node, _name) => {
+export const rustExportChecker = (node, _name) => {
     let current = node;
     while (current) {
         if (RUST_DECL_TYPES.has(current.type)) {
@@ -118,7 +117,7 @@ const rustExportChecker = (node, _name) => {
  * Kotlin: default visibility is public (unlike Java).
  * visibility_modifier is inside modifiers, a sibling of the name node within the declaration.
  */
-const kotlinExportChecker = (node, _name) => {
+export const kotlinExportChecker = (node, _name) => {
     let current = node;
     while (current) {
         if (current.parent) {
@@ -142,7 +141,7 @@ const kotlinExportChecker = (node, _name) => {
  * marked 'static' are file-scoped (not exported). C++ anonymous namespaces
  * (namespace { ... }) also give internal linkage.
  */
-const cCppExportChecker = (node, _name) => {
+export const cCppExportChecker = (node, _name) => {
     let cur = node;
     while (cur) {
         if (cur.type === 'function_definition' || cur.type === 'declaration') {
@@ -165,7 +164,7 @@ const cCppExportChecker = (node, _name) => {
     return true; // Top-level C/C++ functions default to external linkage
 };
 /** PHP: check for visibility modifier or top-level scope. */
-const phpExportChecker = (node, _name) => {
+export const phpExportChecker = (node, _name) => {
     let current = node;
     while (current) {
         if (current.type === 'class_declaration' ||
@@ -182,50 +181,30 @@ const phpExportChecker = (node, _name) => {
     // Top-level functions are globally accessible
     return true;
 };
-/** Swift: check for 'public' or 'open' access modifiers. */
-const swiftExportChecker = (node, _name) => {
+/**
+ * Swift: treat symbols as exported unless explicitly marked private/fileprivate.
+ *
+ * Swift's default access level is `internal`, which means visible to all files
+ * in the same module/target. Since GitNexus indexes at the target level,
+ * `internal` symbols should be treated as exported (cross-file visible).
+ * Only `private` and `fileprivate` symbols are truly file-scoped.
+ */
+export const swiftExportChecker = (node, _name) => {
     let current = node;
     while (current) {
         if (current.type === 'modifiers' || current.type === 'visibility_modifier') {
             const text = current.text || '';
-            if (text.includes('public') || text.includes('open'))
-                return true;
+            // Exclude private(set)/fileprivate(set) — only the setter is restricted,
+            // the symbol itself is still readable cross-file.
+            if (/\b(private|fileprivate)\b(?!\s*\()/.test(text))
+                return false;
         }
         current = current.parent;
     }
-    return false;
-};
-// ============================================================================
-// Exhaustive dispatch table — satisfies enforces all SupportedLanguages are covered
-// ============================================================================
-const exportCheckers = {
-    [SupportedLanguages.JavaScript]: tsExportChecker,
-    [SupportedLanguages.TypeScript]: tsExportChecker,
-    [SupportedLanguages.Python]: pythonExportChecker,
-    [SupportedLanguages.Java]: javaExportChecker,
-    [SupportedLanguages.CSharp]: csharpExportChecker,
-    [SupportedLanguages.Go]: goExportChecker,
-    [SupportedLanguages.Rust]: rustExportChecker,
-    [SupportedLanguages.Kotlin]: kotlinExportChecker,
-    [SupportedLanguages.C]: cCppExportChecker,
-    [SupportedLanguages.CPlusPlus]: cCppExportChecker,
-    [SupportedLanguages.PHP]: phpExportChecker,
-    [SupportedLanguages.Swift]: swiftExportChecker,
-    [SupportedLanguages.Ruby]: (_node, _name) => true,
-};
-// ============================================================================
-// Public API
-// ============================================================================
-/**
- * Check if a tree-sitter node is exported/public in its language.
- * @param node - The tree-sitter AST node
- * @param name - The symbol name
- * @param language - The programming language
- * @returns true if the symbol is exported/public
- */
-export const isNodeExported = (node, name, language) => {
-    const checker = exportCheckers[language];
-    if (!checker)
-        return false;
-    return checker(node, name);
+    // Default (internal), public, and open are all cross-file visible
+    return true;
 };
+/** Ruby: all top-level definitions are public (no export syntax). */
+export const rubyExportChecker = (_node, _name) => true;
+/** Dart: public if no leading underscore (convention, same as Python). */
+export const dartExportChecker = (_node, name) => !name.startsWith('_');

package/dist/core/ingestion/field-extractor.d.ts

@@ -0,0 +1,29 @@
+import type { SyntaxNode } from './utils/ast-helpers.js';
+import { SupportedLanguages } from '../../config/supported-languages.js';
+import type { FieldExtractorContext, ExtractedFields, FieldVisibility } from './field-types.js';
+/**
+ * Language-specific field extractor
+ */
+export interface FieldExtractor {
+    /** Language this extractor handles */
+    language: SupportedLanguages;
+    /**
+     * Extract fields from a class/struct/interface declaration
+     */
+    extract(node: SyntaxNode, context: FieldExtractorContext): ExtractedFields | null;
+    /**
+     * Check if this node represents a type declaration with fields
+     */
+    isTypeDeclaration(node: SyntaxNode): boolean;
+}
+/**
+ * Base class for field extractors with common utilities
+ */
+export declare abstract class BaseFieldExtractor implements FieldExtractor {
+    abstract language: SupportedLanguages;
+    abstract extract(node: SyntaxNode, context: FieldExtractorContext): ExtractedFields | null;
+    abstract isTypeDeclaration(node: SyntaxNode): boolean;
+    protected normalizeType(type: string | null): string | null;
+    protected resolveType(typeName: string, context: FieldExtractorContext): string | null;
+    protected abstract extractVisibility(node: SyntaxNode): FieldVisibility;
+}

package/dist/core/ingestion/field-extractor.js

@@ -0,0 +1,25 @@
+// gitnexus/src/core/ingestion/field-extractor.ts
+/**
+ * Base class for field extractors with common utilities
+ */
+export class BaseFieldExtractor {
+    normalizeType(type) {
+        if (!type)
+            return null;
+        return type.trim().replace(/\s+/g, ' ');
+    }
+    resolveType(typeName, context) {
+        const { typeEnv, symbolTable, filePath } = context;
+        // Try to find in type environment (check file scope first)
+        const fileEnv = typeEnv.fileScope();
+        const local = fileEnv.get(typeName);
+        if (local)
+            return local;
+        // Try symbol table lookup in current file
+        const symbols = symbolTable.lookupExactAll(filePath, typeName);
+        if (symbols.length === 1) {
+            return symbols[0].nodeId;
+        }
+        return typeName;
+    }
+}

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

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

package/dist/core/ingestion/field-extractors/configs/c-cpp.js

@@ -0,0 +1,108 @@
+// gitnexus/src/core/ingestion/field-extractors/configs/c-cpp.ts
+import { SupportedLanguages } from '../../../../config/supported-languages.js';
+import { hasKeyword } from './helpers.js';
+import { extractSimpleTypeName } from '../../type-extractors/shared.js';
+/**
+ * Detect C++ access specifier (public:/private:/protected:) by walking
+ * backwards from the field node through siblings.
+ */
+function cppAccessSpecifier(node) {
+    let sibling = node.previousNamedSibling;
+    while (sibling) {
+        if (sibling.type === 'access_specifier') {
+            const text = sibling.text.replace(':', '').trim();
+            if (text === 'public' || text === 'private' || text === 'protected')
+                return text;
+        }
+        sibling = sibling.previousNamedSibling;
+    }
+    return undefined;
+}
+function extractFieldName(node) {
+    // field_declaration > declarator:(field_identifier | pointer_declarator > field_identifier)
+    const declarator = node.childForFieldName('declarator');
+    if (declarator) {
+        if (declarator.type === 'field_identifier')
+            return declarator.text;
+        // pointer_declarator: *fieldName
+        for (let i = 0; i < declarator.namedChildCount; i++) {
+            const child = declarator.namedChild(i);
+            if (child?.type === 'field_identifier')
+                return child.text;
+        }
+        return declarator.text;
+    }
+    // fallback
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child?.type === 'field_identifier')
+            return child.text;
+    }
+    return undefined;
+}
+function extractFieldType(node) {
+    const typeNode = node.childForFieldName('type');
+    if (typeNode)
+        return extractSimpleTypeName(typeNode) ?? typeNode.text?.trim();
+    // fallback: first child that is a type node
+    const first = node.firstNamedChild;
+    if (first && (first.type === 'type_identifier' || first.type === 'primitive_type'
+        || first.type === 'sized_type_specifier' || first.type === 'template_type')) {
+        return extractSimpleTypeName(first) ?? first.text?.trim();
+    }
+    return undefined;
+}
+// ---------------------------------------------------------------------------
+// C++ config
+// ---------------------------------------------------------------------------
+export const cppConfig = {
+    language: SupportedLanguages.CPlusPlus,
+    typeDeclarationNodes: [
+        'struct_specifier',
+        'class_specifier',
+        'union_specifier',
+    ],
+    fieldNodeTypes: ['field_declaration'],
+    bodyNodeTypes: ['field_declaration_list'],
+    defaultVisibility: 'private', // C++ class default is private
+    extractName: extractFieldName,
+    extractType: extractFieldType,
+    extractVisibility(node) {
+        const access = cppAccessSpecifier(node);
+        if (access)
+            return access;
+        // struct default = public, class default = private
+        const parent = node.parent?.parent;
+        return parent?.type === 'struct_specifier' ? 'public' : 'private';
+    },
+    isStatic(node) {
+        return hasKeyword(node, 'static');
+    },
+    isReadonly(node) {
+        return hasKeyword(node, 'const');
+    },
+};
+// ---------------------------------------------------------------------------
+// C config (subset of C++)
+// ---------------------------------------------------------------------------
+export const cConfig = {
+    language: SupportedLanguages.C,
+    typeDeclarationNodes: [
+        'struct_specifier',
+        'union_specifier',
+    ],
+    fieldNodeTypes: ['field_declaration'],
+    bodyNodeTypes: ['field_declaration_list'],
+    defaultVisibility: 'public', // C structs are always public
+    extractName: extractFieldName,
+    extractType: extractFieldType,
+    extractVisibility(_node) {
+        return 'public'; // C has no access control
+    },
+    isStatic(node) {
+        return hasKeyword(node, 'static');
+    },
+    isReadonly(node) {
+        return hasKeyword(node, 'const');
+    },
+};

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

@@ -0,0 +1,8 @@
+import type { FieldExtractionConfig } from '../generic.js';
+/**
+ * C# field extraction config.
+ *
+ * Handles field_declaration and property_declaration inside class/struct/interface bodies.
+ * The body node in tree-sitter-c-sharp is 'declaration_list'.
+ */
+export declare const csharpConfig: FieldExtractionConfig;

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

@@ -0,0 +1,73 @@
+// gitnexus/src/core/ingestion/field-extractors/configs/csharp.ts
+import { SupportedLanguages } from '../../../../config/supported-languages.js';
+import { findVisibility, hasKeyword, hasModifier } from './helpers.js';
+import { extractSimpleTypeName } from '../../type-extractors/shared.js';
+const CSHARP_VIS = new Set(['public', 'private', 'protected', 'internal']);
+/**
+ * C# field extraction config.
+ *
+ * Handles field_declaration and property_declaration inside class/struct/interface bodies.
+ * The body node in tree-sitter-c-sharp is 'declaration_list'.
+ */
+export const csharpConfig = {
+    language: SupportedLanguages.CSharp,
+    typeDeclarationNodes: [
+        'class_declaration',
+        'struct_declaration',
+        'interface_declaration',
+        'record_declaration',
+    ],
+    fieldNodeTypes: ['field_declaration', 'property_declaration'],
+    bodyNodeTypes: ['declaration_list'],
+    defaultVisibility: 'private',
+    extractName(node) {
+        // field_declaration > variable_declaration > variable_declarator > 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 declarator = child.namedChild(j);
+                    if (declarator?.type === 'variable_declarator') {
+                        const name = declarator.childForFieldName('name');
+                        return name?.text ?? declarator.firstNamedChild?.text;
+                    }
+                }
+            }
+        }
+        // property_declaration: name field
+        const nameNode = node.childForFieldName('name');
+        if (nameNode)
+            return nameNode.text;
+        return undefined;
+    },
+    extractType(node) {
+        // field_declaration > variable_declaration > type:(predefined_type | identifier | ...)
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child?.type === 'variable_declaration') {
+                const typeNode = child.childForFieldName('type');
+                if (typeNode)
+                    return extractSimpleTypeName(typeNode) ?? typeNode.text?.trim();
+                // fallback: first child that is a type
+                const first = child.firstNamedChild;
+                if (first && first.type !== 'variable_declarator') {
+                    return extractSimpleTypeName(first) ?? first.text?.trim();
+                }
+            }
+        }
+        // property_declaration: type is first named child
+        const typeNode = node.childForFieldName('type');
+        if (typeNode)
+            return extractSimpleTypeName(typeNode) ?? typeNode.text?.trim();
+        return undefined;
+    },
+    extractVisibility(node) {
+        return findVisibility(node, CSHARP_VIS, 'private', 'modifier');
+    },
+    isStatic(node) {
+        return hasKeyword(node, 'static') || hasModifier(node, 'modifier', 'static');
+    },
+    isReadonly(node) {
+        return hasKeyword(node, 'readonly') || hasModifier(node, 'modifier', 'readonly');
+    },
+};

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

@@ -0,0 +1,8 @@
+import type { FieldExtractionConfig } from '../generic.js';
+/**
+ * Dart field extraction config.
+ *
+ * Dart class fields appear as declaration nodes inside class_body.
+ * Visibility is convention-based: underscore prefix = private.
+ */
+export declare const dartConfig: FieldExtractionConfig;