@codragraph/cli 1.6.2

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

@@ -0,0 +1,76 @@
+// codragraph/src/core/ingestion/field-extractors/configs/ruby.ts
+import { SupportedLanguages } from '../../../../_shared/index.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;

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

@@ -0,0 +1,52 @@
+// codragraph/src/core/ingestion/field-extractors/configs/rust.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+import { extractSimpleTypeName } from '../../type-extractors/shared.js';
+import { hasKeyword } from './helpers.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 const rustConfig = {
+    language: SupportedLanguages.Rust,
+    typeDeclarationNodes: ['struct_item', 'enum_item'],
+    fieldNodeTypes: ['field_declaration'],
+    bodyNodeTypes: ['field_declaration_list'],
+    defaultVisibility: 'private',
+    extractName(node) {
+        const name = node.childForFieldName('name');
+        if (name)
+            return name.text;
+        // fallback: first field_identifier
+        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) {
+        const typeNode = node.childForFieldName('type');
+        if (typeNode)
+            return extractSimpleTypeName(typeNode) ?? typeNode.text?.trim();
+        return undefined;
+    },
+    extractVisibility(node) {
+        // Check for visibility_modifier named child (pub, pub(crate), pub(super))
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child?.type === 'visibility_modifier')
+                return 'public';
+        }
+        return hasKeyword(node, 'pub') ? 'public' : 'private';
+    },
+    isStatic(_node) {
+        return false; // Rust struct fields are never static
+    },
+    isReadonly(_node) {
+        // All Rust fields are immutable by default (mutability is per-binding)
+        return true;
+    },
+};

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

@@ -0,0 +1,8 @@
+import type { FieldExtractionConfig } from '../generic.js';
+/**
+ * Swift field extraction config.
+ *
+ * Handles property_declaration inside class_body / protocol_body.
+ * tree-sitter-swift uses property_declaration for stored/computed properties.
+ */
+export declare const swiftConfig: FieldExtractionConfig;

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

@@ -0,0 +1,65 @@
+// codragraph/src/core/ingestion/field-extractors/configs/swift.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+import { hasKeyword, findVisibility } from './helpers.js';
+import { extractSimpleTypeName } from '../../type-extractors/shared.js';
+const SWIFT_VIS = new Set([
+    'public',
+    'private',
+    'fileprivate',
+    'internal',
+    'open',
+]);
+/**
+ * Swift field extraction config.
+ *
+ * Handles property_declaration inside class_body / protocol_body.
+ * tree-sitter-swift uses property_declaration for stored/computed properties.
+ */
+export const swiftConfig = {
+    language: SupportedLanguages.Swift,
+    typeDeclarationNodes: ['class_declaration', 'struct_declaration', 'protocol_declaration'],
+    fieldNodeTypes: ['property_declaration'],
+    bodyNodeTypes: ['class_body', 'protocol_body'],
+    defaultVisibility: 'internal',
+    extractName(node) {
+        // property_declaration > pattern > simple_identifier
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child?.type === 'pattern') {
+                for (let j = 0; j < child.namedChildCount; j++) {
+                    const ident = child.namedChild(j);
+                    if (ident?.type === 'simple_identifier')
+                        return ident.text;
+                }
+                return child.text;
+            }
+            if (child?.type === 'simple_identifier')
+                return child.text;
+        }
+        // fallback: childForFieldName('name')
+        const name = node.childForFieldName('name');
+        return name?.text;
+    },
+    extractType(node) {
+        // property_declaration > type_annotation > type_identifier
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child?.type === 'type_annotation') {
+                const inner = child.firstNamedChild;
+                if (inner)
+                    return extractSimpleTypeName(inner) ?? inner.text?.trim();
+            }
+        }
+        return undefined;
+    },
+    extractVisibility(node) {
+        return findVisibility(node, SWIFT_VIS, 'internal', 'modifiers');
+    },
+    isStatic(node) {
+        return hasKeyword(node, 'static') || hasKeyword(node, 'class');
+    },
+    isReadonly(node) {
+        // 'let' = constant/readonly, 'var' = variable
+        return hasKeyword(node, 'let');
+    },
+};

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

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

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

