@codragraph/cli 1.6.2

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

@@ -0,0 +1,57 @@
+/**
+ * Export Detection
+ *
+ * Determines whether a symbol (function, class, etc.) is exported/public
+ * in its language. This is a pure function — safe for use in worker threads.
+ *
+ * Shared between parse-worker.ts (worker pool) and parsing-processor.ts (sequential fallback).
+ */
+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;
+/**
+ * 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 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 CodraGraph 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

@@ -0,0 +1,233 @@
+/**
+ * Export Detection
+ *
+ * Determines whether a symbol (function, class, etc.) is exported/public
+ * in its language. This is a pure function — safe for use in worker threads.
+ *
+ * Shared between parse-worker.ts (worker pool) and parsing-processor.ts (sequential fallback).
+ */
+import { findSiblingChild } from './utils/ast-helpers.js';
+// ============================================================================
+// Per-language export checkers
+// ============================================================================
+/** JS/TS: walk ancestors looking for export_statement or export_specifier. */
+export const tsExportChecker = (node, _name) => {
+    let current = node;
+    while (current) {
+        const type = current.type;
+        if (type === 'export_statement' ||
+            type === 'export_specifier' ||
+            (type === 'lexical_declaration' && current.parent?.type === 'export_statement')) {
+            return true;
+        }
+        // Fallback: check if node text starts with 'export ' for edge cases
+        if (current.text?.startsWith('export ')) {
+            return true;
+        }
+        current = current.parent;
+    }
+    return false;
+};
+/** Python: public if no leading underscore (convention). */
+export const pythonExportChecker = (_node, name) => !name.startsWith('_');
+/** Java: check for 'public' modifier — modifiers are siblings of the name node, not parents. */
+export const javaExportChecker = (node, _name) => {
+    let current = node;
+    while (current) {
+        if (current.parent) {
+            const parent = current.parent;
+            for (let i = 0; i < parent.childCount; i++) {
+                const child = parent.child(i);
+                if (child?.type === 'modifiers' && child.text?.includes('public')) {
+                    return true;
+                }
+            }
+            if (parent.type === 'method_declaration' || parent.type === 'constructor_declaration') {
+                if (parent.text?.trimStart().startsWith('public')) {
+                    return true;
+                }
+            }
+        }
+        current = current.parent;
+    }
+    return false;
+};
+/** C# declaration node types for sibling modifier scanning. */
+const CSHARP_DECL_TYPES = new Set([
+    'method_declaration',
+    'local_function_statement',
+    'constructor_declaration',
+    'class_declaration',
+    'interface_declaration',
+    'struct_declaration',
+    'enum_declaration',
+    'record_declaration',
+    // tree-sitter-c-sharp absorbs 'record struct' and 'record class' into
+    // record_declaration — these two node types are listed defensively but
+    // never emitted by the grammar in practice (verified against ^0.23.1).
+    'record_struct_declaration',
+    'record_class_declaration',
+    'delegate_declaration',
+    'property_declaration',
+    'field_declaration',
+    'event_declaration',
+    'namespace_declaration',
+    'file_scoped_namespace_declaration',
+]);
+/**
+ * C#: modifier nodes are SIBLINGS of the name node inside the declaration.
+ * Walk up to the declaration node, then scan its direct children.
+ */
+export const csharpExportChecker = (node, _name) => {
+    let current = node;
+    while (current) {
+        if (CSHARP_DECL_TYPES.has(current.type)) {
+            for (let i = 0; i < current.childCount; i++) {
+                const child = current.child(i);
+                if (child?.type === 'modifier' && child.text === 'public')
+                    return true;
+            }
+            return false;
+        }
+        current = current.parent;
+    }
+    return false;
+};
+/** Go: uppercase first letter = exported. */
+export const goExportChecker = (_node, name) => {
+    if (name.length === 0)
+        return false;
+    const first = name[0];
+    return first === first.toUpperCase() && first !== first.toLowerCase();
+};
+/** Rust declaration node types for sibling visibility_modifier scanning. */
+const RUST_DECL_TYPES = new Set([
+    'function_item',
+    'struct_item',
+    'enum_item',
+    'trait_item',
+    'impl_item',
+    'union_item',
+    'type_item',
+    'const_item',
+    'static_item',
+    'mod_item',
+    'use_declaration',
+    'associated_type',
+    'function_signature_item',
+]);
+/**
+ * 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 const rustExportChecker = (node, _name) => {
+    let current = node;
+    while (current) {
+        if (RUST_DECL_TYPES.has(current.type)) {
+            for (let i = 0; i < current.childCount; i++) {
+                const child = current.child(i);
+                if (child?.type === 'visibility_modifier' && child.text?.startsWith('pub'))
+                    return true;
+            }
+            return false;
+        }
+        current = current.parent;
+    }
+    return false;
+};
+/**
+ * Kotlin: default visibility is public (unlike Java).
+ * visibility_modifier is inside modifiers, a sibling of the name node within the declaration.
+ */
+export const kotlinExportChecker = (node, _name) => {
+    let current = node;
+    while (current) {
+        if (current.parent) {
+            const visMod = findSiblingChild(current.parent, 'modifiers', 'visibility_modifier');
+            if (visMod) {
+                const text = visMod.text;
+                if (text === 'private' || text === 'internal' || text === 'protected')
+                    return false;
+                if (text === 'public')
+                    return true;
+            }
+        }
+        current = current.parent;
+    }
+    // No visibility modifier = public (Kotlin default)
+    return true;
+};
+/**
+ * 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 const cCppExportChecker = (node, _name) => {
+    let cur = node;
+    while (cur) {
+        if (cur.type === 'function_definition' || cur.type === 'declaration') {
+            // Check for 'static' storage class specifier as a direct child node.
+            // This avoids reading the full function text (which can be very large).
+            for (let i = 0; i < cur.childCount; i++) {
+                const child = cur.child(i);
+                if (child?.type === 'storage_class_specifier' && child.text === 'static')
+                    return false;
+            }
+        }
+        // C++ anonymous namespace: namespace_definition with no name child = internal linkage
+        if (cur.type === 'namespace_definition') {
+            const hasName = cur.childForFieldName?.('name');
+            if (!hasName)
+                return false;
+        }
+        cur = cur.parent;
+    }
+    return true; // Top-level C/C++ functions default to external linkage
+};
+/** PHP: check for visibility modifier or top-level scope. */
+export const phpExportChecker = (node, _name) => {
+    let current = node;
+    while (current) {
+        if (current.type === 'class_declaration' ||
+            current.type === 'interface_declaration' ||
+            current.type === 'trait_declaration' ||
+            current.type === 'enum_declaration') {
+            return true;
+        }
+        if (current.type === 'visibility_modifier') {
+            return current.text === 'public';
+        }
+        current = current.parent;
+    }
+    // Top-level functions are globally accessible
+    return true;
+};
+/**
+ * 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 CodraGraph 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 || '';
+            // 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;
+    }
+    // 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 '../../_shared/index.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 @@
+// codragraph/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,104 @@
+// codragraph/src/core/ingestion/field-extractors/configs/c-cpp.ts
+import { SupportedLanguages } from '../../../../_shared/index.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,116 @@
+// codragraph/src/core/ingestion/field-extractors/configs/csharp.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+import { findVisibility, hasKeyword, hasModifier, collectModifierTexts } 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) {
+        // Detect compound C# visibilities: protected internal, private protected
+        const mods = collectModifierTexts(node);
+        if (mods.has('protected') && mods.has('internal'))
+            return 'protected internal';
+        if (mods.has('private') && mods.has('protected'))
+            return 'private protected';
+        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');
+    },
+    extractPrimaryFields(ownerNode, context) {
+        // C# record positional parameters become public init-only properties.
+        // C# 12 class primary constructor parameters are captured as private fields.
+        // The parameter_list has no field name — find it by type.
+        let paramList = null;
+        for (let i = 0; i < ownerNode.namedChildCount; i++) {
+            const child = ownerNode.namedChild(i);
+            if (child?.type === 'parameter_list') {
+                paramList = child;
+                break;
+            }
+        }
+        if (!paramList)
+            return [];
+        const isRecord = ownerNode.type === 'record_declaration';
+        const fields = [];
+        for (let i = 0; i < paramList.namedChildCount; i++) {
+            const param = paramList.namedChild(i);
+            if (!param || param.type !== 'parameter')
+                continue;
+            const nameNode = param.childForFieldName('name');
+            const typeNode = param.childForFieldName('type');
+            if (!nameNode)
+                continue;
+            fields.push({
+                name: nameNode.text,
+                type: typeNode ? (extractSimpleTypeName(typeNode) ?? typeNode.text?.trim() ?? null) : null,
+                // Record params are public init-only properties; class params are private captured fields
+                visibility: isRecord ? 'public' : 'private',
+                isStatic: false,
+                isReadonly: isRecord, // record properties are init-only (readonly)
+                sourceFile: context.filePath,
+                line: param.startPosition.row + 1,
+            });
+        }
+        return fields;
+    },
+};

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;

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

@@ -0,0 +1,78 @@
+// codragraph/src/core/ingestion/field-extractors/configs/dart.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+import { hasKeyword } from './helpers.js';
+import { extractSimpleTypeName } from '../../type-extractors/shared.js';
+/**
+ * Dart field extraction config.
+ *
+ * Dart class fields appear as declaration nodes inside class_body.
+ * Visibility is convention-based: underscore prefix = private.
+ */
+export const dartConfig = {
+    language: SupportedLanguages.Dart,
+    typeDeclarationNodes: ['class_definition'],
+    fieldNodeTypes: ['declaration'],
+    bodyNodeTypes: ['class_body'],
+    defaultVisibility: 'public',
+    extractName(node) {
+        // declaration > initialized_identifier_list > initialized_identifier > identifier
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child?.type === 'initialized_identifier_list') {
+                for (let j = 0; j < child.namedChildCount; j++) {
+                    const init = child.namedChild(j);
+                    if (init?.type === 'initialized_identifier') {
+                        const ident = init.firstNamedChild;
+                        if (ident?.type === 'identifier')
+                            return ident.text;
+                    }
+                }
+            }
+            if (child?.type === 'initialized_identifier') {
+                const ident = child.firstNamedChild;
+                if (ident?.type === 'identifier')
+                    return ident.text;
+            }
+        }
+        // fallback: look for direct identifier
+        const name = node.childForFieldName('name');
+        return name?.text;
+    },
+    extractType(node) {
+        // declaration > type_identifier (first named child usually)
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child &&
+                (child.type === 'type_identifier' ||
+                    child.type === 'generic_type' ||
+                    child.type === 'function_type')) {
+                return extractSimpleTypeName(child) ?? child.text?.trim();
+            }
+        }
+        return undefined;
+    },
+    extractVisibility(node) {
+        // Dart uses _ prefix for private
+        // Walk to find the identifier name
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child?.type === 'initialized_identifier_list') {
+                for (let j = 0; j < child.namedChildCount; j++) {
+                    const init = child.namedChild(j);
+                    if (init?.type === 'initialized_identifier') {
+                        const ident = init.firstNamedChild;
+                        if (ident?.text?.startsWith('_'))
+                            return 'private';
+                    }
+                }
+            }
+        }
+        return 'public';
+    },
+    isStatic(node) {
+        return hasKeyword(node, 'static');
+    },
+    isReadonly(node) {
+        return hasKeyword(node, 'final') || hasKeyword(node, 'const');
+    },
+};