@claudetools/tools 0.7.0 → 0.7.1

package/dist/codedna/generators/base.d.ts

@@ -1,7 +1,7 @@
 import { EntitySpec } from '../parser.js';
 import { TemplateEngine } from '../template-engine.js';
 import { TemplateRegistry } from '../registry.js';
-import { GenerationResult, GenerationMetadata } from '../types.js';
+import { GenerationResult, GenerationMetadata, PatternContext } from '../types.js';
 export declare abstract class BaseGenerator {
     protected engine: TemplateEngine;
     protected registry: TemplateRegistry;
@@ -10,6 +10,15 @@ export declare abstract class BaseGenerator {
      * Generate code from entity specification
      */
     generate(entity: EntitySpec, options?: any): Promise<GenerationResult>;
+    /**
+     * Resolve template variants based on detected patterns
+     * For each base template, check if a pattern-specific variant exists
+     */
+    protected resolveTemplateVariants(generatorId: string, baseTemplates: string[], patterns?: PatternContext): Promise<string[]>;
+    /**
+     * Build a map from base template names to resolved variants
+     */
+    private buildTemplateMap;
     /**
      * Get the generator ID (e.g., "express-api")
      */
@@ -25,7 +34,7 @@ export declare abstract class BaseGenerator {
     /**
      * Calculate generation metadata
      */
-    protected calculateMetadata(generatorId: string, framework: string, entity: EntitySpec, files: Record<string, string>): GenerationMetadata;
+    protected calculateMetadata(generatorId: string, framework: string, entity: EntitySpec, files: Record<string, string>, patterns?: PatternContext): GenerationMetadata;
     /**
      * Validate options against generator capabilities
      */

package/dist/codedna/generators/base.js

@@ -5,7 +5,34 @@
 // Abstract base class for all code generators with common file generation
 // pipeline, metadata tracking, and utilities.
 //
+// Pattern-Aware Template Selection:
+// Templates can have variants based on detected patterns. For example:
+//   - validator.ts.j2        (default)
+//   - validator.zod.ts.j2    (if Zod is detected)
+//   - validator.yup.ts.j2    (if Yup is detected)
+//
+// The generator automatically selects the best variant based on detected patterns.
+//
 import { TemplateEngine, buildContext } from '../template-engine.js';
+/**
+ * Template variant mapping: pattern_id -> template suffix
+ */
+const PATTERN_TEMPLATE_VARIANTS = {
+    'zod-validation': '.zod',
+    'yup-validation': '.yup',
+    'react-hook-form': '.rhf',
+    'formik': '.formik',
+    'tanstack-query': '.tanstack',
+    'swr-pattern': '.swr',
+    'zustand': '.zustand',
+    'redux-toolkit': '.redux',
+    'tailwind': '.tailwind',
+    'shadcn-ui': '.shadcn',
+    'mui-patterns': '.mui',
+    'chakra-patterns': '.chakra',
+    'compound-components': '.compound',
+    'headless-components': '.headless',
+};
 export class BaseGenerator {
     engine;
     registry;
@@ -20,33 +47,84 @@ export class BaseGenerator {
         // Get generator metadata
         const generatorId = this.getGeneratorId();
         const metadata = await this.registry.getGeneratorMetadata(generatorId);
-        // Get required templates
-        const templateFiles = this.getRequiredTemplates(options);
+        // Get required templates (with pattern-aware variant selection)
+        const baseTemplates = this.getRequiredTemplates(options);
+        const templateFiles = await this.resolveTemplateVariants(generatorId, baseTemplates, options.patterns);
         const templates = await this.registry.getTemplates(generatorId, templateFiles);
         // Build template context
         const context = buildContext(entity, options);
         // Generate files
         const files = {};
         const fileMapping = this.getFileMapping(entity, options);
-        for (const [outputPath, templateFile] of Object.entries(fileMapping)) {
-            const template = templates[templateFile];
+        // Map base template names to resolved variants
+        const templateMap = this.buildTemplateMap(baseTemplates, templateFiles);
+        for (const [outputPath, baseTemplate] of Object.entries(fileMapping)) {
+            const resolvedTemplate = templateMap[baseTemplate] || baseTemplate;
+            const template = templates[resolvedTemplate];
             if (!template) {
-                throw new Error(`Template not found: ${templateFile}`);
+                throw new Error(`Template not found: ${resolvedTemplate}`);
             }
             const content = this.engine.render(template, context);
             files[outputPath] = content;
         }
         // Calculate metadata
-        const generationMetadata = this.calculateMetadata(generatorId, metadata.framework, entity, files);
+        const generationMetadata = this.calculateMetadata(generatorId, metadata.framework, entity, files, options.patterns);
         return {
             files,
             metadata: generationMetadata,
         };
     }
+    /**
+     * Resolve template variants based on detected patterns
+     * For each base template, check if a pattern-specific variant exists
+     */
+    async resolveTemplateVariants(generatorId, baseTemplates, patterns) {
+        if (!patterns?.detected?.length) {
+            return baseTemplates; // No patterns detected, use defaults
+        }
+        const resolvedTemplates = [];
+        for (const baseTemplate of baseTemplates) {
+            // Try to find a matching variant for each detected pattern
+            let resolved = baseTemplate;
+            // Sort patterns by confidence (highest first)
+            const sortedPatterns = [...patterns.detected].sort((a, b) => b.confidence - a.confidence);
+            for (const pattern of sortedPatterns) {
+                const suffix = PATTERN_TEMPLATE_VARIANTS[pattern.pattern_id];
+                if (!suffix)
+                    continue;
+                // Build variant name: validator.ts.j2 -> validator.zod.ts.j2
+                const parts = baseTemplate.split('.');
+                if (parts.length >= 2) {
+                    const variantName = `${parts[0]}${suffix}.${parts.slice(1).join('.')}`;
+                    // Check if variant exists (try to fetch, cache result)
+                    try {
+                        await this.registry.getTemplate(generatorId, variantName);
+                        resolved = variantName;
+                        break; // Use first matching variant
+                    }
+                    catch {
+                        // Variant doesn't exist, continue checking
+                    }
+                }
+            }
+            resolvedTemplates.push(resolved);
+        }
+        return resolvedTemplates;
+    }
+    /**
+     * Build a map from base template names to resolved variants
+     */
+    buildTemplateMap(baseTemplates, resolvedTemplates) {
+        const map = {};
+        for (let i = 0; i < baseTemplates.length; i++) {
+            map[baseTemplates[i]] = resolvedTemplates[i];
+        }
+        return map;
+    }
     /**
      * Calculate generation metadata
      */
-    calculateMetadata(generatorId, framework, entity, files) {
+    calculateMetadata(generatorId, framework, entity, files, patterns) {
         const filesGenerated = Object.keys(files).length;
         const linesOfCode = Object.values(files).reduce((sum, content) => sum + content.split('\n').length, 0);
         // Estimate token savings
@@ -54,7 +132,7 @@ export class BaseGenerator {
         // AI would generate all lines from scratch
         // With CodeDNA: ~150 tokens for the API call
         const estimatedTokensSaved = Math.max(0, linesOfCode * 25 - 150);
-        return {
+        const metadata = {
             generator: generatorId,
             framework,
             entities: [entity.name],
@@ -62,6 +140,11 @@ export class BaseGenerator {
             linesOfCode,
             estimatedTokensSaved,
         };
+        // Add pattern information to metadata if patterns were used
+        if (patterns?.detected?.length) {
+            metadata.patternsApplied = patterns.detected.map(p => p.pattern_id);
+        }
+        return metadata;
     }
     /**
      * Validate options against generator capabilities

package/dist/codedna/generators/react-frontend.js

@@ -2,7 +2,8 @@
 // React Frontend Generator
 // =============================================================================
 //
-// Generate React components with ShadcnUI for forms, tables, and CRUD views.
+// Generate React components for forms, tables, and CRUD views.
+// Supports multiple UI libraries: shadcn, mui, chakra (default: shadcn)
 //
 import { BaseGenerator } from './base.js';
 export class ReactFrontendGenerator extends BaseGenerator {

package/dist/codedna/parser.d.ts

@@ -71,6 +71,12 @@ export type Constraint = {
     kind: 'nullable';
 } | {
     kind: 'immutable';
+} | {
+    kind: 'textarea';
+} | {
+    kind: 'switch';
+} | {
+    kind: 'radio';
 };
 export declare class EntityParser {
     /**

package/dist/codedna/parser.js

@@ -151,6 +151,13 @@ export class EntityParser {
             return { kind: 'nullable' };
         if (constraintStr === 'immutable')
             return { kind: 'immutable' };
+        // UI hints
+        if (constraintStr === 'textarea')
+            return { kind: 'textarea' };
+        if (constraintStr === 'switch')
+            return { kind: 'switch' };
+        if (constraintStr === 'radio')
+            return { kind: 'radio' };
         // Parameterized constraints: min(18), max(100), default(true), length(10,100), pattern(/regex/)
         const paramMatch = constraintStr.match(/^([a-z]+)\((.+)\)$/);
         if (paramMatch) {

package/dist/codedna/registry.d.ts

@@ -1,18 +1,30 @@
 import { GeneratorMetadata } from './types.js';
 export interface RegistryResponse {
-    generators: GeneratorMetadata[];
-    version: string;
-    updated: string;
+    success: boolean;
+    data: {
+        generators: GeneratorMetadata[];
+        byDomain: Record<string, GeneratorMetadata[]>;
+        summary: {
+            total: number;
+            api: number;
+            frontend: number;
+            component: number;
+        };
+        version: string;
+    };
 }
 export declare class TemplateRegistry {
     private baseUrl;
     private cacheDir;
     private useCache;
+    private registryCache;
     constructor(baseUrl?: string, useCache?: boolean);
     /**
      * List all available generators
+     * Fetches from Cloudflare D1 (single source of truth)
+     * @param domain Optional domain filter: 'api' | 'frontend' | 'component'
      */
-    listGenerators(): Promise<GeneratorMetadata[]>;
+    listGenerators(domain?: 'api' | 'frontend' | 'component'): Promise<GeneratorMetadata[]>;
     /**
      * Get metadata for specific generator
      */
@@ -22,37 +34,31 @@ export declare class TemplateRegistry {
      */
     getTemplate(generatorId: string, templateFile: string): Promise<string>;
     /**
-     * Get multiple templates at once
+     * Get multiple templates at once (parallel fetch)
      */
     getTemplates(generatorId: string, templateFiles: string[]): Promise<Record<string, string>>;
     /**
-     * Check if template is cached locally
+     * Get cached template from file system
      */
     private getCachedTemplate;
     /**
-     * Cache template locally
+     * Cache template to file system
      */
     private cacheTemplate;
     /**
-     * Get local generators (fallback)
-     */
-    private getLocalGenerators;
-    /**
-     * Get local metadata (fallback)
-     */
-    private getLocalMetadata;
-    /**
-     * Get local template (fallback)
+     * Get template from bundled local files (fallback)
      */
     private getLocalTemplate;
     /**
-     * Clear local cache
+     * Clear local template cache
      */
     clearCache(): Promise<void>;
     /**
      * Get cache statistics
      */
     getCacheStats(): Promise<{
+        registryCached: boolean;
+        registryAge: number | null;
         cachedGenerators: string[];
         totalFiles: number;
         totalSize: number;