@@ -0,0 +1,56 @@
+// codragraph/src/core/ingestion/field-extractors/configs/typescript-javascript.ts
+import { SupportedLanguages } from '../../../../_shared/index.js';
+import { hasKeyword, findVisibility, typeFromAnnotation } from './helpers.js';
+const VISIBILITY_KEYWORDS = new Set(['public', 'private', 'protected']);
+const shared = {
+    typeDeclarationNodes: [
+        'class_declaration',
+        'abstract_class_declaration',
+        'interface_declaration',
+    ],
+    fieldNodeTypes: ['public_field_definition', 'property_signature', 'field_definition'],
+    bodyNodeTypes: ['class_body', 'interface_body', 'object_type'],
+    defaultVisibility: 'public',
+    extractName(node) {
+        const nameNode = node.childForFieldName('name') ?? node.childForFieldName('property');
+        return nameNode?.text;
+    },
+    extractType(node) {
+        // tree-sitter TS uses a named 'type' field for type_annotation
+        const typeField = node.childForFieldName('type');
+        if (typeField) {
+            if (typeField.type === 'type_annotation') {
+                const inner = typeField.firstNamedChild;
+                return inner?.text?.trim();
+            }
+            return typeField.text?.trim();
+        }
+        return typeFromAnnotation(node);
+    },
+    extractVisibility(node) {
+        // TypeScript accessibility_modifier
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child && child.type === 'accessibility_modifier') {
+                const t = child.text.trim();
+                if (VISIBILITY_KEYWORDS.has(t))
+                    return t;
+            }
+        }
+        return findVisibility(node, VISIBILITY_KEYWORDS, 'public', 'modifiers');
+    },
+    isStatic(node) {
+        return hasKeyword(node, 'static');
+    },
+    isReadonly(node) {
+        return hasKeyword(node, 'readonly');
+    },
+};
+export const typescriptConfig = {
+    ...shared,
+    language: SupportedLanguages.TypeScript,
+};
+export const javascriptConfig = {
+    ...shared,
+    language: SupportedLanguages.JavaScript,
+};

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

@@ -0,0 +1,49 @@
+/**
+ * Generic table-driven field extractor factory.
+ *
+ * Instead of 14 separate 300-line files, define a config per language and
+ * generate extractors from configs.  The factory creates a class extending
+ * BaseFieldExtractor whose behaviour is entirely driven by FieldExtractionConfig.
+ */
+import type { SyntaxNode } from '../utils/ast-helpers.js';
+import { SupportedLanguages } from '../../../_shared/index.js';
+import type { FieldExtractor } from '../field-extractor.js';
+import type { FieldExtractorContext, FieldInfo, FieldVisibility } from '../field-types.js';
+export interface FieldExtractionConfig {
+    language: SupportedLanguages;
+    /** AST node types that are class/struct/interface declarations */
+    typeDeclarationNodes: string[];
+    /** AST node types that represent field/property declarations inside a body */
+    fieldNodeTypes: string[];
+    /** AST node type(s) for the class body container (e.g., 'class_body', 'declaration_list') */
+    bodyNodeTypes: string[];
+    /** Default visibility when no modifier is present */
+    defaultVisibility: FieldVisibility;
+    /**
+     * Extract field name from a field declaration node.
+     * Use this for nodes that declare exactly one field.
+     */
+    extractName: (node: SyntaxNode) => string | undefined;
+    /**
+     * Extract multiple field names from a single declaration node.
+     * Optional override for languages where one AST node can declare
+     * several fields (e.g. Ruby `attr_accessor :foo, :bar`).
+     * When present, the factory uses this instead of `extractName`.
+     */
+    extractNames?: (node: SyntaxNode) => string[];
+    /** Extract type annotation from a field declaration node */
+    extractType: (node: SyntaxNode) => string | undefined;
+    /** Extract visibility from a field declaration node */
+    extractVisibility: (node: SyntaxNode) => FieldVisibility;
+    /** Check if a field is static */
+    isStatic: (node: SyntaxNode) => boolean;
+    /** Check if a field is readonly/final/const */
+    isReadonly: (node: SyntaxNode) => boolean;
+    /** Extract fields from primary constructor parameters on the owner node itself
+     *  (e.g. C# record positional parameters, C# 12 class primary constructors). */
+    extractPrimaryFields?: (ownerNode: SyntaxNode, context: FieldExtractorContext) => FieldInfo[];
+}
+/**
+ * Create a FieldExtractor from a declarative config.
+ */
+export declare function createFieldExtractor(config: FieldExtractionConfig): FieldExtractor;

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

