@claudetools/tools 0.9.0 → 0.9.2

package/dist/codegen/codegen-tool.js

@@ -0,0 +1,312 @@
+// =============================================================================
+// Unified Codegen Tool
+// =============================================================================
+//
+// ONE tool to replace 20+ broken CodeDNA/Kappa tools.
+// Natural language in → generated code out.
+//
+import { parseNaturalLanguage, parsePageDescription, parseComponentDescription } from './natural-parser.js';
+import { parseFormDescription } from './form-parser.js';
+import { generateDrizzleSchema } from '../codedna/kappa-drizzle-generator.js';
+import { generateZodSchemas } from '../codedna/kappa-zod-generator.js';
+import { generateTypeScriptTypes } from '../codedna/kappa-types-generator.js';
+import { generateAPI } from '../codedna/kappa-api-generator.js';
+import { generateEntityTests } from '../codedna/kappa-vitest-generator.js';
+import { generateRadixComponents } from '../codedna/kappa-radix-generator.js';
+import { generatePages } from '../codedna/kappa-page-generator.js';
+import { generateForms } from '../codedna/kappa-form-generator.js';
+export function detectStack(packageJson) {
+    const deps = {
+        ...(packageJson?.dependencies || {}),
+        ...(packageJson?.devDependencies || {}),
+    };
+    const stack = {
+        orm: null,
+        api: null,
+        ui: null,
+        db: null,
+        framework: null,
+        lang: 'typescript' in deps || '@types/node' in deps ? 'typescript' : 'javascript',
+    };
+    // Detect ORM
+    if ('drizzle-orm' in deps)
+        stack.orm = 'drizzle';
+    else if ('@prisma/client' in deps)
+        stack.orm = 'prisma';
+    else if ('typeorm' in deps)
+        stack.orm = 'typeorm';
+    else if ('mongoose' in deps)
+        stack.orm = 'mongoose';
+    // Detect API framework
+    if ('hono' in deps)
+        stack.api = 'hono';
+    else if ('express' in deps)
+        stack.api = 'express';
+    else if ('@trpc/server' in deps)
+        stack.api = 'trpc';
+    else if ('fastify' in deps)
+        stack.api = 'fastify';
+    // Detect UI
+    if ('@radix-ui/react-dialog' in deps || '@radix-ui/themes' in deps)
+        stack.ui = 'radix';
+    else if ('@mantine/core' in deps)
+        stack.ui = 'mantine';
+    else if ('@chakra-ui/react' in deps)
+        stack.ui = 'chakra';
+    // shadcn doesn't have a package, detected by tailwind + radix primitives
+    // Detect DB
+    if ('better-sqlite3' in deps || '@libsql/client' in deps)
+        stack.db = 'sqlite';
+    else if ('pg' in deps || '@neondatabase/serverless' in deps)
+        stack.db = 'postgres';
+    else if ('mysql2' in deps)
+        stack.db = 'mysql';
+    else if ('mongodb' in deps || 'mongoose' in deps)
+        stack.db = 'mongodb';
+    // Detect Framework
+    if ('@tanstack/react-router' in deps || '@tanstack/start' in deps)
+        stack.framework = 'tanstack-start';
+    else if ('next' in deps)
+        stack.framework = 'nextjs';
+    return stack;
+}
+// =============================================================================
+// Main Codegen Function
+// =============================================================================
+export function codegen(input, packageJson) {
+    // Parse all types from natural language
+    const parsed = parseNaturalLanguage(input.describe);
+    const formParsed = parseFormDescription(input.describe);
+    const componentParsed = parseComponentDescription(input.describe);
+    const pagesParsed = parsePageDescription(input.describe);
+    // Check if we parsed anything useful
+    const hasEntities = parsed.success && parsed.entities.length > 0;
+    const hasForms = formParsed.success && formParsed.forms.length > 0;
+    const hasComponents = componentParsed.success && componentParsed.components.length > 0;
+    const hasPages = pagesParsed.length > 0;
+    if (!hasEntities && !hasForms && !hasComponents && !hasPages) {
+        return {
+            success: false,
+            files: [],
+            entities: [],
+            summary: 'Failed to parse description',
+            errors: ['Could not understand the description. Try:\n  Entity: "User with email, password, role (admin/user)"\n  Form: "Login form with email, password"\n  Component: "Button with label, onClick, variant (primary/secondary)"\n  Page: "Dashboard page at /dashboard, requires auth"'],
+        };
+    }
+    // Detect or use provided stack
+    const detected = detectStack(packageJson);
+    const stack = {
+        orm: input.stack?.orm || detected.orm || 'drizzle',
+        api: input.stack?.api || detected.api || 'hono',
+        db: input.stack?.db || detected.db || 'sqlite',
+        ui: input.stack?.ui || detected.ui || 'radix',
+        framework: detected.framework || 'tanstack-start',
+        lang: detected.lang,
+    };
+    const files = [];
+    const toGenerate = input.generate || ['schema', 'types', 'validators'];
+    const generateAll = toGenerate.includes('all');
+    // Generate schema (Drizzle)
+    if (generateAll || toGenerate.includes('schema')) {
+        if (stack.orm === 'drizzle') {
+            // Map 'postgres' to 'postgresql' for Drizzle dialect
+            const dialectMap = {
+                sqlite: 'sqlite',
+                postgres: 'postgresql',
+                postgresql: 'postgresql',
+                mysql: 'mysql',
+            };
+            const drizzle = generateDrizzleSchema(parsed.entities, {
+                dialect: dialectMap[stack.db] || 'sqlite',
+            });
+            files.push({
+                path: 'src/db/schema.ts',
+                content: drizzle.schema,
+                description: 'Drizzle ORM schema',
+            });
+            if (drizzle.relations) {
+                files.push({
+                    path: 'src/db/relations.ts',
+                    content: drizzle.relations,
+                    description: 'Drizzle relations',
+                });
+            }
+            if (drizzle.types) {
+                files.push({
+                    path: 'src/db/types.ts',
+                    content: drizzle.types,
+                    description: 'Drizzle inferred types',
+                });
+            }
+        }
+        // TODO: Add prisma, typeorm, mongoose
+    }
+    // Generate TypeScript types
+    if (generateAll || toGenerate.includes('types')) {
+        const types = generateTypeScriptTypes(parsed.entities);
+        files.push({
+            path: 'src/types/entities.ts',
+            content: types.types,
+            description: 'TypeScript entity types',
+        });
+    }
+    // Generate Zod validators
+    if (generateAll || toGenerate.includes('validators')) {
+        const zod = generateZodSchemas(parsed.entities);
+        files.push({
+            path: 'src/validators/schemas.ts',
+            content: zod.schemas,
+            description: 'Zod validation schemas',
+        });
+    }
+    // Generate API routes
+    if (generateAll || toGenerate.includes('api')) {
+        const apis = createAPIsFromEntities(parsed.entities);
+        const api = generateAPI(apis, { framework: stack.api });
+        files.push({
+            path: 'src/routes/index.ts',
+            content: api.routes,
+            description: `${stack.api} API routes`,
+        });
+        if (api.validation) {
+            files.push({
+                path: 'src/routes/validation.ts',
+                content: api.validation,
+                description: 'Route validation schemas',
+            });
+        }
+    }
+    // Generate Vitest tests
+    if (generateAll || toGenerate.includes('tests')) {
+        for (const entity of parsed.entities) {
+            const tests = generateEntityTests(entity, {
+                factories: true,
+                mocks: true,
+                provenance: true,
+            });
+            const entityName = entity.name.toLowerCase();
+            files.push({
+                path: `__tests__/${entityName}.test.ts`,
+                content: tests.tests,
+                description: `Vitest unit tests for ${entity.name}`,
+            });
+            if (tests.factories) {
+                files.push({
+                    path: `__tests__/${entityName}.factory.ts`,
+                    content: tests.factories,
+                    description: `Test factory for ${entity.name}`,
+                });
+            }
+            if (tests.mocks) {
+                files.push({
+                    path: `__tests__/${entityName}.mock.ts`,
+                    content: tests.mocks,
+                    description: `Mock repository for ${entity.name}`,
+                });
+            }
+        }
+    }
+    // Generate React components (Radix UI)
+    if (generateAll || toGenerate.includes('components')) {
+        if (hasComponents) {
+            const radixResult = generateRadixComponents(componentParsed.components, {
+                typescript: true,
+                provenance: true,
+                a11yDocs: true,
+            });
+            for (const component of radixResult.components) {
+                files.push({
+                    path: component.path,
+                    content: component.content,
+                    description: `Radix UI ${component.primitive} component`,
+                });
+            }
+        }
+        // TODO: Add shadcn, mantine generation when available
+    }
+    // Generate Pages (TanStack Start / Next.js)
+    if (generateAll || toGenerate.includes('pages')) {
+        if (hasPages) {
+            const framework = stack.framework || 'tanstack-start';
+            const pagesResult = generatePages(pagesParsed, {
+                framework: framework,
+                typescript: stack.lang === 'typescript',
+                provenance: true,
+            });
+            for (const page of pagesResult.pages) {
+                files.push({
+                    path: page.path,
+                    content: page.content,
+                    description: `${framework} page: ${page.path}`,
+                });
+                if (page.loader) {
+                    files.push({
+                        path: page.loader.path,
+                        content: page.loader.content,
+                        description: `Page loader for ${page.path}`,
+                    });
+                }
+            }
+            if (pagesResult.layouts) {
+                for (const layout of pagesResult.layouts) {
+                    files.push({
+                        path: layout.path,
+                        content: layout.content,
+                        description: `Shared layout component`,
+                    });
+                }
+            }
+        }
+    }
+    // Generate forms (React Hook Form + Zod)
+    if (generateAll || toGenerate.includes('forms')) {
+        if (hasForms) {
+            const ui = stack.ui === 'shadcn' || stack.ui === 'radix' ? 'shadcn' : 'plain';
+            const formsResult = generateForms(formParsed.forms, {
+                ui,
+                typescript: true,
+                provenance: true,
+                zod: true,
+            });
+            for (const form of formsResult.forms) {
+                files.push({
+                    path: form.path,
+                    content: form.content,
+                    description: `React Hook Form component`,
+                });
+            }
+        }
+    }
+    const entityNames = parsed.entities.map(e => e.name);
+    const formNames = formParsed.forms.map(f => f.name);
+    const allNames = [...entityNames, ...formNames.map(n => `${n} form`)];
+    return {
+        success: true,
+        files,
+        entities: entityNames,
+        summary: `Generated ${files.length} files for ${allNames.join(', ')}`,
+    };
+}
+/**
+ * Create API blocks from entities (CRUD for each)
+ */
+function createAPIsFromEntities(entities) {
+    return entities.map(entity => ({
+        kind: 'APIBlock',
+        name: `${entity.name}API`,
+        operations: [],
+        crud: [{
+                kind: 'CRUDShorthand',
+                entity: entity.name,
+                actions: [
+                    { action: 'list', effects: ['DB'] },
+                    { action: 'create', effects: ['DB'] },
+                    { action: 'read', effects: ['DB'] },
+                    { action: 'update', effects: ['DB'] },
+                    { action: 'delete', effects: ['DB'] },
+                ],
+                loc: { startLine: 1, startColumn: 1, endLine: 1, endColumn: 1, startOffset: 0, endOffset: 0 },
+            }],
+        loc: { startLine: 1, startColumn: 1, endLine: 1, endColumn: 1, startOffset: 0, endOffset: 0 },
+    }));
+}

