@claudetools/tools 0.9.0 → 0.9.2

package/dist/codedna/parser.js

@@ -79,7 +79,16 @@ export class EntityParser {
         if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) {
             throw new Error(`Invalid field name: ${name}`);
         }
-        const type = this.parseType(typeStr);
+        let type = this.parseType(typeStr);
+        // Check for relationship annotations (one-to-many, many-to-many) in constraints
+        // These modify reference types to add relation metadata
+        const relationIndex = constraintStrs.findIndex(c => c === 'one-to-many' || c === 'many-to-many');
+        if (relationIndex !== -1 && type.kind === 'reference') {
+            const relation = constraintStrs[relationIndex] === 'one-to-many' ? 'oneToMany' : 'manyToMany';
+            type = { ...type, relation };
+            // Remove the relation annotation from constraints since it's been applied to the type
+            constraintStrs.splice(relationIndex, 1);
+        }
         const constraints = constraintStrs.map(c => this.parseConstraint(c));
         return { name, type, constraints };
     }
@@ -103,6 +112,22 @@ export class EntityParser {
         if (refMatch) {
             return { kind: 'reference', entity: refMatch[1] };
         }
+        // Check for array notation: EntityName[] (reference array)
+        const refArrayMatch = typeStr.match(/^([A-Z][a-zA-Z0-9]*)\[\]$/);
+        if (refArrayMatch) {
+            return { kind: 'reference', entity: refArrayMatch[1] };
+        }
+        // Check for simple reference: EntityName (capitalized = entity reference)
+        const entityRefMatch = typeStr.match(/^([A-Z][a-zA-Z0-9]*)$/);
+        if (entityRefMatch) {
+            return { kind: 'reference', entity: entityRefMatch[1] };
+        }
+        // Check for primitive array: string[], integer[], boolean[], decimal[]
+        const primitiveArrayMatch = typeStr.match(/^(string|integer|decimal|boolean)\[\]$/);
+        if (primitiveArrayMatch) {
+            const itemType = primitiveArrayMatch[1];
+            return { kind: 'array', itemType };
+        }
         // Check for array: array(string), array(integer), etc.
         const arrayMatch = typeStr.match(/^array\((string|integer|decimal|boolean)\)$/);
         if (arrayMatch) {

package/dist/codegen/cloud-client.d.ts

@@ -0,0 +1,160 @@
+export interface CloudCodegenConfig {
+    /** API base URL (default: https://api.claudetools.dev) */
+    apiUrl?: string;
+    /** API key for authentication */
+    apiKey?: string;
+    /** User ID for analytics */
+    userId?: string;
+    /** Project ID for analytics */
+    projectId?: string;
+    /** Request timeout in ms (default: 30000) */
+    timeout?: number;
+}
+export interface CodegenInput {
+    /** Natural language description */
+    describe: string;
+    /** What to generate (schema, types, validators, api, components, forms, pages, tests, all) */
+    generate?: string[];
+    /** Override auto-detected stack */
+    stack?: {
+        orm?: string;
+        api?: string;
+        ui?: string;
+        db?: string;
+        framework?: string;
+    };
+}
+export interface GeneratedFile {
+    path: string;
+    content: string;
+    description: string;
+}
+export interface CodegenResult {
+    success: boolean;
+    files: GeneratedFile[];
+    entities: string[];
+    summary: string;
+    errors?: string[];
+    /** Generation time in ms */
+    generationTimeMs?: number;
+    /** Generators used */
+    generators?: Array<{
+        id: string;
+        name: string;
+        category: string;
+    }>;
+}
+export interface GeneratorInfo {
+    id: string;
+    name: string;
+    slug: string;
+    description: string;
+    category: string;
+    categoryName: string;
+    qualityScore: number;
+    usageCount: number;
+    version: string;
+    outputFiles: string[];
+    dependencies: string[];
+}
+export interface CategoryInfo {
+    id: string;
+    name: string;
+    description: string;
+    parentId: string | null;
+    icon: string | null;
+    generatorCount: number;
+}
+export interface FrameworkInfo {
+    id: string;
+    name: string;
+    packageName: string;
+    currentVersion: string;
+    language: string;
+    ecosystem: string;
+    generatorCount: number;
+}
+export declare class CloudCodegenClient {
+    private config;
+    constructor(config?: CloudCodegenConfig);
+    /**
+     * Generate code from natural language description
+     */
+    generate(input: CodegenInput): Promise<CodegenResult>;
+    /**
+     * List available generators
+     */
+    listGenerators(options?: {
+        category?: string;
+        framework?: string;
+        status?: string;
+    }): Promise<GeneratorInfo[]>;
+    /**
+     * Get generator details
+     */
+    getGenerator(id: string): Promise<GeneratorInfo & {
+        frameworks: Array<{
+            id: string;
+            name: string;
+            language: string;
+            minVersion: string;
+            maxVersion: string;
+            isPrimary: boolean;
+        }>;
+        recentVersions: Array<{
+            version: string;
+            changelog: string;
+            qualityScore: number;
+            createdAt: string;
+        }>;
+    }>;
+    /**
+     * List categories
+     */
+    listCategories(): Promise<CategoryInfo[]>;
+    /**
+     * List frameworks
+     */
+    listFrameworks(language?: string): Promise<{
+        frameworks: FrameworkInfo[];
+        byLanguage: Record<string, FrameworkInfo[]>;
+        languages: string[];
+    }>;
+    /**
+     * Check API health
+     */
+    health(): Promise<{
+        status: string;
+        timestamp: string;
+        services: {
+            database: boolean;
+            storage: boolean;
+        };
+        stats: {
+            publishedGenerators: number;
+            categories: number;
+            frameworks: number;
+            totalUsage: number;
+            averageQuality: number;
+        };
+    }>;
+    private fetch;
+}
+/**
+ * Generate code using the cloud API
+ *
+ * @example
+ * ```ts
+ * const result = await cloudCodegen({
+ *   describe: 'User with email, password, role (admin/user)',
+ *   generate: ['schema', 'types', 'api'],
+ *   stack: { orm: 'drizzle', api: 'hono' }
+ * });
+ *
+ * for (const file of result.files) {
+ *   console.log(`${file.path}: ${file.description}`);
+ * }
+ * ```
+ */
+export declare function cloudCodegen(input: CodegenInput, config?: CloudCodegenConfig): Promise<CodegenResult>;
+export declare const defaultClient: CloudCodegenClient;

package/dist/codegen/cloud-client.js

@@ -0,0 +1,195 @@
+// =============================================================================
+// Codegen Cloud Client
+// =============================================================================
+//
+// Thin client that delegates ALL code generation to the cloud API.
+// No local parsing or generation - cloud handles everything.
+//
+// =============================================================================
+// =============================================================================
+// Cloud Client
+// =============================================================================
+export class CloudCodegenClient {
+    config;
+    constructor(config = {}) {
+        this.config = {
+            apiUrl: config.apiUrl || 'https://api.claudetools.dev',
+            apiKey: config.apiKey || '',
+            userId: config.userId || '',
+            projectId: config.projectId || '',
+            timeout: config.timeout || 30000,
+        };
+    }
+    /**
+     * Generate code from natural language description
+     */
+    async generate(input) {
+        if (!input.describe || input.describe.trim() === '') {
+            return {
+                success: false,
+                files: [],
+                entities: [],
+                summary: 'Missing description',
+                errors: ['Please provide a description of what to generate'],
+            };
+        }
+        try {
+            const response = await this.fetch('/api/v1/codegen/generate', {
+                method: 'POST',
+                body: JSON.stringify({
+                    describe: input.describe,
+                    generate: input.generate || ['schema', 'types', 'validators'],
+                    stack: input.stack,
+                    userId: this.config.userId,
+                    projectId: this.config.projectId,
+                }),
+            });
+            if (!response.success) {
+                return {
+                    success: false,
+                    files: [],
+                    entities: [],
+                    summary: response.error || 'Generation failed',
+                    errors: [response.error || 'Unknown error'],
+                };
+            }
+            const data = response.data;
+            return {
+                success: true,
+                files: data.files || [],
+                entities: data.entities || [],
+                summary: data.summary || `Generated ${data.files?.length || 0} files`,
+                generators: data.generators,
+                generationTimeMs: data.generationTimeMs,
+                errors: data.errors,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                files: [],
+                entities: [],
+                summary: 'API request failed',
+                errors: [error instanceof Error ? error.message : String(error)],
+            };
+        }
+    }
+    /**
+     * List available generators
+     */
+    async listGenerators(options) {
+        const params = new URLSearchParams();
+        if (options?.category)
+            params.set('category', options.category);
+        if (options?.framework)
+            params.set('framework', options.framework);
+        if (options?.status)
+            params.set('status', options.status);
+        const url = `/api/v1/codegen/generators${params.toString() ? `?${params}` : ''}`;
+        const response = await this.fetch(url);
+        if (!response.success) {
+            throw new Error(response.error || 'Failed to list generators');
+        }
+        return response.data.generators;
+    }
+    /**
+     * Get generator details
+     */
+    async getGenerator(id) {
+        const response = await this.fetch(`/api/v1/codegen/generators/${id}`);
+        if (!response.success) {
+            throw new Error(response.error || 'Failed to get generator');
+        }
+        return response.data;
+    }
+    /**
+     * List categories
+     */
+    async listCategories() {
+        const response = await this.fetch('/api/v1/codegen/categories');
+        if (!response.success) {
+            throw new Error(response.error || 'Failed to list categories');
+        }
+        return response.data.categories;
+    }
+    /**
+     * List frameworks
+     */
+    async listFrameworks(language) {
+        const url = language
+            ? `/api/v1/codegen/frameworks?language=${language}`
+            : '/api/v1/codegen/frameworks';
+        const response = await this.fetch(url);
+        if (!response.success) {
+            throw new Error(response.error || 'Failed to list frameworks');
+        }
+        return response.data;
+    }
+    /**
+     * Check API health
+     */
+    async health() {
+        const response = await this.fetch('/api/v1/codegen/health');
+        if (!response.success) {
+            throw new Error(response.error || 'Health check failed');
+        }
+        return response.data;
+    }
+    // ===========================================================================
+    // Private Methods
+    // ===========================================================================
+    async fetch(path, options = {}) {
+        const url = `${this.config.apiUrl}${path}`;
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+        try {
+            const response = await fetch(url, {
+                ...options,
+                signal: controller.signal,
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...(this.config.apiKey && { Authorization: `Bearer ${this.config.apiKey}` }),
+                    ...options.headers,
+                },
+            });
+            clearTimeout(timeoutId);
+            const data = await response.json();
+            return data;
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            if (error instanceof Error && error.name === 'AbortError') {
+                return { success: false, error: 'Request timeout' };
+            }
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Network error',
+            };
+        }
+    }
+}
+// =============================================================================
+// Convenience Function
+// =============================================================================
+/**
+ * Generate code using the cloud API
+ *
+ * @example
+ * ```ts
+ * const result = await cloudCodegen({
+ *   describe: 'User with email, password, role (admin/user)',
+ *   generate: ['schema', 'types', 'api'],
+ *   stack: { orm: 'drizzle', api: 'hono' }
+ * });
+ *
+ * for (const file of result.files) {
+ *   console.log(`${file.path}: ${file.description}`);
+ * }
+ * ```
+ */
+export async function cloudCodegen(input, config) {
+    const client = new CloudCodegenClient(config);
+    return client.generate(input);
+}
+// Export default client instance
+export const defaultClient = new CloudCodegenClient();