@@ -0,0 +1,117 @@
+// codragraph/src/core/ingestion/field-extractors/generic.ts
+import { BaseFieldExtractor } from '../field-extractor.js';
+// ---------------------------------------------------------------------------
+// Factory
+// ---------------------------------------------------------------------------
+/**
+ * Create a FieldExtractor from a declarative config.
+ */
+export function createFieldExtractor(config) {
+    const typeDeclarationSet = new Set(config.typeDeclarationNodes);
+    const fieldNodeSet = new Set(config.fieldNodeTypes);
+    const bodyNodeSet = new Set(config.bodyNodeTypes);
+    class GenericFieldExtractor extends BaseFieldExtractor {
+        language = config.language;
+        isTypeDeclaration(node) {
+            return typeDeclarationSet.has(node.type);
+        }
+        extractVisibility(node) {
+            return config.extractVisibility(node);
+        }
+        extract(node, context) {
+            if (!this.isTypeDeclaration(node))
+                return null;
+            const nameNode = node.childForFieldName('name');
+            if (!nameNode)
+                return null;
+            const ownerFqn = nameNode.text;
+            const fields = [];
+            // Find body container(s)
+            const bodies = this.findBodies(node);
+            for (const body of bodies) {
+                this.extractFieldsFromBody(body, context, fields);
+            }
+            // Extract fields from primary constructor parameters (e.g. C# records)
+            if (config.extractPrimaryFields) {
+                const primaryFields = config.extractPrimaryFields(node, context);
+                for (const f of primaryFields)
+                    fields.push(f);
+            }
+            return { ownerFqn, fields, nestedTypes: [] };
+        }
+        // ------------------------------------------------------------------
+        // private helpers
+        // ------------------------------------------------------------------
+        findBodies(node) {
+            const result = [];
+            // Try named 'body' field first
+            const bodyField = node.childForFieldName('body');
+            if (bodyField && bodyNodeSet.has(bodyField.type)) {
+                result.push(bodyField);
+                return result;
+            }
+            // Walk immediate children for matching body node types
+            for (let i = 0; i < node.namedChildCount; i++) {
+                const child = node.namedChild(i);
+                if (child && bodyNodeSet.has(child.type)) {
+                    result.push(child);
+                }
+            }
+            // Fallback: use the body field even if its type is not in bodyNodeSet
+            if (result.length === 0 && bodyField) {
+                result.push(bodyField);
+            }
+            return result;
+        }
+        extractFieldsFromBody(body, context, out) {
+            for (let i = 0; i < body.namedChildCount; i++) {
+                const child = body.namedChild(i);
+                if (!child)
+                    continue;
+                if (fieldNodeSet.has(child.type)) {
+                    if (config.extractNames) {
+                        // Multi-name path: one node may declare several fields (e.g. Ruby attr_accessor)
+                        const names = config.extractNames(child);
+                        for (const name of names) {
+                            const field = this.buildField(child, name, context);
+                            if (field)
+                                out.push(field);
+                        }
+                    }
+                    else {
+                        const field = this.extractSingleField(child, context);
+                        if (field)
+                            out.push(field);
+                    }
+                }
+            }
+        }
+        extractSingleField(node, context) {
+            const name = config.extractName(node);
+            if (!name)
+                return null;
+            return this.buildField(node, name, context);
+        }
+        buildField(node, name, context) {
+            if (!name)
+                return null;
+            let type = config.extractType(node) ?? null;
+            if (type) {
+                type = this.normalizeType(type);
+                const resolved = this.resolveType(type, context);
+                if (resolved)
+                    type = resolved;
+            }
+            return {
+                name,
+                type,
+                visibility: config.extractVisibility(node),
+                isStatic: config.isStatic(node),
+                isReadonly: config.isReadonly(node),
+                sourceFile: context.filePath,
+                line: node.startPosition.row + 1,
+            };
+        }
+    }
+    return new GenericFieldExtractor();
+}