package/dist/codegen/field-inference.d.ts

@@ -0,0 +1,24 @@
+export type InferredType = {
+    type: string;
+    modifiers: string[];
+};
+/**
+ * Infer field type from field name
+ */
+export declare function inferFieldType(fieldName: string): InferredType;
+/**
+ * Parse explicit type annotation if present
+ * Examples: "role:enum(admin,user)", "age:int", "bio:text:optional"
+ */
+export declare function parseExplicitType(spec: string): {
+    name: string;
+    type: InferredType;
+} | null;
+/**
+ * Parse enum from parenthetical notation
+ * Example: "role (admin, user, guest)" → { name: 'role', values: ['admin', 'user', 'guest'] }
+ */
+export declare function parseInlineEnum(text: string): {
+    name: string;
+    values: string[];
+} | null;

package/dist/codegen/field-inference.js

@@ -0,0 +1,101 @@
+// =============================================================================
+// Smart Field Inference
+// =============================================================================
+//
+// Maps common field names to appropriate types automatically.
+// No DSL syntax needed - just say "User with email, password, createdAt"
+//
+// Field name patterns → type mappings
+const FIELD_PATTERNS = [
+    // Identity - always uuid primary
+    [/^id$/i, { type: 'uuid', modifiers: ['primary', 'auto'] }],
+    [/^uuid$/i, { type: 'uuid', modifiers: ['primary', 'auto'] }],
+    // Email fields
+    [/email/i, { type: 'email', modifiers: ['unique'] }],
+    // Password - always hashed
+    [/^password$/i, { type: 'string', modifiers: ['hashed'] }],
+    [/^passwordHash$/i, { type: 'string', modifiers: [] }],
+    // URLs
+    [/^url$|Url$|^link$|Link$|^href$/i, { type: 'url', modifiers: [] }],
+    [/^avatar$|^image$|^photo$|^picture$/i, { type: 'url', modifiers: ['optional'] }],
+    // Phone
+    [/phone|mobile|cell/i, { type: 'phone', modifiers: ['optional'] }],
+    // Slugs
+    [/^slug$/i, { type: 'slug', modifiers: ['unique'] }],
+    // Timestamps - auto-managed
+    [/^createdAt$|^created_at$/i, { type: 'timestamp', modifiers: ['auto'] }],
+    [/^updatedAt$|^updated_at$/i, { type: 'timestamp', modifiers: ['auto'] }],
+    [/^deletedAt$|^deleted_at$/i, { type: 'timestamp', modifiers: ['optional'] }],
+    [/^publishedAt$|^published_at$/i, { type: 'timestamp', modifiers: ['optional'] }],
+    [/At$|_at$/i, { type: 'timestamp', modifiers: ['optional'] }],
+    // Booleans - common patterns
+    [/^is[A-Z]|^has[A-Z]|^can[A-Z]|^should[A-Z]/i, { type: 'bool', modifiers: [] }],
+    [/^active$|^enabled$|^published$|^verified$|^approved$/i, { type: 'bool', modifiers: [] }],
+    // Counts/numbers
+    [/count$|Count$|^total|Total$|^num|Num$|^amount|Amount$/i, { type: 'int', modifiers: [] }],
+    [/^age$|^order$|^priority$|^position$|^rank$/i, { type: 'int', modifiers: [] }],
+    [/^price$|^cost$|^amount$|^balance$|^rate$/i, { type: 'float', modifiers: [] }],
+    // Long text content
+    [/^content$|^body$|^text$|^description$|^summary$/i, { type: 'markdown', modifiers: [] }],
+    [/^bio$|^about$|^notes$/i, { type: 'markdown', modifiers: ['optional'] }],
+    // JSON data
+    [/^data$|^meta$|^metadata$|^settings$|^config$|^options$/i, { type: 'json', modifiers: ['optional'] }],
+];
+// Default: string
+const DEFAULT_TYPE = { type: 'string', modifiers: [] };
+/**
+ * Infer field type from field name
+ */
+export function inferFieldType(fieldName) {
+    for (const [pattern, inferredType] of FIELD_PATTERNS) {
+        if (pattern.test(fieldName)) {
+            return inferredType;
+        }
+    }
+    return DEFAULT_TYPE;
+}
+/**
+ * Parse explicit type annotation if present
+ * Examples: "role:enum(admin,user)", "age:int", "bio:text:optional"
+ */
+export function parseExplicitType(spec) {
+    // Clean up: remove trailing punctuation and whitespace
+    const cleaned = spec.trim().replace(/[.,;!?]+$/, '');
+    // Match: fieldName:type or fieldName:type(args) or fieldName:type:modifier
+    const match = cleaned.match(/^(\w+):(\w+)(?:\(([^)]+)\))?(?::(\w+))?$/);
+    if (!match)
+        return null;
+    const [, name, type, args, modifier] = match;
+    const modifiers = modifier ? [modifier] : [];
+    // Handle enum
+    if (type === 'enum' && args) {
+        return {
+            name,
+            type: {
+                type: `enum:${args}`,
+                modifiers,
+            },
+        };
+    }
+    return {
+        name,
+        type: {
+            type,
+            modifiers,
+        },
+    };
+}
+/**
+ * Parse enum from parenthetical notation
+ * Example: "role (admin, user, guest)" → { name: 'role', values: ['admin', 'user', 'guest'] }
+ */
+export function parseInlineEnum(text) {
+    const match = text.match(/^(\w+)\s*\(([^)]+)\)$/);
+    if (!match)
+        return null;
+    const [, name, valuesStr] = match;
+    const values = valuesStr.split(/[,\/|]/).map(v => v.trim()).filter(Boolean);
+    if (values.length < 2)
+        return null; // Not an enum, probably a function
+    return { name, values };
+}

