@claudetools/tools 0.3.9 → 0.4.0

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

@@ -0,0 +1,41 @@
+import { EntitySpec } from '../parser.js';
+import { TemplateEngine } from '../template-engine.js';
+import { TemplateRegistry } from '../registry.js';
+import { GenerationResult, GenerationMetadata } from '../types.js';
+export declare abstract class BaseGenerator {
+    protected engine: TemplateEngine;
+    protected registry: TemplateRegistry;
+    constructor(registry: TemplateRegistry);
+    /**
+     * Generate code from entity specification
+     */
+    generate(entity: EntitySpec, options?: any): Promise<GenerationResult>;
+    /**
+     * Get the generator ID (e.g., "express-api")
+     */
+    protected abstract getGeneratorId(): string;
+    /**
+     * Get list of required template files based on options
+     */
+    protected abstract getRequiredTemplates(options: any): string[];
+    /**
+     * Get mapping of output file paths to template files
+     */
+    protected abstract getFileMapping(entity: EntitySpec, options: any): Record<string, string>;
+    /**
+     * Calculate generation metadata
+     */
+    protected calculateMetadata(generatorId: string, framework: string, entity: EntitySpec, files: Record<string, string>): GenerationMetadata;
+    /**
+     * Validate options against generator capabilities
+     */
+    protected validateOptions(options: any): Promise<void>;
+    /**
+     * Helper to get output path for entity file
+     */
+    protected getEntityPath(entity: EntitySpec, directory: string, extension: string): string;
+    /**
+     * Helper to check if option is enabled
+     */
+    protected isEnabled(options: any, key: string, defaultValue?: boolean): boolean;
+}

package/dist/codedna/generators/base.js

@@ -0,0 +1,102 @@
+// =============================================================================
+// Base Generator Class
+// =============================================================================
+//
+// Abstract base class for all code generators with common file generation
+// pipeline, metadata tracking, and utilities.
+//
+import { TemplateEngine, buildContext } from '../template-engine.js';
+export class BaseGenerator {
+    engine;
+    registry;
+    constructor(registry) {
+        this.engine = new TemplateEngine();
+        this.registry = registry;
+    }
+    /**
+     * Generate code from entity specification
+     */
+    async generate(entity, options = {}) {
+        // Get generator metadata
+        const generatorId = this.getGeneratorId();
+        const metadata = await this.registry.getGeneratorMetadata(generatorId);
+        // Get required templates
+        const templateFiles = this.getRequiredTemplates(options);
+        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];
+            if (!template) {
+                throw new Error(`Template not found: ${templateFile}`);
+            }
+            const content = this.engine.render(template, context);
+            files[outputPath] = content;
+        }
+        // Calculate metadata
+        const generationMetadata = this.calculateMetadata(generatorId, metadata.framework, entity, files);
+        return {
+            files,
+            metadata: generationMetadata,
+        };
+    }
+    /**
+     * Calculate generation metadata
+     */
+    calculateMetadata(generatorId, framework, entity, files) {
+        const filesGenerated = Object.keys(files).length;
+        const linesOfCode = Object.values(files).reduce((sum, content) => sum + content.split('\n').length, 0);
+        // Estimate token savings
+        // Average: 1 line of code ≈ 25 tokens
+        // AI would generate all lines from scratch
+        // With CodeDNA: ~150 tokens for the API call
+        const estimatedTokensSaved = Math.max(0, linesOfCode * 25 - 150);
+        return {
+            generator: generatorId,
+            framework,
+            entities: [entity.name],
+            filesGenerated,
+            linesOfCode,
+            estimatedTokensSaved,
+        };
+    }
+    /**
+     * Validate options against generator capabilities
+     */
+    async validateOptions(options) {
+        const generatorId = this.getGeneratorId();
+        const metadata = await this.registry.getGeneratorMetadata(generatorId);
+        // Validate database option
+        if (options.database && metadata.databases) {
+            if (!metadata.databases.includes(options.database)) {
+                throw new Error(`Unsupported database: ${options.database}. Supported: ${metadata.databases.join(', ')}`);
+            }
+        }
+        // Validate features
+        if (options.auth && !metadata.features.includes('auth')) {
+            throw new Error('This generator does not support authentication');
+        }
+        if (options.validation && !metadata.features.includes('validation')) {
+            throw new Error('This generator does not support validation');
+        }
+        if (options.tests && !metadata.features.includes('tests')) {
+            throw new Error('This generator does not support test generation');
+        }
+    }
+    /**
+     * Helper to get output path for entity file
+     */
+    getEntityPath(entity, directory, extension) {
+        const filename = entity.name.toLowerCase();
+        return `${directory}/${filename}.${extension}`;
+    }
+    /**
+     * Helper to check if option is enabled
+     */
+    isEnabled(options, key, defaultValue = false) {
+        return options[key] ?? defaultValue;
+    }
+}

