@claudetools/tools 0.3.9 → 0.4.0

package/dist/codedna/registry.js

@@ -0,0 +1,214 @@
+// =============================================================================
+// Template Registry Client
+// =============================================================================
+//
+// HTTP client for Cloudflare Workers template registry with local caching
+// and fallback to bundled templates on network failure.
+//
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+export class TemplateRegistry {
+    baseUrl;
+    cacheDir;
+    useCache;
+    constructor(baseUrl = 'https://templates.claudetools.com', useCache = true) {
+        this.baseUrl = baseUrl;
+        this.cacheDir = path.join(__dirname, '../../templates');
+        this.useCache = useCache;
+    }
+    /**
+     * List all available generators
+     */
+    async listGenerators() {
+        try {
+            const response = await fetch(`${this.baseUrl}/registry`, {
+                signal: AbortSignal.timeout(5000), // 5 second timeout
+            });
+            if (!response.ok) {
+                throw new Error(`Registry fetch failed: ${response.statusText}`);
+            }
+            const data = await response.json();
+            return data.generators;
+        }
+        catch (error) {
+            console.warn('Failed to fetch from registry, using local fallback:', error);
+            return this.getLocalGenerators();
+        }
+    }
+    /**
+     * Get metadata for specific generator
+     */
+    async getGeneratorMetadata(generatorId) {
+        try {
+            const response = await fetch(`${this.baseUrl}/metadata/${generatorId}`, {
+                signal: AbortSignal.timeout(5000),
+            });
+            if (!response.ok) {
+                throw new Error(`Metadata fetch failed: ${response.statusText}`);
+            }
+            return await response.json();
+        }
+        catch (error) {
+            console.warn('Failed to fetch metadata from registry, using local fallback:', error);
+            return this.getLocalMetadata(generatorId);
+        }
+    }
+    /**
+     * Get template file content
+     */
+    async getTemplate(generatorId, templateFile) {
+        // Check cache first
+        if (this.useCache) {
+            const cached = await this.getCachedTemplate(generatorId, templateFile);
+            if (cached)
+                return cached;
+        }
+        // Fetch from registry
+        try {
+            const response = await fetch(`${this.baseUrl}/templates/${generatorId}/${templateFile}`, {
+                signal: AbortSignal.timeout(10000), // 10 second timeout for templates
+            });
+            if (!response.ok) {
+                throw new Error(`Template fetch failed: ${response.statusText}`);
+            }
+            const content = await response.text();
+            // Cache it
+            if (this.useCache) {
+                await this.cacheTemplate(generatorId, templateFile, content);
+            }
+            return content;
+        }
+        catch (error) {
+            console.warn('Failed to fetch template from registry, using local fallback:', error);
+            return this.getLocalTemplate(generatorId, templateFile);
+        }
+    }
+    /**
+     * Get multiple templates at once
+     */
+    async getTemplates(generatorId, templateFiles) {
+        const results = {};
+        await Promise.all(templateFiles.map(async (file) => {
+            results[file] = await this.getTemplate(generatorId, file);
+        }));
+        return results;
+    }
+    /**
+     * Check if template is cached locally
+     */
+    async getCachedTemplate(generatorId, templateFile) {
+        try {
+            const cachePath = path.join(this.cacheDir, generatorId, templateFile);
+            return await fs.readFile(cachePath, 'utf-8');
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Cache template locally
+     */
+    async cacheTemplate(generatorId, templateFile, content) {
+        try {
+            const cachePath = path.join(this.cacheDir, generatorId, templateFile);
+            await fs.mkdir(path.dirname(cachePath), { recursive: true });
+            await fs.writeFile(cachePath, content, 'utf-8');
+        }
+        catch (error) {
+            console.warn('Failed to cache template:', error);
+        }
+    }
+    /**
+     * Get local generators (fallback)
+     */
+    async getLocalGenerators() {
+        // Return hardcoded list of bundled generators
+        return [
+            {
+                id: 'express-api',
+                name: 'Express REST API',
+                framework: 'express',
+                description: 'Generate TypeScript Express API with CRUD operations',
+                features: ['auth', 'validation', 'tests'],
+                databases: ['postgresql', 'mysql', 'mongodb'],
+                version: '1.0.0',
+                templates: [
+                    'controller.ts.j2',
+                    'model.ts.j2',
+                    'route.ts.j2',
+                    'middleware.ts.j2',
+                    'validator.ts.j2',
+                ],
+            },
+        ];
+    }
+    /**
+     * Get local metadata (fallback)
+     */
+    async getLocalMetadata(generatorId) {
+        const generators = await this.getLocalGenerators();
+        const generator = generators.find(g => g.id === generatorId);
+        if (!generator) {
+            throw new Error(`Generator not found: ${generatorId}`);
+        }
+        return generator;
+    }
+    /**
+     * Get local template (fallback)
+     */
+    async getLocalTemplate(generatorId, templateFile) {
+        // Try to load from local bundled templates
+        const localPath = path.join(__dirname, '../../../cloudflare/templates', generatorId, templateFile);
+        try {
+            return await fs.readFile(localPath, 'utf-8');
+        }
+        catch (error) {
+            throw new Error(`Template not found: ${generatorId}/${templateFile}. Registry unavailable and local fallback missing.`);
+        }
+    }
+    /**
+     * Clear local cache
+     */
+    async clearCache() {
+        try {
+            await fs.rm(this.cacheDir, { recursive: true, force: true });
+        }
+        catch (error) {
+            console.warn('Failed to clear cache:', error);
+        }
+    }
+    /**
+     * Get cache statistics
+     */
+    async getCacheStats() {
+        try {
+            const entries = await fs.readdir(this.cacheDir, { withFileTypes: true });
+            const generators = entries.filter(e => e.isDirectory()).map(e => e.name);
+            let totalFiles = 0;
+            let totalSize = 0;
+            for (const gen of generators) {
+                const genPath = path.join(this.cacheDir, gen);
+                const files = await fs.readdir(genPath);
+                totalFiles += files.length;
+                for (const file of files) {
+                    const stats = await fs.stat(path.join(genPath, file));
+                    totalSize += stats.size;
+                }
+            }
+            return {
+                cachedGenerators: generators,
+                totalFiles,
+                totalSize,
+            };
+        }
+        catch {
+            return {
+                cachedGenerators: [],
+                totalFiles: 0,
+                totalSize: 0,
+            };
+        }
+    }
+}

package/dist/codedna/template-engine.d.ts

@@ -0,0 +1,17 @@
+import { EntitySpec } from './parser.js';
+export declare class TemplateEngine {
+    private env;
+    constructor();
+    /**
+     * Render template string with context
+     */
+    render(template: string, context: any): string;
+    /**
+     * Add custom filters for code generation
+     */
+    private addFilters;
+}
+/**
+ * Helper to build template context from EntitySpec
+ */
+export declare function buildContext(entity: EntitySpec, options?: any): any;

package/dist/codedna/template-engine.js

@@ -0,0 +1,149 @@
+// =============================================================================
+// Template Engine with Custom Filters
+// =============================================================================
+//
+// Jinja2-style template engine using nunjucks with custom filters for
+// code generation (plural, camelCase, TypeScript types, SQL types, etc.)
+//
+import nunjucks from 'nunjucks';
+export class TemplateEngine {
+    env;
+    constructor() {
+        // Configure nunjucks
+        this.env = new nunjucks.Environment(null, {
+            autoescape: false,
+            trimBlocks: true,
+            lstripBlocks: true,
+        });
+        // Add custom filters
+        this.addFilters();
+    }
+    /**
+     * Render template string with context
+     */
+    render(template, context) {
+        return this.env.renderString(template, context);
+    }
+    /**
+     * Add custom filters for code generation
+     */
+    addFilters() {
+        // Pluralize: User → Users
+        this.env.addFilter('plural', (str) => {
+            if (str.endsWith('y'))
+                return str.slice(0, -1) + 'ies';
+            if (str.endsWith('s'))
+                return str + 'es';
+            return str + 's';
+        });
+        // Lowercase: User → user
+        this.env.addFilter('lower', (str) => {
+            return str.toLowerCase();
+        });
+        // Uppercase: user → USER
+        this.env.addFilter('upper', (str) => {
+            return str.toUpperCase();
+        });
+        // camelCase: user_name → userName
+        this.env.addFilter('camel', (str) => {
+            return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+        });
+        // PascalCase: user_name → UserName
+        this.env.addFilter('pascal', (str) => {
+            const camel = str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+            return camel.charAt(0).toUpperCase() + camel.slice(1);
+        });
+        // snake_case: userName → user_name
+        this.env.addFilter('snake', (str) => {
+            return str.replace(/[A-Z]/g, letter => '_' + letter.toLowerCase());
+        });
+        // kebab-case: userName → user-name
+        this.env.addFilter('kebab', (str) => {
+            return str.replace(/[A-Z]/g, letter => '-' + letter.toLowerCase());
+        });
+        // Check if array includes value
+        this.env.addFilter('includes', (arr, val) => {
+            return Array.isArray(arr) && arr.includes(val);
+        });
+        // Get TypeScript type for field
+        this.env.addFilter('tsType', (field) => {
+            if (field.type.kind === 'primitive') {
+                const typeMap = {
+                    string: 'string',
+                    integer: 'number',
+                    decimal: 'number',
+                    boolean: 'boolean',
+                    datetime: 'Date',
+                };
+                return typeMap[field.type.value];
+            }
+            if (field.type.kind === 'reference') {
+                return field.type.entity;
+            }
+            if (field.type.kind === 'enum') {
+                return field.type.values.map(v => `'${v}'`).join(' | ');
+            }
+            return 'any';
+        });
+        // Get SQL type for field
+        this.env.addFilter('sqlType', (field) => {
+            if (field.type.kind === 'primitive') {
+                const typeMap = {
+                    string: 'VARCHAR(255)',
+                    integer: 'INTEGER',
+                    decimal: 'DECIMAL(10,2)',
+                    boolean: 'BOOLEAN',
+                    datetime: 'TIMESTAMP',
+                };
+                return typeMap[field.type.value];
+            }
+            if (field.type.kind === 'reference') {
+                return 'INTEGER'; // Foreign key
+            }
+            if (field.type.kind === 'enum') {
+                return `ENUM(${field.type.values.map(v => `'${v}'`).join(',')})`;
+            }
+            return 'TEXT';
+        });
+        // Check if field has specific constraint
+        this.env.addFilter('hasConstraint', (field, constraintKind) => {
+            return field.constraints.some(c => c.kind === constraintKind);
+        });
+        // Get constraint value (for min, max, default)
+        this.env.addFilter('getConstraint', (field, constraintKind) => {
+            const constraint = field.constraints.find(c => c.kind === constraintKind);
+            if (!constraint)
+                return null;
+            if ('value' in constraint)
+                return constraint.value;
+            return true;
+        });
+        // Join array with custom separator
+        this.env.addFilter('joinWith', (arr, separator) => {
+            return arr.join(separator);
+        });
+        // First letter uppercase
+        this.env.addFilter('capitalize', (str) => {
+            return str.charAt(0).toUpperCase() + str.slice(1);
+        });
+        // Indent lines
+        this.env.addFilter('indent', (str, spaces = 2) => {
+            const indent = ' '.repeat(spaces);
+            return str.split('\n').map(line => indent + line).join('\n');
+        });
+    }
+}
+/**
+ * Helper to build template context from EntitySpec
+ */
+export function buildContext(entity, options = {}) {
+    return {
+        entity,
+        options,
+        // Helper data
+        hasRequiredFields: entity.fields.some(f => f.constraints.some(c => c.kind === 'required')),
+        hasUniqueFields: entity.fields.some(f => f.constraints.some(c => c.kind === 'unique')),
+        hasHashedFields: entity.fields.some(f => f.constraints.some(c => c.kind === 'hashed')),
+        hasReferences: entity.fields.some(f => f.type.kind === 'reference'),
+    };
+}

package/dist/codedna/types.d.ts

@@ -0,0 +1,64 @@
+import { EntitySpec } from './parser.js';
+/**
+ * Options for API generation
+ */
+export interface GenerateApiOptions {
+    auth?: boolean;
+    validation?: boolean;
+    tests?: boolean;
+    database?: 'postgresql' | 'mysql' | 'mongodb';
+}
+/**
+ * Options for frontend generation
+ */
+export interface GenerateFrontendOptions {
+    ui?: 'shadcn' | 'mui' | 'chakra';
+    forms?: boolean;
+    tables?: boolean;
+    routing?: boolean;
+}
+/**
+ * Options for component generation
+ */
+export interface GenerateComponentOptions {
+    ui?: 'shadcn' | 'mui' | 'chakra';
+    validation?: boolean;
+}
+/**
+ * Generated code result
+ */
+export interface GenerationResult {
+    files: Record<string, string>;
+    metadata: GenerationMetadata;
+}
+/**
+ * Metadata about generated code
+ */
+export interface GenerationMetadata {
+    generator: string;
+    framework: string;
+    entities: string[];
+    filesGenerated: number;
+    linesOfCode: number;
+    estimatedTokensSaved: number;
+}
+/**
+ * Generator metadata from registry
+ */
+export interface GeneratorMetadata {
+    id: string;
+    name: string;
+    framework: string;
+    description: string;
+    features: string[];
+    databases?: string[];
+    version: string;
+    templates: string[];
+}
+/**
+ * Template context for rendering
+ */
+export interface TemplateContext {
+    entity: EntitySpec;
+    options: any;
+}

package/dist/codedna/types.js

@@ -0,0 +1,4 @@
+// =============================================================================
+// CodeDNA TypeScript Types
+// =============================================================================
+export {};

package/dist/handlers/codedna-handlers.d.ts

@@ -0,0 +1,122 @@
+/**
+ * Handle codedna_generate_api tool call
+ */
+export declare function handleGenerateApi(args: any): Promise<{
+    error: string;
+    details: string[] | undefined;
+    message?: undefined;
+    supported?: undefined;
+    success?: undefined;
+    files?: undefined;
+    metadata?: undefined;
+    tokenSavings?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    supported?: undefined;
+    success?: undefined;
+    files?: undefined;
+    metadata?: undefined;
+    tokenSavings?: undefined;
+} | {
+    error: string;
+    supported: string[];
+    details?: undefined;
+    message?: undefined;
+    success?: undefined;
+    files?: undefined;
+    metadata?: undefined;
+    tokenSavings?: undefined;
+} | {
+    success: boolean;
+    files: Record<string, string>;
+    metadata: import("../codedna/types.js").GenerationMetadata;
+    tokenSavings: {
+        traditional: number;
+        codedna: number;
+        saved: number;
+        percentSaved: string;
+    };
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+    supported?: undefined;
+}>;
+/**
+ * Handle codedna_generate_frontend tool call
+ */
+export declare function handleGenerateFrontend(args: any): Promise<{
+    error: string;
+    details: string[] | undefined;
+    message?: undefined;
+    frameworks?: undefined;
+    status?: undefined;
+} | {
+    error: string;
+    message: string;
+    frameworks: string[];
+    status: string;
+    details?: undefined;
+}>;
+/**
+ * Handle codedna_generate_component tool call
+ */
+export declare function handleGenerateComponent(args: any): Promise<{
+    error: string;
+    details: string[] | undefined;
+    message?: undefined;
+    types?: undefined;
+    frameworks?: undefined;
+    status?: undefined;
+} | {
+    error: string;
+    message: string;
+    types: string[];
+    frameworks: string[];
+    status: string;
+    details?: undefined;
+}>;
+/**
+ * Handle codedna_list_generators tool call
+ */
+export declare function handleListGenerators(): Promise<{
+    generators: import("../codedna/types.js").GeneratorMetadata[];
+    summary: {
+        total: number;
+        byFramework: any;
+    };
+    error?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    generators?: undefined;
+    summary?: undefined;
+}>;
+/**
+ * Handle codedna_validate_spec tool call
+ */
+export declare function handleValidateSpec(args: any): Promise<{
+    valid: boolean;
+    entity: {
+        name: string;
+        fields: {
+            name: string;
+            type: import("../codedna/parser.js").FieldType;
+            constraints: ("default" | "min" | "max" | "required" | "unique" | "hashed" | "index")[];
+        }[];
+    };
+    summary: {
+        totalFields: number;
+        hasReferences: boolean;
+        hasEnums: boolean;
+        hasConstraints: boolean;
+    };
+    errors?: undefined;
+} | {
+    valid: boolean;
+    errors: string[] | undefined;
+    entity?: undefined;
+    summary?: undefined;
+}>;