package/dist/codegen/form-parser.d.ts

@@ -0,0 +1,13 @@
+import type { FormBlock } from '../codedna/kappa-ast.js';
+export interface ParsedForm {
+    form: FormBlock;
+}
+export interface FormParseResult {
+    success: boolean;
+    forms: FormBlock[];
+    errors: string[];
+}
+/**
+ * Parse natural language form description into FormBlock
+ */
+export declare function parseFormDescription(description: string): FormParseResult;

package/dist/codegen/form-parser.js

@@ -0,0 +1,186 @@
+// =============================================================================
+// Natural Language → Form AST Parser
+// =============================================================================
+//
+// Converts natural language form descriptions into Kappa FormBlock AST.
+// Examples:
+//   "Login form with email, password"
+//   "User registration with name, email, password, confirm password"
+//   "Contact form with name, email, subject, message"
+//
+const defaultLoc = {
+    startLine: 1,
+    startColumn: 1,
+    endLine: 1,
+    endColumn: 1,
+    startOffset: 0,
+    endOffset: 0,
+};
+/**
+ * Parse natural language form description into FormBlock
+ */
+export function parseFormDescription(description) {
+    const errors = [];
+    const forms = [];
+    try {
+        // Extract form name (e.g., "Login form", "User registration", "Contact form")
+        const nameMatch = description.match(/^([A-Za-z\s]+?)(?:\s+form|\s+with)/i);
+        if (!nameMatch) {
+            throw new Error('Could not extract form name. Try: "Login form with email, password"');
+        }
+        const formName = nameMatch[1].trim()
+            .split(/\s+/)
+            .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+            .join('');
+        // Extract fields (after "with")
+        const fieldsMatch = description.match(/with\s+(.+)$/i);
+        if (!fieldsMatch) {
+            throw new Error('Could not find fields. Use format: "FormName with field1, field2"');
+        }
+        const fieldsStr = fieldsMatch[1];
+        const fields = parseFormFields(fieldsStr);
+        // Determine submit button text based on form type
+        const submitText = inferSubmitText(formName, description);
+        const form = {
+            kind: 'FormBlock',
+            name: formName,
+            fields,
+            submit: {
+                kind: 'FormSubmit',
+                action: 'submit',
+                button: submitText,
+                loading: `${submitText.replace(/^(.*?)(?:ing)?$/, '$1ing')}...`,
+                onSuccess: 'console.log("Form submitted successfully")',
+                onError: 'console.error("Form submission failed", error)',
+                loc: defaultLoc,
+            },
+            layout: [],
+            loc: defaultLoc,
+        };
+        forms.push(form);
+    }
+    catch (e) {
+        errors.push(e instanceof Error ? e.message : String(e));
+    }
+    return {
+        success: errors.length === 0 && forms.length > 0,
+        forms,
+        errors,
+    };
+}
+/**
+ * Parse comma-separated form fields
+ */
+function parseFormFields(fieldsStr) {
+    const fields = [];
+    const parts = fieldsStr.split(',').map(s => s.trim());
+    for (const part of parts) {
+        if (!part)
+            continue;
+        const field = createFormField(part);
+        fields.push(field);
+    }
+    return fields;
+}
+/**
+ * Create a FormField from a field name
+ */
+function createFormField(fieldName) {
+    const normalizedName = fieldName.replace(/\s+/g, '');
+    const label = fieldName
+        .split(/\s+/)
+        .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+        .join(' ');
+    // Infer field type from name
+    const { type, required, placeholder } = inferFormFieldType(normalizedName);
+    return {
+        kind: 'FormField',
+        name: normalizedName,
+        label,
+        type,
+        required,
+        placeholder,
+        options: type === 'select' ? [] : undefined,
+        loc: defaultLoc,
+    };
+}
+/**
+ * Infer form field type from field name
+ */
+function inferFormFieldType(fieldName) {
+    const lower = fieldName.toLowerCase();
+    // Email
+    if (lower.includes('email')) {
+        return { type: 'email', required: true, placeholder: 'your@email.com' };
+    }
+    // Password
+    if (lower.includes('password')) {
+        return { type: 'password', required: true, placeholder: '••••••••' };
+    }
+    // Number/Age
+    if (lower.includes('age') || lower.includes('count') || lower.includes('quantity')) {
+        return { type: 'number', required: false };
+    }
+    // Date
+    if (lower.includes('date') || lower.includes('birthday') || lower.includes('dob')) {
+        return { type: 'date', required: false };
+    }
+    // Time
+    if (lower.includes('time')) {
+        return { type: 'time', required: false };
+    }
+    // Textarea (for longer content)
+    if (lower.includes('message') ||
+        lower.includes('description') ||
+        lower.includes('bio') ||
+        lower.includes('comment') ||
+        lower.includes('content')) {
+        return { type: 'textarea', required: false, placeholder: 'Enter your message...' };
+    }
+    // Checkbox
+    if (lower.includes('agree') ||
+        lower.includes('accept') ||
+        lower.includes('consent') ||
+        lower.includes('subscribe')) {
+        return { type: 'checkbox', required: false };
+    }
+    // Phone
+    if (lower.includes('phone') || lower.includes('mobile')) {
+        return { type: 'text', required: false, placeholder: '+1 (555) 123-4567' };
+    }
+    // URL
+    if (lower.includes('website') || lower.includes('url')) {
+        return { type: 'text', required: false, placeholder: 'https://example.com' };
+    }
+    // Default to text
+    return { type: 'text', required: false };
+}
+/**
+ * Infer submit button text from form name/description
+ */
+function inferSubmitText(formName, description) {
+    const lower = formName.toLowerCase();
+    const descLower = description.toLowerCase();
+    if (lower.includes('login') || lower.includes('signin')) {
+        return 'Sign In';
+    }
+    if (lower.includes('register') || lower.includes('signup') || descLower.includes('registration')) {
+        return 'Create Account';
+    }
+    if (lower.includes('contact')) {
+        return 'Send Message';
+    }
+    if (lower.includes('search')) {
+        return 'Search';
+    }
+    if (lower.includes('update') || lower.includes('edit')) {
+        return 'Update';
+    }
+    if (lower.includes('delete')) {
+        return 'Delete';
+    }
+    if (lower.includes('reset')) {
+        return 'Reset Password';
+    }
+    return 'Submit';
+}

package/dist/codegen/index.d.ts

@@ -0,0 +1,2 @@
+export { cloudCodegen, CloudCodegenClient, defaultClient as cloudClient, } from './cloud-client.js';
+export type { CloudCodegenConfig, CodegenInput, CodegenResult, GeneratorInfo, CategoryInfo, FrameworkInfo, } from './cloud-client.js';

package/dist/codegen/index.js

@@ -0,0 +1,4 @@
+// =============================================================================
+// Codegen Module - Cloud Only
+// =============================================================================
+export { cloudCodegen, CloudCodegenClient, defaultClient as cloudClient, } from './cloud-client.js';