@claudetools/tools 0.7.0 → 0.7.2

package/dist/cli.js

@@ -10,6 +10,7 @@ import { dirname, join } from 'node:path';
 import { runSetup, runUninstall, runInit, runCleanup } from './setup.js';
 import { startServer } from './index.js';
 import { startWatcher, stopWatcher, watcherStatus } from './watcher.js';
+import { generateCodebaseMap, generateCodebaseMapLocal } from './helpers/codebase-mapper.js';
 // Get version from package.json
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -53,6 +54,8 @@ Commands:
   watch            Start the file watcher daemon
   watch --stop     Stop the watcher daemon
   watch --status   Check watcher status
+  map              Generate codebase map for current project
+  map --local      Generate map locally without uploading
 
 Running without options starts the MCP server.
 
@@ -103,6 +106,65 @@ else if (positionals[0] === 'watch') {
         });
     }
 }
+else if (positionals[0] === 'map') {
+    // Handle map command
+    const mapArgs = process.argv.slice(3); // Get args after 'map'
+    const isLocal = mapArgs.includes('--local');
+    (async () => {
+        const cwd = process.cwd();
+        if (isLocal) {
+            console.log(`Generating codebase map for: ${cwd}`);
+            const { index, markdown } = generateCodebaseMapLocal(cwd);
+            console.log(`\nGenerated map with ${index.summary.totalFiles} files, ${index.summary.totalSymbols} symbols`);
+            console.log(`\n--- CODEBASE MAP ---\n`);
+            console.log(markdown);
+        }
+        else {
+            // Load config to get API key and project ID
+            const { existsSync: exists, readFileSync: read } = await import('fs');
+            const { join: pathJoin, basename } = await import('path');
+            const { homedir } = await import('os');
+            const configPath = pathJoin(homedir(), '.claudetools', 'config.json');
+            const projectsPath = pathJoin(homedir(), '.claudetools', 'projects.json');
+            if (!exists(configPath)) {
+                console.error('Not configured. Run: claudetools --setup');
+                process.exit(1);
+            }
+            const config = JSON.parse(read(configPath, 'utf-8'));
+            if (!config.apiKey) {
+                console.error('No API key configured. Run: claudetools --setup');
+                process.exit(1);
+            }
+            // Find project ID for current directory
+            let projectId = null;
+            if (exists(projectsPath)) {
+                const projects = JSON.parse(read(projectsPath, 'utf-8'));
+                const binding = projects.bindings?.find((b) => b.local_path === cwd);
+                if (binding) {
+                    projectId = binding.project_id;
+                }
+            }
+            if (!projectId) {
+                console.error('Current directory is not a registered project.');
+                console.error('Run: claudetools init');
+                process.exit(1);
+            }
+            console.log(`Generating codebase map for: ${basename(cwd)} (${projectId})`);
+            const result = await generateCodebaseMap(cwd, projectId, config.apiKey);
+            if (result.success) {
+                console.log('Codebase map generated and uploaded successfully!');
+                console.log(`View at: ${config.apiUrl || 'https://api.claudetools.dev'}/api/v1/codebase/${projectId}/map`);
+            }
+            else {
+                console.error('Failed to generate map:', result.error);
+                process.exit(1);
+            }
+        }
+    })().catch((error) => {
+        console.error('Map generation failed:', error);
+        process.exit(1);
+    });
+}
 else {
     // Start MCP server
     startServer();

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;