@claudetools/tools 0.7.0 → 0.7.1

package/dist/codedna/registry.js

@@ -2,18 +2,29 @@
 // Template Registry Client
 // =============================================================================
 //
-// HTTP client for Cloudflare Workers template registry with local caching
-// and fallback to bundled templates on network failure.
+// HTTP client for Cloudflare Workers template registry.
+// Cloudflare D1 is the single source of truth for generators.
+// Local file cache provides offline fallback for templates only.
+//
+// Registry data structure:
+//   - generators: flat list with domain field (api/frontend/component)
+//   - byDomain: grouped by domain for easy filtering
+//   - summary: counts by domain
 //
 import fs from 'fs/promises';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import { errorTracker } from '../helpers/error-tracking.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
+// Cache TTL in milliseconds (1 hour for registry, 24 hours for templates)
+const REGISTRY_CACHE_TTL = 60 * 60 * 1000;
+const TEMPLATE_CACHE_TTL = 24 * 60 * 60 * 1000;
 export class TemplateRegistry {
     baseUrl;
     cacheDir;
     useCache;
+    // In-memory cache for registry data
+    registryCache = null;
     constructor(baseUrl = 'https://api.claudetools.dev/api/v1/codedna', useCache = true) {
         this.baseUrl = baseUrl;
         this.cacheDir = path.join(__dirname, '../../templates');
@@ -21,21 +32,54 @@ export class TemplateRegistry {
     }
     /**
      * List all available generators
+     * Fetches from Cloudflare D1 (single source of truth)
+     * @param domain Optional domain filter: 'api' | 'frontend' | 'component'
      */
-    async listGenerators() {
+    async listGenerators(domain) {
+        // Check in-memory cache first
+        if (this.registryCache && Date.now() - this.registryCache.timestamp < REGISTRY_CACHE_TTL) {
+            const cached = this.registryCache.data;
+            if (domain) {
+                return cached.filter(g => g.domain === domain);
+            }
+            return cached;
+        }
         try {
-            const response = await fetch(`${this.baseUrl}/registry`, {
-                signal: AbortSignal.timeout(5000), // 5 second timeout
+            const url = domain
+                ? `${this.baseUrl}/registry?domain=${domain}`
+                : `${this.baseUrl}/registry`;
+            const response = await fetch(url, {
+                signal: AbortSignal.timeout(5000),
             });
             if (!response.ok) {
                 throw new Error(`Registry fetch failed: ${response.statusText}`);
             }
-            const data = await response.json();
-            return data.generators;
+            const result = await response.json();
+            if (!result.success || !result.data?.generators) {
+                throw new Error('Invalid registry response');
+            }
+            // Cache the full list (not filtered)
+            if (!domain) {
+                this.registryCache = {
+                    data: result.data.generators,
+                    timestamp: Date.now(),
+                };
+            }
+            return result.data.generators;
         }
         catch (error) {
-            console.warn('Failed to fetch from registry, using local fallback:', error);
-            return this.getLocalGenerators();
+            console.warn('Failed to fetch from registry:', error);
+            // Try to use stale cache if available
+            if (this.registryCache) {
+                console.warn('Using stale registry cache');
+                const stale = this.registryCache.data;
+                if (domain) {
+                    return stale.filter(g => g.domain === domain);
+                }
+                return stale;
+            }
+            // No cache available - throw error (Cloudflare is required)
+            throw new Error('Registry unavailable and no cache. Please check your network connection or try again later.');
         }
     }
     /**
@@ -47,49 +91,64 @@ export class TemplateRegistry {
                 signal: AbortSignal.timeout(5000),
             });
             if (!response.ok) {
+                if (response.status === 404) {
+                    throw new Error(`Generator '${generatorId}' not found`);
+                }
                 throw new Error(`Metadata fetch failed: ${response.statusText}`);
             }
-            return await response.json();
+            const result = await response.json();
+            return result.data || result;
         }
         catch (error) {
-            console.warn('Failed to fetch metadata from registry, using local fallback:', error);
-            return this.getLocalMetadata(generatorId);
+            // Try to find in cached registry
+            if (this.registryCache) {
+                const cached = this.registryCache.data.find(g => g.id === generatorId);
+                if (cached) {
+                    console.warn('Using cached metadata for:', generatorId);
+                    return cached;
+                }
+            }
+            throw error;
         }
     }
     /**
      * Get template file content
      */
     async getTemplate(generatorId, templateFile) {
-        // Check cache first
+        // Check file cache first
         if (this.useCache) {
             const cached = await this.getCachedTemplate(generatorId, templateFile);
             if (cached)
                 return cached;
         }
-        // Fetch from registry
+        // Fetch from Cloudflare
         try {
             const response = await fetch(`${this.baseUrl}/templates/${generatorId}/${templateFile}`, {
-                signal: AbortSignal.timeout(10000), // 10 second timeout for templates
+                signal: AbortSignal.timeout(10000),
             });
             if (!response.ok) {
+                if (response.status === 404) {
+                    throw new Error(`Template '${templateFile}' not found for generator '${generatorId}'`);
+                }
                 throw new Error(`Template fetch failed: ${response.statusText}`);
             }
             const content = await response.text();
-            // Cache it
+            // Cache locally for offline use
             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);
-            // Track template fetch error
+            console.warn('Failed to fetch template:', error);
+            // Track fetch error
             await errorTracker.trackTemplateFetchError(generatorId, templateFile, error instanceof Error ? error : new Error(String(error)));
+            // Try local bundled fallback
             return this.getLocalTemplate(generatorId, templateFile);
         }
     }
     /**
-     * Get multiple templates at once
+     * Get multiple templates at once (parallel fetch)
      */
     async getTemplates(generatorId, templateFiles) {
         const results = {};
@@ -99,11 +158,16 @@ export class TemplateRegistry {
         return results;
     }
     /**
-     * Check if template is cached locally
+     * Get cached template from file system
      */
     async getCachedTemplate(generatorId, templateFile) {
         try {
             const cachePath = path.join(this.cacheDir, generatorId, templateFile);
+            const stats = await fs.stat(cachePath);
+            // Check if cache is still valid
+            if (Date.now() - stats.mtimeMs > TEMPLATE_CACHE_TTL) {
+                return null; // Cache expired
+            }
             return await fs.readFile(cachePath, 'utf-8');
         }
         catch {
@@ -111,7 +175,7 @@ export class TemplateRegistry {
         }
     }
     /**
-     * Cache template locally
+     * Cache template to file system
      */
     async cacheTemplate(generatorId, templateFile, content) {
         try {
@@ -124,245 +188,24 @@ export class TemplateRegistry {
         }
     }
     /**
-     * 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',
-                ],
-            },
-            {
-                id: 'fastapi-api',
-                name: 'FastAPI REST API',
-                framework: 'fastapi',
-                description: 'Generate Python FastAPI with Pydantic models and SQLAlchemy ORM',
-                features: ['auth', 'validation', 'tests'],
-                databases: ['postgresql', 'mysql', 'mongodb'],
-                version: '1.0.0',
-                templates: [
-                    'model.py.j2',
-                    'schemas.py.j2',
-                    'router.py.j2',
-                    'crud.py.j2',
-                    'test_api.py.j2',
-                ],
-            },
-            {
-                id: 'nestjs-api',
-                name: 'NestJS REST API',
-                framework: 'nestjs',
-                description: 'Generate TypeScript NestJS with TypeORM entities and DTOs',
-                features: ['auth', 'validation', 'tests'],
-                databases: ['postgresql', 'mysql', 'mongodb'],
-                version: '1.0.0',
-                templates: [
-                    'entity.ts.j2',
-                    'dto.ts.j2',
-                    'controller.ts.j2',
-                    'service.ts.j2',
-                    'module.ts.j2',
-                    'spec.ts.j2',
-                ],
-            },
-            {
-                id: 'react-frontend',
-                name: 'React/Next.js Frontend',
-                framework: 'react',
-                description: 'Generate React components with ShadcnUI for forms, tables, and pages',
-                features: ['forms', 'tables', 'routing'],
-                databases: [],
-                version: '1.0.0',
-                templates: [
-                    'form.tsx.j2',
-                    'table.tsx.j2',
-                    'list-page.tsx.j2',
-                    'detail-page.tsx.j2',
-                    'hooks.ts.j2',
-                ],
-            },
-            {
-                id: 'vue-frontend',
-                name: 'Vue 3 Frontend',
-                framework: 'vue',
-                description: 'Generate Vue 3 components with Composition API for forms, tables, and views',
-                features: ['forms', 'tables', 'routing'],
-                databases: [],
-                version: '1.0.0',
-                templates: [
-                    'Form.vue.j2',
-                    'Table.vue.j2',
-                    'ListView.vue.j2',
-                    'DetailView.vue.j2',
-                    'composables.ts.j2',
-                ],
-            },
-            // Component generators
-            {
-                id: 'react-form',
-                name: 'React Form Component',
-                framework: 'react',
-                description: 'Generate React form with Zod validation and ShadcnUI',
-                features: ['validation'],
-                databases: [],
-                version: '1.0.0',
-                templates: ['form.tsx.j2'],
-            },
-            {
-                id: 'react-table',
-                name: 'React Table Component',
-                framework: 'react',
-                description: 'Generate React data table with ShadcnUI',
-                features: [],
-                databases: [],
-                version: '1.0.0',
-                templates: ['table.tsx.j2'],
-            },
-            {
-                id: 'react-card',
-                name: 'React Card Component',
-                framework: 'react',
-                description: 'Generate React card component with ShadcnUI',
-                features: [],
-                databases: [],
-                version: '1.0.0',
-                templates: ['card.tsx.j2'],
-            },
-            {
-                id: 'react-modal',
-                name: 'React Modal Component',
-                framework: 'react',
-                description: 'Generate React modal/dialog with ShadcnUI',
-                features: [],
-                databases: [],
-                version: '1.0.0',
-                templates: ['modal.tsx.j2'],
-            },
-            {
-                id: 'vue-form',
-                name: 'Vue Form Component',
-                framework: 'vue',
-                description: 'Generate Vue 3 form with Vuelidate',
-                features: ['validation'],
-                databases: [],
-                version: '1.0.0',
-                templates: ['form.vue.j2'],
-            },
-            {
-                id: 'vue-table',
-                name: 'Vue Table Component',
-                framework: 'vue',
-                description: 'Generate Vue 3 data table component',
-                features: [],
-                databases: [],
-                version: '1.0.0',
-                templates: ['table.vue.j2'],
-            },
-            {
-                id: 'vue-card',
-                name: 'Vue Card Component',
-                framework: 'vue',
-                description: 'Generate Vue 3 card component',
-                features: [],
-                databases: [],
-                version: '1.0.0',
-                templates: ['card.vue.j2'],
-            },
-            {
-                id: 'vue-modal',
-                name: 'Vue Modal Component',
-                framework: 'vue',
-                description: 'Generate Vue 3 modal with Teleport',
-                features: [],
-                databases: [],
-                version: '1.0.0',
-                templates: ['modal.vue.j2'],
-            },
-            {
-                id: 'svelte-form',
-                name: 'Svelte Form Component',
-                framework: 'svelte',
-                description: 'Generate Svelte form with reactive bindings',
-                features: ['validation'],
-                databases: [],
-                version: '1.0.0',
-                templates: ['form.svelte.j2'],
-            },
-            {
-                id: 'svelte-table',
-                name: 'Svelte Table Component',
-                framework: 'svelte',
-                description: 'Generate Svelte data table component',
-                features: [],
-                databases: [],
-                version: '1.0.0',
-                templates: ['table.svelte.j2'],
-            },
-            {
-                id: 'svelte-card',
-                name: 'Svelte Card Component',
-                framework: 'svelte',
-                description: 'Generate Svelte card component',
-                features: [],
-                databases: [],
-                version: '1.0.0',
-                templates: ['card.svelte.j2'],
-            },
-            {
-                id: 'svelte-modal',
-                name: 'Svelte Modal Component',
-                framework: 'svelte',
-                description: 'Generate Svelte modal component',
-                features: [],
-                databases: [],
-                version: '1.0.0',
-                templates: ['modal.svelte.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)
+     * Get template from bundled local files (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) {
+        catch {
             throw new Error(`Template not found: ${generatorId}/${templateFile}. Registry unavailable and local fallback missing.`);
         }
     }
     /**
-     * Clear local cache
+     * Clear local template cache
      */
     async clearCache() {
         try {
             await fs.rm(this.cacheDir, { recursive: true, force: true });
+            this.registryCache = null;
         }
         catch (error) {
             console.warn('Failed to clear cache:', error);
@@ -372,32 +215,29 @@ export class TemplateRegistry {
      * Get cache statistics
      */
     async getCacheStats() {
+        const stats = {
+            registryCached: !!this.registryCache,
+            registryAge: this.registryCache ? Date.now() - this.registryCache.timestamp : null,
+            cachedGenerators: [],
+            totalFiles: 0,
+            totalSize: 0,
+        };
         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) {
+            stats.cachedGenerators = entries.filter(e => e.isDirectory()).map(e => e.name);
+            for (const gen of stats.cachedGenerators) {
                 const genPath = path.join(this.cacheDir, gen);
                 const files = await fs.readdir(genPath);
-                totalFiles += files.length;
+                stats.totalFiles += files.length;
                 for (const file of files) {
-                    const stats = await fs.stat(path.join(genPath, file));
-                    totalSize += stats.size;
+                    const fileStats = await fs.stat(path.join(genPath, file));
+                    stats.totalSize += fileStats.size;
                 }
             }
-            return {
-                cachedGenerators: generators,
-                totalFiles,
-                totalSize,
-            };
         }
         catch {
-            return {
-                cachedGenerators: [],
-                totalFiles: 0,
-                totalSize: 0,
-            };
+            // Cache directory doesn't exist yet
         }
+        return stats;
     }
 }

package/dist/codedna/template-engine.js

@@ -171,6 +171,9 @@ export class TemplateEngine {
  * Helper to build template context from EntitySpec
  */
 export function buildContext(entity, options = {}) {
+    // Pattern detection helpers
+    const patterns = options.patterns || { detected: [], preferred: [], avoid: [] };
+    const detectedPatternIds = patterns.detected?.map((p) => p.pattern_id) || [];
     return {
         entity,
         options,
@@ -179,5 +182,25 @@ export function buildContext(entity, options = {}) {
         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'),
+        // Pattern context for templates
+        patterns: {
+            detected: patterns.detected || [],
+            preferred: patterns.preferred || [],
+            avoid: patterns.avoid || [],
+            // Quick lookup helpers
+            hasPattern: (patternId) => detectedPatternIds.includes(patternId),
+            usesZod: detectedPatternIds.includes('zod-validation'),
+            usesYup: detectedPatternIds.includes('yup-validation'),
+            usesReactHookForm: detectedPatternIds.includes('react-hook-form'),
+            usesFormik: detectedPatternIds.includes('formik'),
+            usesTanstackQuery: detectedPatternIds.includes('tanstack-query'),
+            usesSwr: detectedPatternIds.includes('swr-pattern'),
+            usesZustand: detectedPatternIds.includes('zustand'),
+            usesRedux: detectedPatternIds.includes('redux-toolkit'),
+            usesTailwind: detectedPatternIds.includes('tailwind'),
+            usesShadcn: detectedPatternIds.includes('shadcn-ui'),
+            usesMui: detectedPatternIds.includes('mui-patterns'),
+            usesChakra: detectedPatternIds.includes('chakra-patterns'),
+        },
     };
 }

package/dist/codedna/types.d.ts

@@ -1,4 +1,21 @@
 import { EntitySpec } from './parser.js';
+/**
+ * Detected pattern from codebase analysis
+ */
+export interface DetectedPattern {
+    pattern_id: string;
+    name: string;
+    category: 'components' | 'hooks' | 'forms' | 'state' | 'validation' | 'styling' | 'anti-patterns';
+    confidence: number;
+}
+/**
+ * Pattern context for generation
+ */
+export interface PatternContext {
+    detected: DetectedPattern[];
+    preferred: string[];
+    avoid: string[];
+}
 /**
  * Options for API generation
  */
@@ -7,6 +24,7 @@ export interface GenerateApiOptions {
     validation?: boolean;
     tests?: boolean;
     database?: 'postgresql' | 'mysql' | 'mongodb';
+    patterns?: PatternContext;
 }
 /**
  * Options for frontend generation
@@ -16,6 +34,7 @@ export interface GenerateFrontendOptions {
     forms?: boolean;
     tables?: boolean;
     routing?: boolean;
+    patterns?: PatternContext;
 }
 /**
  * Options for component generation
@@ -23,6 +42,7 @@ export interface GenerateFrontendOptions {
 export interface GenerateComponentOptions {
     ui?: 'shadcn' | 'mui' | 'chakra';
     validation?: boolean;
+    patterns?: PatternContext;
 }
 /**
  * Generated code result
@@ -48,10 +68,12 @@ export interface GenerationMetadata {
 export interface GeneratorMetadata {
     id: string;
     name: string;
+    domain?: 'api' | 'frontend' | 'component';
     framework: string;
     description: string;
     features: string[];
     databases?: string[];
+    uiLibraries?: string[];
     version: string;
     templates: string[];
 }