package/dist/codedna/generators/express-api.d.ts

@@ -0,0 +1,12 @@
+import { BaseGenerator } from './base.js';
+import { EntitySpec } from '../parser.js';
+import { GenerateApiOptions } from '../types.js';
+export declare class ExpressApiGenerator extends BaseGenerator {
+    protected getGeneratorId(): string;
+    protected getRequiredTemplates(options: GenerateApiOptions): string[];
+    protected getFileMapping(entity: EntitySpec, options: GenerateApiOptions): Record<string, string>;
+    /**
+     * Generate Express API from entity specification
+     */
+    generate(entity: EntitySpec, options?: GenerateApiOptions): Promise<import('../types.js').GenerationResult>;
+}

package/dist/codedna/generators/express-api.js

@@ -0,0 +1,61 @@
+// =============================================================================
+// Express API Generator
+// =============================================================================
+//
+// Generate TypeScript Express REST API with CRUD operations, models,
+// controllers, routes, middleware, and validators.
+//
+import { BaseGenerator } from './base.js';
+export class ExpressApiGenerator extends BaseGenerator {
+    getGeneratorId() {
+        return 'express-api';
+    }
+    getRequiredTemplates(options) {
+        const templates = [
+            'model.ts.j2',
+            'controller.ts.j2',
+            'route.ts.j2',
+            'validator.ts.j2',
+        ];
+        if (this.isEnabled(options, 'auth')) {
+            templates.push('middleware.ts.j2');
+        }
+        if (this.isEnabled(options, 'tests')) {
+            templates.push('test.ts.j2');
+        }
+        return templates;
+    }
+    getFileMapping(entity, options) {
+        const entityLower = entity.name.toLowerCase();
+        const mapping = {
+            [`src/models/${entityLower}.model.ts`]: 'model.ts.j2',
+            [`src/controllers/${entityLower}.controller.ts`]: 'controller.ts.j2',
+            [`src/routes/${entityLower}.routes.ts`]: 'route.ts.j2',
+            [`src/validators/${entityLower}.validator.ts`]: 'validator.ts.j2',
+        };
+        if (this.isEnabled(options, 'auth')) {
+            mapping['src/middleware/auth.middleware.ts'] = 'middleware.ts.j2';
+        }
+        if (this.isEnabled(options, 'tests')) {
+            mapping[`src/__tests__/${entityLower}.test.ts`] = 'test.ts.j2';
+        }
+        return mapping;
+    }
+    /**
+     * Generate Express API from entity specification
+     */
+    async generate(entity, options = {}) {
+        // Validate options
+        await this.validateOptions(options);
+        // Set defaults
+        const opts = {
+            auth: false,
+            validation: true,
+            tests: false,
+            database: 'postgresql',
+            ...options,
+        };
+        // Generate files
+        return super.generate(entity, opts);
+    }
+}

package/dist/codedna/index.d.ts

@@ -0,0 +1,4 @@
+export * from './parser.js';
+export * from './types.js';
+export * from './template-engine.js';
+export * from './registry.js';

package/dist/codedna/index.js

@@ -0,0 +1,7 @@
+// =============================================================================
+// CodeDNA Module Exports
+// =============================================================================
+export * from './parser.js';
+export * from './types.js';
+export * from './template-engine.js';
+export * from './registry.js';

package/dist/codedna/parser.d.ts

