@claudetools/tools 0.8.11 → 0.9.0

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

@@ -0,0 +1,355 @@
+// =============================================================================
+// Kappa v2.5 Drizzle Schema Generator
+// =============================================================================
+//
+// Generates Drizzle ORM schema code from Kappa entity blocks.
+// Supports PostgreSQL, MySQL, and SQLite dialects.
+//
+// =============================================================================
+// Type Mappings
+// =============================================================================
+const DRIZZLE_IMPORTS = {
+    postgresql: 'drizzle-orm/pg-core',
+    mysql: 'drizzle-orm/mysql-core',
+    sqlite: 'drizzle-orm/sqlite-core',
+};
+const PRIMITIVE_TYPE_MAP = {
+    postgresql: {
+        string: 'text',
+        int: 'integer',
+        float: 'real',
+        bool: 'boolean',
+        email: 'text',
+        url: 'text',
+        uuid: 'uuid',
+        phone: 'text',
+        slug: 'text',
+        markdown: 'text',
+        json: 'jsonb',
+        timestamp: 'timestamp',
+        date: 'date',
+        time: 'time',
+        duration: 'interval',
+    },
+    mysql: {
+        string: 'text',
+        int: 'int',
+        float: 'double',
+        bool: 'boolean',
+        email: 'varchar(255)',
+        url: 'text',
+        uuid: 'varchar(36)',
+        phone: 'varchar(20)',
+        slug: 'varchar(255)',
+        markdown: 'text',
+        json: 'json',
+        timestamp: 'timestamp',
+        date: 'date',
+        time: 'time',
+        duration: 'varchar(50)',
+    },
+    sqlite: {
+        string: 'text',
+        int: 'integer',
+        float: 'real',
+        bool: 'integer', // SQLite uses 0/1
+        email: 'text',
+        url: 'text',
+        uuid: 'text',
+        phone: 'text',
+        slug: 'text',
+        markdown: 'text',
+        json: 'text', // JSON stored as text
+        timestamp: 'integer', // Unix timestamp
+        date: 'text', // ISO date string
+        time: 'text',
+        duration: 'text',
+    },
+};
+// =============================================================================
+// Generator Class
+// =============================================================================
+export class KappaDrizzleGenerator {
+    dialect;
+    provenance;
+    generateRelations;
+    constructor(options = {}) {
+        this.dialect = options.dialect ?? 'postgresql';
+        this.provenance = options.provenance ?? true;
+        this.generateRelations = options.relations ?? true;
+    }
+    /**
+     * Generate Drizzle schema from entity blocks
+     */
+    generate(entities) {
+        const schema = this.generateSchemaFile(entities);
+        const types = this.generateTypesFile(entities);
+        const result = { schema, types };
+        if (this.generateRelations) {
+            result.relations = this.generateRelationsFile(entities);
+        }
+        return result;
+    }
+    // ===========================================================================
+    // Schema File Generation
+    // ===========================================================================
+    generateSchemaFile(entities) {
+        const lines = [];
+        // Header comment
+        if (this.provenance) {
+            lines.push('// Generated by Kappa v2.5 CodeDNA');
+            lines.push(`// Dialect: ${this.dialect}`);
+            lines.push(`// Generated at: ${new Date().toISOString()}`);
+            lines.push('');
+        }
+        // Imports
+        lines.push(this.generateSchemaImports(entities));
+        lines.push('');
+        // Generate each table
+        for (const entity of entities) {
+            lines.push(this.generateTable(entity));
+            lines.push('');
+        }
+        return lines.join('\n');
+    }
+    generateSchemaImports(entities) {
+        const importPath = DRIZZLE_IMPORTS[this.dialect];
+        const columnTypes = new Set();
+        // Collect all column types used
+        for (const entity of entities) {
+            for (const field of entity.fields) {
+                const colType = this.getColumnTypeFunction(field.type);
+                columnTypes.add(colType);
+            }
+            // Add relation types
+            for (const rel of entity.relationships) {
+                if (rel.type === 'belongs_to') {
+                    columnTypes.add(this.getColumnTypeFunction({ kind: 'primitive', type: 'uuid' }));
+                }
+            }
+        }
+        // Always include table function
+        const imports = [this.getTableFunction(), ...Array.from(columnTypes).sort()];
+        // Add relations import if needed
+        if (this.generateRelations) {
+            imports.push('relations');
+        }
+        return `import { ${imports.join(', ')} } from '${importPath}';`;
+    }
+    getTableFunction() {
+        switch (this.dialect) {
+            case 'postgresql':
+                return 'pgTable';
+            case 'mysql':
+                return 'mysqlTable';
+            case 'sqlite':
+                return 'sqliteTable';
+        }
+    }
+    generateTable(entity) {
+        const tableName = this.toSnakeCase(entity.name);
+        const tableFunc = this.getTableFunction();
+        const lines = [];
+        lines.push(`export const ${tableName} = ${tableFunc}('${tableName}', {`);
+        // Generate columns
+        for (const field of entity.fields) {
+            lines.push(`  ${this.generateColumn(field, entity)},`);
+        }
+        // Generate foreign key columns for belongs_to relationships
+        for (const rel of entity.relationships) {
+            if (rel.type === 'belongs_to') {
+                lines.push(`  ${this.generateForeignKeyColumn(rel)},`);
+            }
+        }
+        lines.push('});');
+        // Generate indexes if any
+        if (entity.indexes.length > 0) {
+            lines.push('');
+            lines.push(this.generateIndexes(entity));
+        }
+        return lines.join('\n');
+    }
+    generateColumn(field, entity) {
+        const { name, type, modifiers } = field;
+        const colName = this.toSnakeCase(name);
+        const colType = this.getColumnTypeFunction(type);
+        const colTypeCall = this.getColumnTypeCall(type, colName);
+        const chainMethods = [];
+        // Handle modifiers
+        if (modifiers.includes('primary')) {
+            chainMethods.push('primaryKey()');
+        }
+        if (modifiers.includes('auto')) {
+            if (type.kind === 'primitive' && type.type === 'uuid') {
+                chainMethods.push('defaultRandom()');
+            }
+            else if (type.kind === 'primitive' && (type.type === 'int' || type.type === 'timestamp')) {
+                if (type.type === 'timestamp') {
+                    chainMethods.push('defaultNow()');
+                }
+            }
+        }
+        if (modifiers.includes('unique')) {
+            chainMethods.push('unique()');
+        }
+        if (!modifiers.includes('optional') && !modifiers.includes('primary')) {
+            chainMethods.push('notNull()');
+        }
+        // Handle default values for enums
+        if (type.kind === 'enum' && type.defaultValue) {
+            chainMethods.push(`default('${type.defaultValue}')`);
+        }
+        const chain = chainMethods.length > 0 ? '.' + chainMethods.join('.') : '';
+        return `${colName}: ${colTypeCall}${chain}`;
+    }
+    generateForeignKeyColumn(rel) {
+        // Derive FK column name from relationship entity (foreignKey field doesn't exist in AST)
+        const colName = `${this.toSnakeCase(rel.entity)}_id`;
+        const refTable = this.toSnakeCase(rel.entity);
+        if (this.dialect === 'postgresql') {
+            return `${colName}: uuid('${colName}').references(() => ${refTable}.id)`;
+        }
+        else {
+            return `${colName}: text('${colName}').references(() => ${refTable}.id)`;
+        }
+    }
+    getColumnTypeFunction(type) {
+        switch (type.kind) {
+            case 'primitive':
+                return PRIMITIVE_TYPE_MAP[this.dialect][type.type];
+            case 'enum':
+                return 'text'; // Enums as text with check constraint
+            case 'reference':
+                return this.dialect === 'postgresql' ? 'uuid' : 'text';
+            case 'array':
+                return this.dialect === 'postgresql' ? 'jsonb' : 'text';
+            default:
+                return 'text';
+        }
+    }
+    getColumnTypeCall(type, colName) {
+        const baseType = this.getColumnTypeFunction(type);
+        // Handle range constraints for strings
+        if (type.kind === 'primitive' && type.range && this.dialect !== 'sqlite') {
+            if (type.type === 'string' && type.range.max) {
+                return `varchar('${colName}', { length: ${type.range.max} })`;
+            }
+        }
+        return `${baseType}('${colName}')`;
+    }
+    generateIndexes(entity) {
+        const tableName = this.toSnakeCase(entity.name);
+        const lines = [];
+        for (const index of entity.indexes) {
+            // EntityIndex only has fields and unique, so construct name from fields
+            const indexName = `${tableName}_${index.fields.join('_')}_idx`;
+            const fields = index.fields.map(f => `${tableName}.${this.toSnakeCase(f)}`).join(', ');
+            const unique = index.unique ? '.unique()' : '';
+            lines.push(`// Index: ${indexName}`);
+            lines.push(`export const ${indexName} = index('${indexName}').on(${fields})${unique};`);
+        }
+        return lines.join('\n');
+    }
+    // ===========================================================================
+    // Relations File Generation
+    // ===========================================================================
+    generateRelationsFile(entities) {
+        const lines = [];
+        if (this.provenance) {
+            lines.push('// Generated by Kappa v2.5 CodeDNA');
+            lines.push('// Drizzle Relations');
+            lines.push('');
+        }
+        // Import relations helper
+        lines.push(`import { relations } from 'drizzle-orm';`);
+        // Import all tables
+        const tableImports = entities.map(e => this.toSnakeCase(e.name)).join(', ');
+        lines.push(`import { ${tableImports} } from './schema';`);
+        lines.push('');
+        // Generate relations for each entity
+        for (const entity of entities) {
+            if (entity.relationships.length > 0) {
+                lines.push(this.generateEntityRelations(entity, entities));
+                lines.push('');
+            }
+        }
+        return lines.join('\n');
+    }
+    generateEntityRelations(entity, allEntities) {
+        const tableName = this.toSnakeCase(entity.name);
+        const lines = [];
+        lines.push(`export const ${tableName}Relations = relations(${tableName}, ({ one, many }) => ({`);
+        for (const rel of entity.relationships) {
+            const relatedTable = this.toSnakeCase(rel.entity);
+            const relName = rel.as || relatedTable;
+            switch (rel.type) {
+                case 'belongs_to':
+                    // Derive FK column name from relationship entity
+                    const fkCol = `${relatedTable}_id`;
+                    lines.push(`  ${relName}: one(${relatedTable}, {`);
+                    lines.push(`    fields: [${tableName}.${fkCol}],`);
+                    lines.push(`    references: [${relatedTable}.id],`);
+                    lines.push(`  }),`);
+                    break;
+                case 'has_one':
+                    lines.push(`  ${relName}: one(${relatedTable}),`);
+                    break;
+                case 'has_many':
+                    if (rel.through) {
+                        // Many-to-many through join table
+                        const throughTable = this.toSnakeCase(rel.through);
+                        lines.push(`  ${relName}: many(${throughTable}),`);
+                    }
+                    else {
+                        lines.push(`  ${relName}: many(${relatedTable}),`);
+                    }
+                    break;
+            }
+        }
+        lines.push('}));');
+        return lines.join('\n');
+    }
+    // ===========================================================================
+    // Types File Generation
+    // ===========================================================================
+    generateTypesFile(entities) {
+        const lines = [];
+        if (this.provenance) {
+            lines.push('// Generated by Kappa v2.5 CodeDNA');
+            lines.push('// TypeScript types inferred from Drizzle schema');
+            lines.push('');
+        }
+        lines.push(`import type { InferSelectModel, InferInsertModel } from 'drizzle-orm';`);
+        const tableImports = entities.map(e => this.toSnakeCase(e.name)).join(', ');
+        lines.push(`import { ${tableImports} } from './schema';`);
+        lines.push('');
+        // Generate types for each entity
+        for (const entity of entities) {
+            const tableName = this.toSnakeCase(entity.name);
+            const typeName = entity.name;
+            lines.push(`export type ${typeName} = InferSelectModel<typeof ${tableName}>;`);
+            lines.push(`export type New${typeName} = InferInsertModel<typeof ${tableName}>;`);
+            lines.push('');
+        }
+        return lines.join('\n');
+    }
+    // ===========================================================================
+    // Utilities
+    // ===========================================================================
+    toSnakeCase(str) {
+        return str
+            .replace(/([A-Z])/g, '_$1')
+            .toLowerCase()
+            .replace(/^_/, '');
+    }
+}
+// =============================================================================
+// Convenience Function
+// =============================================================================
+/**
+ * Generate Drizzle schema from Kappa entities
+ */
+export function generateDrizzleSchema(entities, options = {}) {
+    const generator = new KappaDrizzleGenerator(options);
+    return generator.generate(entities);
+}

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

