@claudetools/tools 0.9.0 → 0.9.2

package/dist/codedna/kappa-parser.js

@@ -34,6 +34,7 @@ class KappaParser extends CstParser {
                 { ALT: () => this.SUBRULE(this.componentBlock) },
                 { ALT: () => this.SUBRULE(this.formBlock) },
                 { ALT: () => this.SUBRULE(this.designBlock) },
+                { ALT: () => this.SUBRULE(this.testBlock) },
             ]);
         });
     });
@@ -1167,6 +1168,261 @@ class KappaParser extends CstParser {
             { ALT: () => this.CONSUME(tokens.StringLiteral) },
         ]);
     });
+    // ---------------------------------------------------------------------------
+    // Test Block
+    // ---------------------------------------------------------------------------
+    // test UserTests {
+    //   target: User
+    //   framework: vitest
+    //   type: unit
+    //   describe "User entity" {
+    //     it "creates a user" { ... }
+    //   }
+    // }
+    testBlock = this.RULE('testBlock', () => {
+        this.CONSUME(tokens.Test);
+        this.CONSUME(tokens.PascalIdentifier); // Test suite name
+        this.CONSUME(tokens.LBrace);
+        this.MANY(() => {
+            this.OR([
+                { ALT: () => this.SUBRULE(this.testProperty) },
+                { ALT: () => this.SUBRULE(this.testSuite) },
+                { ALT: () => this.SUBRULE(this.testMock) },
+            ]);
+        });
+        this.CONSUME(tokens.RBrace);
+    });
+    // target: User, framework: vitest, type: unit, coverage: { ... }
+    testProperty = this.RULE('testProperty', () => {
+        this.OR([
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Target);
+                    this.CONSUME(tokens.Colon);
+                    this.CONSUME(tokens.PascalIdentifier);
+                },
+            },
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Framework);
+                    this.CONSUME2(tokens.Colon);
+                    this.OR2([
+                        { ALT: () => this.CONSUME(tokens.Vitest) },
+                        { ALT: () => this.CONSUME(tokens.Jest) },
+                        { ALT: () => this.CONSUME(tokens.Playwright) },
+                        { ALT: () => this.CONSUME(tokens.Cypress) },
+                    ]);
+                },
+            },
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Identifier); // 'type' keyword
+                    this.CONSUME3(tokens.Colon);
+                    this.OR3([
+                        { ALT: () => this.CONSUME2(tokens.Identifier) }, // unit, integration, e2e
+                    ]);
+                },
+            },
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Coverage);
+                    this.CONSUME4(tokens.Colon);
+                    this.CONSUME(tokens.LBrace);
+                    this.MANY(() => {
+                        this.SUBRULE(this.coverageProperty);
+                    });
+                    this.CONSUME(tokens.RBrace);
+                },
+            },
+        ]);
+    });
+    coverageProperty = this.RULE('coverageProperty', () => {
+        this.CONSUME(tokens.Identifier); // statements, branches, functions, lines
+        this.CONSUME(tokens.Colon);
+        this.CONSUME(tokens.IntegerLiteral);
+    });
+    // describe "Suite name" { ... }
+    testSuite = this.RULE('testSuite', () => {
+        this.CONSUME(tokens.Describe);
+        this.CONSUME(tokens.StringLiteral);
+        this.CONSUME(tokens.LBrace);
+        this.MANY(() => {
+            this.OR([
+                { ALT: () => this.SUBRULE(this.testLifecycle) },
+                { ALT: () => this.SUBRULE(this.testCase) },
+                { ALT: () => this.SUBRULE2(this.testSuite) }, // Nested suites
+                { ALT: () => this.SUBRULE2(this.testMock) },
+            ]);
+        });
+        this.CONSUME(tokens.RBrace);
+    });
+    // beforeAll { ... }, afterEach { ... }, etc.
+    testLifecycle = this.RULE('testLifecycle', () => {
+        this.OR([
+            { ALT: () => this.CONSUME(tokens.BeforeAll) },
+            { ALT: () => this.CONSUME(tokens.AfterAll) },
+            { ALT: () => this.CONSUME(tokens.BeforeEach) },
+            { ALT: () => this.CONSUME(tokens.AfterEach) },
+        ]);
+        this.CONSUME(tokens.LBrace);
+        this.MANY(() => {
+            this.CONSUME(tokens.StringLiteral); // Code statements as strings
+        });
+        this.CONSUME(tokens.RBrace);
+    });
+    // mock ModuleName { returns: "value" }
+    testMock = this.RULE('testMock', () => {
+        this.CONSUME(tokens.Mock);
+        this.OR([
+            { ALT: () => this.CONSUME(tokens.PascalIdentifier) },
+            { ALT: () => this.CONSUME(tokens.StringLiteral) },
+        ]);
+        this.OPTION(() => {
+            this.CONSUME(tokens.LBrace);
+            this.MANY(() => {
+                this.SUBRULE(this.mockProperty);
+            });
+            this.CONSUME(tokens.RBrace);
+        });
+    });
+    mockProperty = this.RULE('mockProperty', () => {
+        this.OR([
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Returns);
+                    this.CONSUME(tokens.Colon);
+                    this.CONSUME(tokens.StringLiteral);
+                },
+            },
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Identifier); // implementation, etc.
+                    this.CONSUME2(tokens.Colon);
+                    this.CONSUME2(tokens.StringLiteral);
+                },
+            },
+        ]);
+    });
+    // it "test name" { setup: [...], action: "...", expect: [...] }
+    // it "test name", skip { ... }
+    // it "test name", only { ... }
+    testCase = this.RULE('testCase', () => {
+        this.CONSUME(tokens.It);
+        this.CONSUME(tokens.StringLiteral);
+        this.OPTION(() => {
+            this.CONSUME(tokens.Comma);
+            this.OR([
+                { ALT: () => this.CONSUME(tokens.Skip) },
+                { ALT: () => this.CONSUME(tokens.Only) },
+                { ALT: () => this.CONSUME(tokens.Todo) },
+            ]);
+        });
+        this.CONSUME(tokens.LBrace);
+        this.MANY(() => {
+            this.SUBRULE(this.testCaseSection);
+        });
+        this.CONSUME(tokens.RBrace);
+    });
+    testCaseSection = this.RULE('testCaseSection', () => {
+        this.OR([
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Setup);
+                    this.CONSUME(tokens.Colon);
+                    this.CONSUME(tokens.LBracket);
+                    this.MANY_SEP({
+                        SEP: tokens.Comma,
+                        DEF: () => this.CONSUME(tokens.StringLiteral),
+                    });
+                    this.CONSUME(tokens.RBracket);
+                },
+            },
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Action);
+                    this.CONSUME2(tokens.Colon);
+                    this.CONSUME2(tokens.StringLiteral);
+                },
+            },
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Teardown);
+                    this.CONSUME3(tokens.Colon);
+                    this.CONSUME2(tokens.LBracket);
+                    this.MANY_SEP2({
+                        SEP: tokens.Comma,
+                        DEF: () => this.CONSUME3(tokens.StringLiteral),
+                    });
+                    this.CONSUME2(tokens.RBracket);
+                },
+            },
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Expect);
+                    this.CONSUME4(tokens.Colon);
+                    this.CONSUME3(tokens.LBracket);
+                    this.MANY_SEP3({
+                        SEP: tokens.Comma,
+                        DEF: () => this.SUBRULE(this.testAssertion),
+                    });
+                    this.CONSUME3(tokens.RBracket);
+                },
+            },
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Timeout);
+                    this.CONSUME5(tokens.Colon);
+                    this.CONSUME(tokens.IntegerLiteral);
+                },
+            },
+        ]);
+    });
+    // { actual: "expr", type: equals, expected: "value" }
+    testAssertion = this.RULE('testAssertion', () => {
+        this.CONSUME(tokens.LBrace);
+        this.MANY_SEP({
+            SEP: tokens.Comma,
+            DEF: () => this.SUBRULE(this.assertionProperty),
+        });
+        this.CONSUME(tokens.RBrace);
+    });
+    assertionProperty = this.RULE('assertionProperty', () => {
+        this.OR([
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Identifier); // actual, expected, message
+                    this.CONSUME(tokens.Colon);
+                    this.CONSUME(tokens.StringLiteral);
+                },
+            },
+            {
+                ALT: () => {
+                    this.CONSUME2(tokens.Identifier); // type
+                    this.CONSUME2(tokens.Colon);
+                    this.SUBRULE(this.assertionType);
+                },
+            },
+        ]);
+    });
+    assertionType = this.RULE('assertionType', () => {
+        this.OR([
+            { ALT: () => this.CONSUME(tokens.EqualsAssertion) },
+            { ALT: () => this.CONSUME(tokens.NotEquals) },
+            { ALT: () => this.CONSUME(tokens.Contains) },
+            { ALT: () => this.CONSUME(tokens.Matches) },
+            { ALT: () => this.CONSUME(tokens.Throws) },
+            { ALT: () => this.CONSUME(tokens.Resolves) },
+            { ALT: () => this.CONSUME(tokens.Rejects) },
+            { ALT: () => this.CONSUME(tokens.Truthy) },
+            { ALT: () => this.CONSUME(tokens.Falsy) },
+            { ALT: () => this.CONSUME(tokens.Defined) },
+            { ALT: () => this.CONSUME(tokens.Undefined) },
+            { ALT: () => this.CONSUME(tokens.Null) },
+            { ALT: () => this.CONSUME(tokens.InstanceOf) },
+            { ALT: () => this.CONSUME(tokens.LengthOf) },
+            { ALT: () => this.CONSUME(tokens.DeepEquals) },
+        ]);
+    });
 }
 // =============================================================================
 // Parser Instance