@@ -0,0 +1,80 @@
+export interface EntitySpec {
+    name: string;
+    fields: Field[];
+}
+export interface Field {
+    name: string;
+    type: FieldType;
+    constraints: Constraint[];
+}
+export type FieldType = {
+    kind: 'primitive';
+    value: 'string' | 'integer' | 'decimal' | 'boolean' | 'datetime';
+} | {
+    kind: 'reference';
+    entity: string;
+} | {
+    kind: 'enum';
+    values: string[];
+};
+export type Constraint = {
+    kind: 'unique';
+} | {
+    kind: 'required';
+} | {
+    kind: 'hashed';
+} | {
+    kind: 'index';
+} | {
+    kind: 'min';
+    value: number;
+} | {
+    kind: 'max';
+    value: number;
+} | {
+    kind: 'default';
+    value: string;
+};
+export declare class EntityParser {
+    /**
+     * Parse Entity DSL specification into structured EntitySpec
+     */
+    parse(spec: string): EntitySpec;
+    /**
+     * Parse comma-separated field definitions
+     */
+    private parseFields;
+    /**
+     * Split fields by commas, respecting parentheses nesting
+     */
+    private splitFields;
+    /**
+     * Parse single field definition
+     * Format: name:type:constraint1:constraint2
+     */
+    private parseField;
+    /**
+     * Parse field type (primitive, reference, enum)
+     */
+    private parseType;
+    /**
+     * Parse field constraint (unique, required, hashed, min, max, default)
+     */
+    private parseConstraint;
+}
+/**
+ * Validate Entity DSL specification
+ */
+export declare function validateSpec(spec: string): {
+    valid: boolean;
+    errors?: string[];
+    parsed?: EntitySpec;
+};
+/**
+ * Helper to check if field has specific constraint
+ */
+export declare function hasConstraint(field: Field, kind: Constraint['kind']): boolean;
+/**
+ * Helper to get constraint value
+ */
+export declare function getConstraintValue<T extends Constraint>(field: Field, kind: T['kind']): T | undefined;

package/dist/codedna/parser.js

@@ -0,0 +1,176 @@
+// =============================================================================
+// Entity DSL Parser
+// =============================================================================
+//
+// Parses compact Entity DSL specifications into structured data for code generation.
+//
+// Syntax: EntityName(field:type:constraint, field:type:constraint)
+//
+// Example: User(email:string:unique:required, password:string:hashed, age:integer:min(18))
+//
+export class EntityParser {
+    /**
+     * Parse Entity DSL specification into structured EntitySpec
+     */
+    parse(spec) {
+        // Remove whitespace
+        spec = spec.trim();
+        // Extract entity name
+        const nameMatch = spec.match(/^([A-Z][a-zA-Z0-9]*)\(/);
+        if (!nameMatch) {
+            throw new Error('Invalid entity spec: must start with EntityName(');
+        }
+        const name = nameMatch[1];
+        // Extract fields section
+        const fieldsMatch = spec.match(/\((.+)\)$/);
+        if (!fieldsMatch) {
+            throw new Error('Invalid entity spec: missing closing parenthesis');
+        }
+        const fieldsStr = fieldsMatch[1];
+        const fields = this.parseFields(fieldsStr);
+        return { name, fields };
+    }
+    /**
+     * Parse comma-separated field definitions
+     */
+    parseFields(fieldsStr) {
+        // Split by commas (but not inside parentheses)
+        const fieldStrs = this.splitFields(fieldsStr);
+        return fieldStrs.map(fieldStr => this.parseField(fieldStr.trim()));
+    }
+    /**
+     * Split fields by commas, respecting parentheses nesting
+     */
+    splitFields(str) {
+        const fields = [];
+        let current = '';
+        let depth = 0;
+        for (let i = 0; i < str.length; i++) {
+            const char = str[i];
+            if (char === '(')
+                depth++;
+            if (char === ')')
+                depth--;
+            if (char === ',' && depth === 0) {
+                fields.push(current);
+                current = '';
+            }
+            else {
+                current += char;
+            }
+        }
+        if (current)
+            fields.push(current);
+        return fields;
+    }
+    /**
+     * Parse single field definition
+     * Format: name:type:constraint1:constraint2
+     */
+    parseField(fieldStr) {
+        const parts = fieldStr.split(':');
+        if (parts.length < 2) {
+            throw new Error(`Invalid field spec: ${fieldStr}`);
+        }
+        const name = parts[0].trim();
+        const typeStr = parts[1].trim();
+        const constraintStrs = parts.slice(2).map(s => s.trim());
+        // Validate field name
+        if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) {
+            throw new Error(`Invalid field name: ${name}`);
+        }
+        const type = this.parseType(typeStr);
+        const constraints = constraintStrs.map(c => this.parseConstraint(c));
+        return { name, type, constraints };
+    }
+    /**
+     * Parse field type (primitive, reference, enum)
+     */
+    parseType(typeStr) {
+        // Check for reference: ref(EntityName)
+        const refMatch = typeStr.match(/^ref\(([A-Z][a-zA-Z0-9]*)\)$/);
+        if (refMatch) {
+            return { kind: 'reference', entity: refMatch[1] };
+        }
+        // Check for enum: enum(val1,val2,val3)
+        const enumMatch = typeStr.match(/^enum\((.+)\)$/);
+        if (enumMatch) {
+            const values = enumMatch[1].split(',').map(v => v.trim());
+            if (values.length === 0) {
+                throw new Error('Enum must have at least one value');
+            }
+            return { kind: 'enum', values };
+        }
+        // Primitive types
+        const primitives = ['string', 'integer', 'decimal', 'boolean', 'datetime'];
+        if (primitives.includes(typeStr)) {
+            return { kind: 'primitive', value: typeStr };
+        }
+        throw new Error(`Unknown field type: ${typeStr}`);
+    }
+    /**
+     * Parse field constraint (unique, required, hashed, min, max, default)
+     */
+    parseConstraint(constraintStr) {
+        // Simple constraints
+        if (constraintStr === 'unique')
+            return { kind: 'unique' };
+        if (constraintStr === 'required')
+            return { kind: 'required' };
+        if (constraintStr === 'hashed')
+            return { kind: 'hashed' };
+        if (constraintStr === 'index')
+            return { kind: 'index' };
+        // Parameterized constraints: min(18), max(100), default(true)
+        const paramMatch = constraintStr.match(/^([a-z]+)\((.+)\)$/);
+        if (paramMatch) {
+            const [, kind, value] = paramMatch;
+            if (kind === 'min') {
+                const numValue = Number(value);
+                if (isNaN(numValue)) {
+                    throw new Error(`Invalid min constraint value: ${value}`);
+                }
+                return { kind: 'min', value: numValue };
+            }
+            if (kind === 'max') {
+                const numValue = Number(value);
+                if (isNaN(numValue)) {
+                    throw new Error(`Invalid max constraint value: ${value}`);
+                }
+                return { kind: 'max', value: numValue };
+            }
+            if (kind === 'default') {
+                return { kind: 'default', value };
+            }
+        }
+        throw new Error(`Unknown constraint: ${constraintStr}`);
+    }
+}
+/**
+ * Validate Entity DSL specification
+ */
+export function validateSpec(spec) {
+    try {
+        const parser = new EntityParser();
+        const parsed = parser.parse(spec);
+        return { valid: true, parsed };
+    }
+    catch (error) {
+        return {
+            valid: false,
+            errors: [error instanceof Error ? error.message : String(error)],
+        };
+    }
+}
+/**
+ * Helper to check if field has specific constraint
+ */
+export function hasConstraint(field, kind) {
+    return field.constraints.some(c => c.kind === kind);
+}
+/**
+ * Helper to get constraint value
+ */
+export function getConstraintValue(field, kind) {
+    return field.constraints.find(c => c.kind === kind);
+}