package/dist/codegen/codegen-tool.d.ts

@@ -0,0 +1,35 @@
+export interface CodegenInput {
+    /** Natural language description of what to generate */
+    describe: string;
+    /** Override auto-detected stack (optional) */
+    stack?: {
+        orm?: 'drizzle' | 'prisma' | 'typeorm' | 'mongoose';
+        api?: 'hono' | 'express' | 'trpc';
+        ui?: 'shadcn' | 'mantine' | 'radix';
+        db?: 'sqlite' | 'postgres' | 'mysql';
+    };
+    /** What to generate (default: schema, types, validators) */
+    generate?: ('schema' | 'types' | 'validators' | 'api' | 'tests' | 'components' | 'pages' | 'forms' | 'all')[];
+}
+export interface GeneratedFile {
+    path: string;
+    content: string;
+    description: string;
+}
+export interface CodegenResult {
+    success: boolean;
+    files: GeneratedFile[];
+    entities: string[];
+    summary: string;
+    errors?: string[];
+}
+export interface DetectedStack {
+    orm: 'drizzle' | 'prisma' | 'typeorm' | 'mongoose' | null;
+    api: 'hono' | 'express' | 'trpc' | 'fastify' | null;
+    ui: 'shadcn' | 'mantine' | 'radix' | 'chakra' | null;
+    db: 'sqlite' | 'postgres' | 'mysql' | 'mongodb' | null;
+    framework: 'tanstack-start' | 'nextjs' | null;
+    lang: 'typescript' | 'javascript';
+}
+export declare function detectStack(packageJson?: Record<string, unknown>): DetectedStack;
+export declare function codegen(input: CodegenInput, packageJson?: Record<string, unknown>): CodegenResult;