package/dist/core/ingestion/field-extractors/typescript.d.ts

@@ -0,0 +1,77 @@
+import type { SyntaxNode } from '../utils/ast-helpers.js';
+import { SupportedLanguages } from '../../../_shared/index.js';
+import { BaseFieldExtractor } from '../field-extractor.js';
+import type { FieldExtractorContext, ExtractedFields, FieldVisibility } from '../field-types.js';
+/**
+ * Hand-written TypeScript field extractor.
+ *
+ * This exists alongside the config-based extractor in configs/typescript-javascript.ts
+ * (used for JavaScript) because TypeScript has unique requirements:
+ * 1. type_alias_declaration with object type literals (e.g., type Config = { key: string })
+ * 2. Optional property detection appending '| undefined' to types
+ * 3. Nested type discovery within class/interface bodies
+ *
+ * The config-based extractor cannot express these TS-specific capabilities.
+ * JavaScript uses the config-based version since it lacks type syntax.
+ */
+export declare class TypeScriptFieldExtractor extends BaseFieldExtractor {
+    language: SupportedLanguages;
+    /**
+     * Node types that represent type declarations with fields in TypeScript
+     */
+    private static readonly TYPE_DECLARATION_NODES;
+    /**
+     * Node types that contain field definitions within class bodies
+     */
+    private static readonly FIELD_NODE_TYPES;
+    /**
+     * Visibility modifiers in TypeScript
+     */
+    private static readonly VISIBILITY_MODIFIERS;
+    /**
+     * Check if this node represents a type declaration with fields
+     */
+    isTypeDeclaration(node: SyntaxNode): boolean;
+    /**
+     * Extract visibility modifier from a field node
+     */
+    protected extractVisibility(node: SyntaxNode): FieldVisibility;
+    /**
+     * Check if a field has the static modifier
+     */
+    private isStatic;
+    /**
+     * Check if a field has the readonly modifier
+     */
+    private isReadonly;
+    /**
+     * Check if a property is optional (has ?: syntax)
+     */
+    private isOptional;
+    /**
+     * Extract the full type text, handling complex generic types.
+     *
+     * type_annotation nodes wrap the literal ': SomeType' — only that branch
+     * needs special handling to unwrap the inner child and skip the colon.
+     * All other node kinds are already the type text itself, so normalizeType
+     * is applied directly.
+     */
+    private extractFullType;
+    /**
+     * Extract a single field from a field definition node
+     */
+    private extractField;
+    /**
+     * Extract fields from a class body or interface body
+     */
+    private extractFieldsFromBody;
+    /**
+     * Extract fields from an object type (used in type aliases)
+     */
+    private extractFieldsFromObjectType;
+    /**
+     * Extract fields from a class or interface declaration
+     */
+    extract(node: SyntaxNode, context: FieldExtractorContext): ExtractedFields | null;
+}
+export declare const typescriptFieldExtractor: TypeScriptFieldExtractor;