@claudetools/tools 0.9.0 → 0.9.2

package/dist/codedna/kappa-radix-generator.js

@@ -0,0 +1,566 @@
+// =============================================================================
+// Kappa v2.5 Radix UI Component Generator
+// =============================================================================
+//
+// Generates React components using Radix UI primitives from Kappa ComponentBlock AST.
+// Supports compound components, accessibility props, and Radix composition patterns.
+//
+// Radix UI provides unstyled, accessible components that can be composed with
+// Tailwind CSS for complete design control while maintaining accessibility.
+//
+const RADIX_MAPPINGS = {
+    Dialog: {
+        primitive: 'Dialog',
+        packageName: '@radix-ui/react-dialog',
+        requiredParts: ['Root', 'Trigger', 'Portal', 'Overlay', 'Content'],
+        optionalParts: ['Close', 'Title', 'Description'],
+    },
+    Modal: {
+        primitive: 'Dialog',
+        packageName: '@radix-ui/react-dialog',
+        requiredParts: ['Root', 'Trigger', 'Portal', 'Overlay', 'Content'],
+        optionalParts: ['Close', 'Title', 'Description'],
+    },
+    Popover: {
+        primitive: 'Popover',
+        packageName: '@radix-ui/react-popover',
+        requiredParts: ['Root', 'Trigger', 'Portal', 'Content'],
+        optionalParts: ['Anchor', 'Close', 'Arrow'],
+    },
+    Select: {
+        primitive: 'Select',
+        packageName: '@radix-ui/react-select',
+        requiredParts: ['Root', 'Trigger', 'Portal', 'Content', 'Viewport', 'Item'],
+        optionalParts: ['Value', 'Icon', 'ScrollUpButton', 'ScrollDownButton', 'Group', 'Label', 'Separator'],
+    },
+    Dropdown: {
+        primitive: 'DropdownMenu',
+        packageName: '@radix-ui/react-dropdown-menu',
+        requiredParts: ['Root', 'Trigger', 'Portal', 'Content', 'Item'],
+        optionalParts: ['Group', 'Label', 'Separator', 'CheckboxItem', 'RadioGroup', 'RadioItem', 'Sub', 'SubTrigger', 'SubContent'],
+    },
+    Tabs: {
+        primitive: 'Tabs',
+        packageName: '@radix-ui/react-tabs',
+        requiredParts: ['Root', 'List', 'Trigger', 'Content'],
+        optionalParts: [],
+    },
+    Accordion: {
+        primitive: 'Accordion',
+        packageName: '@radix-ui/react-accordion',
+        requiredParts: ['Root', 'Item', 'Trigger', 'Content'],
+        optionalParts: ['Header'],
+    },
+    Tooltip: {
+        primitive: 'Tooltip',
+        packageName: '@radix-ui/react-tooltip',
+        requiredParts: ['Provider', 'Root', 'Trigger', 'Portal', 'Content'],
+        optionalParts: ['Arrow'],
+    },
+};
+// =============================================================================
+// Generator Class
+// =============================================================================
+export class KappaRadixGenerator {
+    provenance;
+    typescript;
+    basePath;
+    a11yDocs;
+    usedDependencies = new Set();
+    constructor(options = {}) {
+        this.provenance = options.provenance ?? true;
+        this.typescript = options.typescript ?? true;
+        this.basePath = options.basePath ?? 'components/ui';
+        this.a11yDocs = options.a11yDocs ?? true;
+    }
+    /**
+     * Generate Radix UI component files from ComponentBlock AST nodes
+     */
+    generate(components) {
+        this.usedDependencies.clear();
+        const generatedComponents = [];
+        for (const component of components) {
+            const primitive = this.detectPrimitive(component);
+            if (primitive) {
+                generatedComponents.push(this.generateRadixComponent(component, primitive));
+            }
+            else {
+                // Generate simple component for non-Radix UI components (Button, Card, Badge, etc.)
+                generatedComponents.push(this.generateSimpleComponent(component));
+            }
+        }
+        return {
+            components: generatedComponents,
+            dependencies: Array.from(this.usedDependencies).sort(),
+        };
+    }
+    // ===========================================================================
+    // Primitive Detection
+    // ===========================================================================
+    detectPrimitive(component) {
+        // Check if component name matches a known Radix primitive
+        for (const [key, mapping] of Object.entries(RADIX_MAPPINGS)) {
+            if (component.name.toLowerCase().includes(key.toLowerCase())) {
+                return mapping.primitive;
+            }
+        }
+        // Check if compound parts suggest a Radix primitive
+        if (component.compound && component.compound.length > 0) {
+            const partNames = component.compound.map(p => p.name.toLowerCase());
+            // Dialog/Modal pattern
+            if (partNames.includes('trigger') && partNames.includes('content')) {
+                if (partNames.includes('overlay')) {
+                    return 'Dialog';
+                }
+                return 'Popover';
+            }
+            // Tabs pattern
+            if (partNames.includes('list') && partNames.includes('trigger') && partNames.includes('content')) {
+                return 'Tabs';
+            }
+            // Accordion pattern
+            if (partNames.includes('item') && partNames.includes('trigger')) {
+                return 'Accordion';
+            }
+        }
+        return null;
+    }
+    // ===========================================================================
+    // Radix Component Generation
+    // ===========================================================================
+    generateRadixComponent(component, primitive) {
+        const mapping = Object.values(RADIX_MAPPINGS).find(m => m.primitive === primitive);
+        this.usedDependencies.add(mapping.packageName);
+        const lines = [];
+        const ext = this.typescript ? 'tsx' : 'jsx';
+        // Header
+        if (this.provenance) {
+            lines.push('// Generated by Kappa v2.5 CodeDNA - Radix UI Generator');
+            lines.push(`// Component: ${component.name}`);
+            lines.push(`// Primitive: ${primitive}`);
+            lines.push('');
+        }
+        // Accessibility documentation
+        if (this.a11yDocs) {
+            lines.push('/**');
+            lines.push(` * ${component.name} - Built with Radix UI ${primitive}`);
+            lines.push(' *');
+            lines.push(' * Accessibility features:');
+            lines.push(` * - ARIA attributes automatically applied by Radix UI`);
+            lines.push(` * - Keyboard navigation support`);
+            lines.push(` * - Focus management`);
+            if (primitive === 'Dialog' || primitive === 'AlertDialog') {
+                lines.push(` * - Focus trap when open`);
+                lines.push(` * - Scroll lock when open`);
+            }
+            lines.push(' */');
+        }
+        // Imports
+        lines.push(...this.generateRadixImports(primitive, mapping, component));
+        lines.push('');
+        // Generate based on whether it's compound
+        if (component.compound && component.compound.length > 0) {
+            lines.push(...this.generateCompoundRadixComponent(component, primitive, mapping));
+        }
+        else {
+            lines.push(...this.generateSimpleRadixComponent(component, primitive, mapping));
+        }
+        return {
+            path: `${this.basePath}/${this.toKebabCase(component.name)}.${ext}`,
+            content: lines.join('\n'),
+            primitive,
+        };
+    }
+    generateRadixImports(primitive, mapping, component) {
+        const lines = [];
+        // React imports
+        lines.push("import * as React from 'react';");
+        // Radix imports - import all used parts
+        const usedParts = this.getUsedRadixParts(component, mapping);
+        const radixImports = usedParts.map(part => `${primitive}${part}`).join(', ');
+        lines.push(`import * as ${primitive} from '${mapping.packageName}';`);
+        // Utility imports
+        lines.push("import { cn } from '@/lib/utils';");
+        return lines;
+    }
+    getUsedRadixParts(component, mapping) {
+        const parts = new Set(mapping.requiredParts);
+        // Add optional parts if compound components reference them
+        if (component.compound) {
+            for (const part of component.compound) {
+                const radixPart = this.mapCompoundPartToRadix(part.name);
+                if (mapping.optionalParts.includes(radixPart)) {
+                    parts.add(radixPart);
+                }
+            }
+        }
+        return Array.from(parts);
+    }
+    mapCompoundPartToRadix(partName) {
+        // Map Kappa compound part names to Radix part names
+        const mappings = {
+            trigger: 'Trigger',
+            content: 'Content',
+            overlay: 'Overlay',
+            title: 'Title',
+            description: 'Description',
+            close: 'Close',
+            header: 'Header',
+            body: 'Content',
+            footer: 'Footer',
+            item: 'Item',
+            list: 'List',
+            value: 'Value',
+            icon: 'Icon',
+        };
+        return mappings[partName.toLowerCase()] || partName;
+    }
+    // ===========================================================================
+    // Simple Component Generation
+    // ===========================================================================
+    generateSimpleRadixComponent(component, primitive, mapping) {
+        const lines = [];
+        // Props interface
+        if (this.typescript) {
+            lines.push(this.generateRadixPropsInterface(component, primitive));
+            lines.push('');
+        }
+        // Component
+        const propsType = this.typescript ? `: ${component.name}Props` : '';
+        const destructuredProps = this.getDestructuredProps(component);
+        lines.push(`export const ${component.name} = React.forwardRef<`);
+        lines.push(`  React.ElementRef<typeof ${primitive}.Content>,`);
+        lines.push(`  ${component.name}Props`);
+        lines.push(`>(({ ${destructuredProps} }, ref) => {`);
+        lines.push('  return (');
+        lines.push(`    <${primitive}.Root>`);
+        if (component.structure) {
+            lines.push(this.generateRadixStructureJSX(component.structure, primitive, 6));
+        }
+        else {
+            lines.push(`      <${primitive}.Content ref={ref} className={cn(className)} {...props}>`);
+            lines.push('        {children}');
+            lines.push(`      </${primitive}.Content>`);
+        }
+        lines.push(`    </${primitive}.Root>`);
+        lines.push('  );');
+        lines.push('});');
+        lines.push('');
+        lines.push(`${component.name}.displayName = '${component.name}';`);
+        return lines;
+    }
+    generateRadixPropsInterface(component, primitive) {
+        const lines = [];
+        const propsName = `${component.name}Props`;
+        lines.push(`export interface ${propsName} extends React.ComponentPropsWithoutRef<typeof ${primitive}.Content> {`);
+        for (const prop of component.props) {
+            const optional = prop.optional ? '?' : '';
+            lines.push(`  /** ${prop.name} prop */`);
+            lines.push(`  ${prop.name}${optional}: ${this.mapPropType(prop.type)};`);
+        }
+        lines.push('}');
+        return lines.join('\n');
+    }
+    generateRadixStructureJSX(structure, primitive, indent) {
+        const spaces = ' '.repeat(indent);
+        const lines = [];
+        const radixComponent = this.mapStructureToRadixComponent(structure.type, primitive);
+        const props = Object.entries(structure.props || {})
+            .map(([k, v]) => `${k}="${v}"`)
+            .join(' ');
+        if (structure.children && structure.children.length > 0) {
+            lines.push(`${spaces}<${radixComponent} ${props}>`);
+            for (const child of structure.children) {
+                lines.push(this.generateRadixStructureJSX(child, primitive, indent + 2));
+            }
+            lines.push(`${spaces}</${radixComponent}>`);
+        }
+        else {
+            lines.push(`${spaces}<${radixComponent} ${props}>{children}</${radixComponent}>`);
+        }
+        return lines.join('\n');
+    }
+    mapStructureToRadixComponent(type, primitive) {
+        // Map generic structure types to Radix components
+        const mappings = {
+            overlay: `${primitive}.Overlay`,
+            content: `${primitive}.Content`,
+            title: `${primitive}.Title`,
+            description: `${primitive}.Description`,
+            close: `${primitive}.Close`,
+            trigger: `${primitive}.Trigger`,
+        };
+        return mappings[type.toLowerCase()] || `${primitive}.Content`;
+    }
+    // ===========================================================================
+    // Compound Component Generation
+    // ===========================================================================
+    generateCompoundRadixComponent(component, primitive, mapping) {
+        const lines = [];
+        // Root component interface
+        if (this.typescript) {
+            lines.push(`export interface ${component.name}Props extends React.ComponentPropsWithoutRef<typeof ${primitive}.Root> {`);
+            for (const prop of component.props) {
+                const optional = prop.optional ? '?' : '';
+                lines.push(`  ${prop.name}${optional}: ${this.mapPropType(prop.type)};`);
+            }
+            lines.push('}');
+            lines.push('');
+        }
+        // Root component
+        const propsType = this.typescript ? `: ${component.name}Props` : '';
+        const destructuredProps = this.getDestructuredProps(component);
+        lines.push(`const ${component.name}Root = React.forwardRef<`);
+        lines.push(`  React.ElementRef<typeof ${primitive}.Root>,`);
+        lines.push(`  ${component.name}Props`);
+        lines.push(`>(({ ${destructuredProps} }, ref) => (`);
+        lines.push(`  <${primitive}.Root ref={ref} className={cn(className)} {...props}>`);
+        lines.push('    {children}');
+        lines.push(`  </${primitive}.Root>`);
+        lines.push('));');
+        lines.push('');
+        lines.push(`${component.name}Root.displayName = '${component.name}Root';`);
+        lines.push('');
+        // Compound parts
+        for (const part of component.compound) {
+            lines.push(...this.generateRadixCompoundPart(component.name, part, primitive));
+            lines.push('');
+        }
+        // Export compound object
+        lines.push(`export const ${component.name} = Object.assign(${component.name}Root, {`);
+        for (const part of component.compound) {
+            lines.push(`  ${part.name}: ${component.name}${part.name},`);
+        }
+        lines.push('});');
+        return lines;
+    }
+    generateRadixCompoundPart(parentName, part, primitive) {
+        const lines = [];
+        const partName = `${parentName}${part.name}`;
+        const radixPart = this.mapCompoundPartToRadix(part.name);
+        const radixComponent = `${primitive}.${radixPart}`;
+        // Props interface
+        if (this.typescript) {
+            lines.push(`export interface ${partName}Props extends React.ComponentPropsWithoutRef<typeof ${radixComponent}> {`);
+            if (part.props) {
+                for (const prop of part.props) {
+                    lines.push(`  ${prop}?: string;`);
+                }
+            }
+            lines.push('}');
+            lines.push('');
+        }
+        const propsType = this.typescript ? `: ${partName}Props` : '';
+        const propsStr = part.props
+            ? `{ className, children, ${part.props.join(', ')}, ...props }`
+            : '{ className, children, ...props }';
+        lines.push(`const ${partName} = React.forwardRef<`);
+        lines.push(`  React.ElementRef<typeof ${radixComponent}>,`);
+        lines.push(`  ${partName}Props`);
+        lines.push(`>((`);
+        lines.push(`  ${propsStr}${propsType},`);
+        lines.push(`  ref`);
+        lines.push(`) => (`);
+        lines.push(`  <${radixComponent}`);
+        lines.push(`    ref={ref}`);
+        lines.push(`    className={cn('${this.toKebabCase(partName)}', className)}`);
+        lines.push(`    {...props}`);
+        lines.push(`  >`);
+        lines.push('    {children}');
+        lines.push(`  </${radixComponent}>`);
+        lines.push(`));`);
+        lines.push('');
+        lines.push(`${partName}.displayName = '${partName}';`);
+        return lines;
+    }
+    // ===========================================================================
+    // Simple Component Generation (non-Radix)
+    // ===========================================================================
+    generateSimpleComponent(component) {
+        const lines = [];
+        const ext = this.typescript ? 'tsx' : 'jsx';
+        // Header
+        if (this.provenance) {
+            lines.push('// Generated by Kappa v2.5 CodeDNA - Simple Component Generator');
+            lines.push(`// Component: ${component.name}`);
+            lines.push('');
+        }
+        // Imports
+        lines.push("import * as React from 'react';");
+        lines.push("import { cn } from '@/lib/utils';");
+        lines.push('');
+        // Variant styles (if component has variants)
+        if (component.variants && component.variants.length > 0) {
+            lines.push('// Variant styles');
+            lines.push(`const ${component.name.toLowerCase()}Variants = {`);
+            for (const variant of component.variants) {
+                const className = this.getVariantClassName(component.name, variant.name);
+                lines.push(`  ${variant.name}: '${className}',`);
+            }
+            lines.push('} as const;');
+            lines.push('');
+            lines.push(`type ${component.name}Variant = keyof typeof ${component.name.toLowerCase()}Variants;`);
+            lines.push('');
+        }
+        // Props interface
+        if (this.typescript) {
+            lines.push(`export interface ${component.name}Props extends React.HTMLAttributes<HTMLElement> {`);
+            for (const prop of component.props) {
+                const optional = prop.optional ? '?' : '';
+                lines.push(`  /** ${prop.name} prop */`);
+                lines.push(`  ${prop.name}${optional}: ${this.mapPropType(prop.type)};`);
+            }
+            if (component.variants && component.variants.length > 0) {
+                const defaultVariant = component.variants[0].name;
+                lines.push(`  /** Visual variant */`);
+                lines.push(`  variant?: ${component.name}Variant;`);
+            }
+            lines.push('}');
+            lines.push('');
+        }
+        // Component
+        const destructuredProps = this.getSimpleDestructuredProps(component);
+        const elementType = this.getElementType(component.name);
+        lines.push(`export const ${component.name} = React.forwardRef<`);
+        lines.push(`  HTML${elementType}Element,`);
+        lines.push(`  ${component.name}Props`);
+        lines.push(`>(({ ${destructuredProps} }, ref) => {`);
+        // Variant handling
+        if (component.variants && component.variants.length > 0) {
+            const defaultVariant = component.variants[0].name;
+            lines.push(`  const variantClass = ${component.name.toLowerCase()}Variants[variant ?? '${defaultVariant}'];`);
+            lines.push('');
+        }
+        // Return statement
+        lines.push('  return (');
+        lines.push(`    <${this.getElementTag(component.name)}`);
+        lines.push('      ref={ref}');
+        if (component.variants && component.variants.length > 0) {
+            lines.push(`      className={cn('${this.toKebabCase(component.name)}', variantClass, className)}`);
+        }
+        else {
+            lines.push(`      className={cn('${this.toKebabCase(component.name)}', className)}`);
+        }
+        // Add event handlers from props
+        for (const prop of component.props) {
+            if (prop.name.startsWith('on')) {
+                lines.push(`      ${prop.name}={${prop.name}}`);
+            }
+        }
+        lines.push('      {...props}');
+        lines.push('    >');
+        // Add label/children content
+        const labelProp = component.props.find(p => p.name === 'label');
+        if (labelProp) {
+            lines.push('      {label}');
+        }
+        else {
+            lines.push('      {children}');
+        }
+        lines.push(`    </${this.getElementTag(component.name)}>`);
+        lines.push('  );');
+        lines.push('});');
+        lines.push('');
+        lines.push(`${component.name}.displayName = '${component.name}';`);
+        return {
+            path: `${this.basePath}/${this.toKebabCase(component.name)}.${ext}`,
+            content: lines.join('\n'),
+            primitive: 'Toggle', // Placeholder since this isn't actually a Radix primitive
+        };
+    }
+    getSimpleDestructuredProps(component) {
+        const propNames = component.props.map((p) => p.name);
+        if (component.variants && component.variants.length > 0) {
+            propNames.push('variant');
+        }
+        propNames.push('className', 'children', '...props');
+        return propNames.join(', ');
+    }
+    getVariantClassName(componentName, variantName) {
+        const base = this.toKebabCase(componentName);
+        const styles = {
+            button: {
+                primary: 'bg-primary text-primary-foreground hover:bg-primary/90',
+                secondary: 'bg-secondary text-secondary-foreground hover:bg-secondary/80',
+                destructive: 'bg-destructive text-destructive-foreground hover:bg-destructive/90',
+                outline: 'border border-input bg-background hover:bg-accent hover:text-accent-foreground',
+                ghost: 'hover:bg-accent hover:text-accent-foreground',
+                link: 'text-primary underline-offset-4 hover:underline',
+            },
+            card: {
+                default: 'border bg-card text-card-foreground shadow-sm',
+                outlined: 'border-2 bg-background',
+                elevated: 'bg-card text-card-foreground shadow-lg',
+            },
+            badge: {
+                default: 'border-transparent bg-primary text-primary-foreground',
+                secondary: 'border-transparent bg-secondary text-secondary-foreground',
+                outline: 'text-foreground',
+                destructive: 'border-transparent bg-destructive text-destructive-foreground',
+            },
+        };
+        const componentStyles = styles[componentName.toLowerCase()];
+        if (componentStyles && componentStyles[variantName]) {
+            return componentStyles[variantName];
+        }
+        // Generic variant styles
+        return `${base}--${variantName}`;
+    }
+    getElementType(componentName) {
+        const mappings = {
+            button: 'Button',
+            input: 'Input',
+            textarea: 'TextArea',
+            select: 'Select',
+            card: 'Div',
+            badge: 'Div',
+            avatar: 'Div',
+            alert: 'Div',
+        };
+        return mappings[componentName.toLowerCase()] || 'Div';
+    }
+    getElementTag(componentName) {
+        const mappings = {
+            button: 'button',
+            input: 'input',
+            textarea: 'textarea',
+            select: 'select',
+            link: 'a',
+        };
+        return mappings[componentName.toLowerCase()] || 'div';
+    }
+    // ===========================================================================
+    // Helpers
+    // ===========================================================================
+    getDestructuredProps(component) {
+        const propNames = component.props.map((p) => p.name);
+        propNames.push('className', 'children', '...props');
+        return propNames.join(', ');
+    }
+    mapPropType(type) {
+        const typeMap = {
+            string: 'string',
+            number: 'number',
+            boolean: 'boolean',
+            node: 'React.ReactNode',
+            element: 'React.ReactElement',
+            func: '() => void',
+            array: 'unknown[]',
+            object: 'Record<string, unknown>',
+        };
+        return typeMap[type] || type;
+    }
+    toKebabCase(str) {
+        return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+    }
+}
+// =============================================================================
+// Convenience Function
+// =============================================================================
+/**
+ * Generate Radix UI component files from Kappa ComponentBlock nodes
+ */
+export function generateRadixComponents(components, options = {}) {
+    const generator = new KappaRadixGenerator(options);
+    return generator.generate(components);
+}

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