@@ -1252,6 +1508,9 @@ class KappaAstBuilder extends BaseCstVisitor {
             : [];
         const forms = ctx.formBlock ? ctx.formBlock.map((f) => this.visit(f)) : [];
         const design = ctx.designBlock ? this.visit(ctx.designBlock) : undefined;
+        const tests = ctx.testBlock
+            ? ctx.testBlock.map((t) => this.visit(t))
+            : [];
         return {
             kind: 'KappaSpec',
             loc: this.getLocation(ctx),
@@ -1264,6 +1523,7 @@ class KappaAstBuilder extends BaseCstVisitor {
             components,
             forms,
             design,
+            tests,
         };
     }
     // Project block visitor
@@ -1545,6 +1805,12 @@ class KappaAstBuilder extends BaseCstVisitor {
             'Time',
             'Text',
             'Primary',
+            // Additional keywords commonly used as field names
+            'Title',
+            'Label',
+            'State',
+            'Version',
+            'Color',
         ];
         for (const tokenType of tokenTypes) {
             const token = ctx[tokenType]?.[0];
@@ -2497,6 +2763,341 @@ class KappaAstBuilder extends BaseCstVisitor {
             value = ctx.StringLiteral[0].image.slice(1, -1);
         return { name, value };
     }
+    // ---------------------------------------------------------------------------
+    // Test Block Visitors
+    // ---------------------------------------------------------------------------
+    testBlock(ctx) {
+        const name = (ctx.PascalIdentifier?.[0])?.image ?? '';
+        // Parse properties
+        let target = '';
+        let framework = 'vitest';
+        let type = 'unit';
+        let coverage;
+        if (ctx.testProperty) {
+            for (const prop of ctx.testProperty) {
+                const result = this.visit(prop);
+                if (result.type === 'target')
+                    target = result.value;
+                else if (result.type === 'framework')
+                    framework = result.value;
+                else if (result.type === 'testType')
+                    type = result.value;
+                else if (result.type === 'coverage')
+                    coverage = result.value;
+            }
+        }
+        // Parse suites
+        const suites = ctx.testSuite
+            ? ctx.testSuite.map((s) => this.visit(s))
+            : [];
+        // Parse mocks
+        const mocks = ctx.testMock
+            ? ctx.testMock.map((m) => this.visit(m))
+            : [];
+        // Build root suite
+        const rootSuite = {
+            kind: 'TestSuite',
+            loc: this.getLocation(ctx),
+            name,
+            mocks,
+            tests: [],
+            suites,
+        };
+        return {
+            kind: 'TestBlock',
+            loc: this.getLocation(ctx),
+            name,
+            target,
+            framework,
+            type,
+            suite: rootSuite,
+            coverage,
+        };
+    }
+    testProperty(ctx) {
+        if (ctx.Target) {
+            return {
+                type: 'target',
+                value: (ctx.PascalIdentifier?.[0])?.image ?? '',
+            };
+        }
+        if (ctx.Framework) {
+            let fw = 'vitest';
+            if (ctx.Vitest)
+                fw = 'vitest';
+            else if (ctx.Jest)
+                fw = 'jest';
+            else if (ctx.Playwright)
+                fw = 'playwright';
+            else if (ctx.Cypress)
+                fw = 'cypress';
+            return { type: 'framework', value: fw };
+        }
+        if (ctx.Coverage) {
+            const coverageProps = ctx.coverageProperty
+                ? ctx.coverageProperty.map((p) => this.visit(p))
+                : [];
+            const coverage = {};
+            for (const prop of coverageProps) {
+                coverage[prop.name] = prop.value;
+            }
+            return { type: 'coverage', value: coverage };
+        }
+        // Default: type property
+        const identifiers = ctx.Identifier;
+        if (identifiers && identifiers.length >= 2) {
+            return { type: 'testType', value: identifiers[1].image };
+        }
+        return { type: 'testType', value: 'unit' };
+    }
+    coverageProperty(ctx) {
+        return {
+            name: ctx.Identifier?.[0]?.image ?? '',
+            value: parseInt(ctx.IntegerLiteral?.[0]?.image ?? '0', 10),
+        };
+    }
+    testSuite(ctx) {
+        const name = (ctx.StringLiteral?.[0])?.image?.slice(1, -1) ?? '';
+        // Parse lifecycle hooks
+        const lifecycles = ctx.testLifecycle
+            ? ctx.testLifecycle.map((l) => this.visit(l))
+            : [];
+        let beforeAll;
+        let afterAll;
+        let beforeEach;
+        let afterEach;
+        for (const lc of lifecycles) {
+            if (lc.type === 'beforeAll')
+                beforeAll = lc.statements;
+            else if (lc.type === 'afterAll')
+                afterAll = lc.statements;
+            else if (lc.type === 'beforeEach')
+                beforeEach = lc.statements;
+            else if (lc.type === 'afterEach')
+                afterEach = lc.statements;
+        }
+        // Parse test cases
+        const tests = ctx.testCase
+            ? ctx.testCase.map((t) => this.visit(t))
+            : [];
+        // Parse nested suites
+        const suites = ctx.testSuite
+            ? ctx.testSuite.map((s) => this.visit(s))
+            : [];
+        // Parse mocks
+        const mocks = ctx.testMock
+            ? ctx.testMock.map((m) => this.visit(m))
+            : [];
+        return {
+            kind: 'TestSuite',
+            loc: this.getLocation(ctx),
+            name,
+            beforeAll,
+            afterAll,
+            beforeEach,
+            afterEach,
+            mocks,
+            tests,
+            suites,
+        };
+    }
+    testLifecycle(ctx) {
+        let type = 'beforeEach';
+        if (ctx.BeforeAll)
+            type = 'beforeAll';
+        else if (ctx.AfterAll)
+            type = 'afterAll';
+        else if (ctx.BeforeEach)
+            type = 'beforeEach';
+        else if (ctx.AfterEach)
+            type = 'afterEach';
+        const statements = ctx.StringLiteral
+            ? ctx.StringLiteral.map((s) => s.image.slice(1, -1))
+            : [];
+        return { type, statements };
+    }
+    testMock(ctx) {
+        let target = '';
+        if (ctx.PascalIdentifier) {
+            target = (ctx.PascalIdentifier?.[0])?.image ?? '';
+        }
+        else if (ctx.StringLiteral) {
+            target = (ctx.StringLiteral?.[0])?.image?.slice(1, -1) ?? '';
+        }
+        let returns;
+        let implementation;
+        if (ctx.mockProperty) {
+            for (const prop of ctx.mockProperty) {
+                const result = this.visit(prop);
+                if (result.type === 'returns')
+                    returns = result.value;
+                else if (result.type === 'implementation')
+                    implementation = result.value;
+            }
+        }
+        return {
+            kind: 'TestMock',
+            loc: this.getLocation(ctx),
+            target,
+            returns,
+            implementation,
+        };
+    }
+    mockProperty(ctx) {
+        if (ctx.Returns) {
+            return {
+                type: 'returns',
+                value: (ctx.StringLiteral?.[0])?.image?.slice(1, -1) ?? '',
+            };
+        }
+        // implementation or other property
+        const identifier = (ctx.Identifier?.[0])?.image ?? '';
+        const value = (ctx.StringLiteral?.[0])?.image?.slice(1, -1) ?? '';
+        return { type: identifier, value };
+    }
+    testCase(ctx) {
+        const name = (ctx.StringLiteral?.[0])?.image?.slice(1, -1) ?? '';
+        let skip = false;
+        let only = false;
+        let todo = false;
+        if (ctx.Skip)
+            skip = true;
+        if (ctx.Only)
+            only = true;
+        if (ctx.Todo)
+            todo = true;
+        // Parse sections
+        let setup;
+        let action = '';
+        let teardown;
+        let timeout;
+        const assertions = [];
+        if (ctx.testCaseSection) {
+            for (const section of ctx.testCaseSection) {
+                const result = this.visit(section);
+                if (result.type === 'setup')
+                    setup = result.value;
+                else if (result.type === 'action')
+                    action = result.value;
+                else if (result.type === 'teardown')
+                    teardown = result.value;
+                else if (result.type === 'timeout')
+                    timeout = result.value;
+                else if (result.type === 'expect')
+                    assertions.push(...result.value);
+            }
+        }
+        return {
+            kind: 'TestCase',
+            loc: this.getLocation(ctx),
+            name,
+            setup,
+            action,
+            assertions,
+            teardown,
+            skip,
+            only,
+            todo,
+            timeout,
+        };
+    }
+    testCaseSection(ctx) {
+        if (ctx.Setup) {
+            const statements = ctx.StringLiteral
+                ? ctx.StringLiteral.map((s) => s.image.slice(1, -1))
+                : [];
+            return { type: 'setup', value: statements };
+        }
+        if (ctx.Action) {
+            const value = (ctx.StringLiteral?.[0])?.image?.slice(1, -1) ?? '';
+            return { type: 'action', value };
+        }
+        if (ctx.Teardown) {
+            const statements = ctx.StringLiteral
+                ? ctx.StringLiteral.map((s) => s.image.slice(1, -1))
+                : [];
+            return { type: 'teardown', value: statements };
+        }
+        if (ctx.Expect) {
+            const assertions = ctx.testAssertion
+                ? ctx.testAssertion.map((a) => this.visit(a))
+                : [];
+            return { type: 'expect', value: assertions };
+        }
+        if (ctx.Timeout) {
+            const value = parseInt((ctx.IntegerLiteral?.[0])?.image ?? '0', 10);
+            return { type: 'timeout', value };
+        }
+        return { type: 'unknown', value: null };
+    }
+    testAssertion(ctx) {
+        let actual = '';
+        let type = 'equals';
+        let expected;
+        let message;
+        if (ctx.assertionProperty) {
+            for (const prop of ctx.assertionProperty) {
+                const result = this.visit(prop);
+                if (result.name === 'actual')
+                    actual = result.value;
+                else if (result.name === 'expected')
+                    expected = result.value;
+                else if (result.name === 'message')
+                    message = result.value;
+                else if (result.name === 'type')
+                    type = result.value;
+            }
+        }
+        return {
+            kind: 'TestAssertion',
+            loc: this.getLocation(ctx),
+            actual,
+            type,
+            expected,
+            message,
+        };
+    }
+    assertionProperty(ctx) {
+        const identifier = (ctx.Identifier?.[0])?.image ?? '';
+        if (ctx.assertionType) {
+            return { name: 'type', value: this.visit(ctx.assertionType) };
+        }
+        const value = (ctx.StringLiteral?.[0])?.image?.slice(1, -1) ?? '';
+        return { name: identifier, value };
+    }
+    assertionType(ctx) {
+        if (ctx.EqualsAssertion)
+            return 'equals';
+        if (ctx.NotEquals)
+            return 'notEquals';
+        if (ctx.Contains)
+            return 'contains';
+        if (ctx.Matches)
+            return 'matches';
+        if (ctx.Throws)
+            return 'throws';
+        if (ctx.Resolves)
+            return 'resolves';
+        if (ctx.Rejects)
+            return 'rejects';
+        if (ctx.Truthy)
+            return 'truthy';
+        if (ctx.Falsy)
+            return 'falsy';
+        if (ctx.Defined)
+            return 'defined';
+        if (ctx.Undefined)
+            return 'undefined';
+        if (ctx.Null)
+            return 'null';
+        if (ctx.InstanceOf)
+            return 'instanceOf';
+        if (ctx.LengthOf)
+            return 'lengthOf';
+        if (ctx.DeepEquals)
+            return 'deepEquals';
+        return 'equals';
+    }
 }
 // =============================================================================
 // Parse Function

package/dist/codedna/kappa-radix-generator.d.ts

@@ -0,0 +1,61 @@
+import type { ComponentBlock } from './kappa-ast.js';
+export interface RadixGeneratorOptions {
+    /** Add provenance comments (default: true) */
+    provenance?: boolean;
+    /** Generate TypeScript (default: true) */
+    typescript?: boolean;
+    /** Base path for components (default: 'components/ui') */
+    basePath?: string;
+    /** Include accessibility documentation comments (default: true) */
+    a11yDocs?: boolean;
+}
+export interface GeneratedRadixComponent {
+    /** Component file path */
+    path: string;
+    /** Component content */
+    content: string;
+    /** Radix primitive used */
+    primitive: RadixPrimitive;
+}
+export interface GeneratedRadixComponents {
+    /** Generated component files */
+    components: GeneratedRadixComponent[];
+    /** Required Radix UI dependencies */
+    dependencies: string[];
+}
+export type RadixPrimitive = 'Dialog' | 'Popover' | 'Select' | 'Checkbox' | 'RadioGroup' | 'Switch' | 'Slider' | 'Tabs' | 'Accordion' | 'DropdownMenu' | 'ContextMenu' | 'HoverCard' | 'Tooltip' | 'AlertDialog' | 'AspectRatio' | 'Avatar' | 'Collapsible' | 'Label' | 'Progress' | 'ScrollArea' | 'Separator' | 'Toggle' | 'ToggleGroup';
+export declare class KappaRadixGenerator {
+    private provenance;
+    private typescript;
+    private basePath;
+    private a11yDocs;
+    private usedDependencies;
+    constructor(options?: RadixGeneratorOptions);
+    /**
+     * Generate Radix UI component files from ComponentBlock AST nodes
+     */
+    generate(components: ComponentBlock[]): GeneratedRadixComponents;
+    private detectPrimitive;
+    private generateRadixComponent;
+    private generateRadixImports;
+    private getUsedRadixParts;
+    private mapCompoundPartToRadix;
+    private generateSimpleRadixComponent;
+    private generateRadixPropsInterface;
+    private generateRadixStructureJSX;
+    private mapStructureToRadixComponent;
+    private generateCompoundRadixComponent;
+    private generateRadixCompoundPart;
+    private generateSimpleComponent;
+    private getSimpleDestructuredProps;
+    private getVariantClassName;
+    private getElementType;
+    private getElementTag;
+    private getDestructuredProps;
+    private mapPropType;
+    private toKebabCase;
+}
+/**
+ * Generate Radix UI component files from Kappa ComponentBlock nodes
+ */
+export declare function generateRadixComponents(components: ComponentBlock[], options?: RadixGeneratorOptions): GeneratedRadixComponents;