package/dist/codedna/registry.d.ts

@@ -0,0 +1,60 @@
+import { GeneratorMetadata } from './types.js';
+export interface RegistryResponse {
+    generators: GeneratorMetadata[];
+    version: string;
+    updated: string;
+}
+export declare class TemplateRegistry {
+    private baseUrl;
+    private cacheDir;
+    private useCache;
+    constructor(baseUrl?: string, useCache?: boolean);
+    /**
+     * List all available generators
+     */
+    listGenerators(): Promise<GeneratorMetadata[]>;
+    /**
+     * Get metadata for specific generator
+     */
+    getGeneratorMetadata(generatorId: string): Promise<GeneratorMetadata>;
+    /**
+     * Get template file content
+     */
+    getTemplate(generatorId: string, templateFile: string): Promise<string>;
+    /**
+     * Get multiple templates at once
+     */
+    getTemplates(generatorId: string, templateFiles: string[]): Promise<Record<string, string>>;
+    /**
+     * Check if template is cached locally
+     */
+    private getCachedTemplate;
+    /**
+     * Cache template locally
+     */
+    private cacheTemplate;
+    /**
+     * Get local generators (fallback)
+     */
+    private getLocalGenerators;
+    /**
+     * Get local metadata (fallback)
+     */
+    private getLocalMetadata;
+    /**
+     * Get local template (fallback)
+     */
+    private getLocalTemplate;
+    /**
+     * Clear local cache
+     */
+    clearCache(): Promise<void>;
+    /**
+     * Get cache statistics
+     */
+    getCacheStats(): Promise<{
+        cachedGenerators: string[];
+        totalFiles: number;
+        totalSize: number;
+    }>;
+}