@@ -0,0 +1,51 @@
+import type { FormBlock } from './kappa-ast.js';
+export type FormUILibrary = 'shadcn' | 'plain';
+export interface FormGeneratorOptions {
+    /** UI component library (default: 'shadcn') */
+    ui?: FormUILibrary;
+    /** Add provenance comments (default: true) */
+    provenance?: boolean;
+    /** Generate TypeScript (default: true) */
+    typescript?: boolean;
+    /** Use Zod for validation (default: true) */
+    zod?: boolean;
+}
+export interface GeneratedForm {
+    /** Form component file path */
+    path: string;
+    /** Form component content */
+    content: string;
+    /** Zod schema file (if zod enabled) */
+    schema?: {
+        path: string;
+        content: string;
+    };
+}
+export interface GeneratedForms {
+    /** Generated form files */
+    forms: GeneratedForm[];
+}
+export declare class KappaFormGenerator {
+    private ui;
+    private provenance;
+    private typescript;
+    private zod;
+    constructor(options?: FormGeneratorOptions);
+    /**
+     * Generate form components from FormBlock AST nodes
+     */
+    generate(forms: FormBlock[]): GeneratedForms;
+    private generateForm;
+    private generateZodSchema;
+    private fieldTypeToZod;
+    private generateLayoutRow;
+    private generateShadcnField;
+    private generateShadcnInput;
+    private generatePlainField;
+    private toCamelCase;
+    private toKebabCase;
+}
+/**
+ * Generate form components from Kappa FormBlock nodes
+ */
+export declare function generateForms(forms: FormBlock[], options?: FormGeneratorOptions): GeneratedForms;