@@ -0,0 +1,59 @@
+import type { EntityBlock } from './kappa-ast.js';
+export type TypeORMDialect = 'postgres' | 'mysql' | 'sqlite';
+export interface TypeORMGeneratorOptions {
+    /** Database dialect (default: postgres) */
+    dialect?: TypeORMDialect;
+    /** Generate repository classes (default: false) */
+    repositories?: boolean;
+    /** Generate migration files (default: true) */
+    migrations?: boolean;
+    /** Add provenance comments (default: true) */
+    provenance?: boolean;
+}
+export interface GeneratedTypeORM {
+    /** Entity class files (map of entity name to content) */
+    entities: Record<string, string>;
+    /** Repository files (if enabled) */
+    repositories?: Record<string, string>;
+    /** Migration file content (if enabled) */
+    migration?: string;
+    /** Data source configuration */
+    dataSource: string;
+}
+export declare class KappaTypeORMGenerator {
+    private dialect;
+    private provenance;
+    private generateRepositories;
+    private generateMigrations;
+    constructor(options?: TypeORMGeneratorOptions);
+    /**
+     * Generate TypeORM entities from entity blocks
+     */
+    generate(entities: EntityBlock[]): GeneratedTypeORM;
+    private generateEntity;
+    private generateEntityImports;
+    private generateEntityClass;
+    private generatePrimaryKey;
+    private generateField;
+    private generateRelationship;
+    private getColumnType;
+    private getTSType;
+    /**
+     * Determine the foreign key column type based on the related entity's primary key
+     */
+    private getForeignKeyType;
+    private generateDataSource;
+    private generateRepositoryFiles;
+    private generateRepository;
+    private generateMigrationFile;
+    private generateCreateTableSQL;
+    private generateColumnSQL;
+    private generateCreateIndexSQL;
+    private toSnakeCase;
+    private toCamelCase;
+    private toLowerCamelCase;
+}
+/**
+ * Generate TypeORM entities from Kappa entity blocks
+ */
+export declare function generateTypeORMEntities(entities: EntityBlock[], options?: TypeORMGeneratorOptions): GeneratedTypeORM;