@claudetools/tools 0.4.0 → 0.5.1

package/README.md

@@ -67,19 +67,75 @@ CLAUDETOOLS_API_URL=https://api.claudetools.dev
 - **Impact analysis** for changes
 - **Pattern detection** (security, performance)
 
+### CodeDNA (AI Code Generation)
+- **95-99% token savings** by generating production code from compact Entity DSL specs
+- **Production-ready APIs** with models, controllers, routes, validation, tests
+- **Express.js generator** available (FastAPI, NestJS, React coming soon)
+- **Template registry** hosted on ClaudeTools API with global CDN
+
+### 10/10 Prompt Engineering Framework
+- **Production-proven architecture** from Claude 4 analysis (~60K char prompt)
+- **4 complexity tiers** (Minimal/Standard/Professional/Enterprise) with progressive disclosure
+- **7 semantic layers** with XML boundaries for machine-parseability
+- **Token-optimized templates** (500t → 10000t based on complexity)
+- **Compliance verification** with automated validation script
+
+#### Quick Example
+
+```typescript
+// Instead of AI writing 1000 lines of code (30,000 tokens)...
+// Use a compact Entity DSL spec (150 tokens):
+
+codedna_generate_api({
+  spec: "User(email:string:unique, password:string:hashed, age:integer:min(18))",
+  framework: "express",
+  options: {
+    auth: true,
+    validation: true,
+    tests: true,
+    database: "postgresql"
+  }
+})
+
+// Returns 6 complete files:
+// - src/models/user.model.ts
+// - src/controllers/user.controller.ts
+// - src/routes/user.routes.ts
+// - src/validators/user.validator.ts
+// - src/middleware/auth.middleware.ts
+// - tests/user.test.ts
+
+// Token savings: 11,100 tokens (98.7%)
+// Cost savings: $0.11 per generation
+// Time savings: 2-3 minutes → 10 seconds
+```
+
+#### Available Tools
+
+- `codedna_generate_api(spec, framework, options)` - Generate complete REST API
+- `codedna_validate_spec(spec)` - Validate Entity DSL syntax
+- `codedna_list_generators()` - List available code generators
+
+See [CODEDNA_README.md](./CODEDNA_README.md) for full documentation.
+
 ## CLI
 
 ```bash
-claudetools --setup    # Interactive configuration
-claudetools --version  # Show version
-claudetools --help     # Show help
-claudetools            # Start MCP server
+claudetools --setup        # Interactive configuration
+claudetools --version      # Show version
+claudetools --help         # Show help
+claudetools                # Start MCP server
+npm run prompt:verify      # Verify prompt compliance with 10/10 framework
 ```
 
 ## Documentation
 
 - [GitHub](https://github.com/claudetools/memory)
 - [Configuration Guide](./CONFIG.md)
+- [CodeDNA Guide](./CODEDNA_README.md) - AI code generation with 95-99% token savings
+- [10/10 Prompt Framework](./docs/PROMPT_TIER_TEMPLATES.md) - Production-grade prompt engineering
+- [Claude 4 Analysis](./docs/CLAUDE4_PROMPT_ANALYSIS.md) - Insights from ~60K char production prompt
+- [Research Methodology](./docs/RESEARCH_METHODOLOGY_EXTRACTION.md) - Claude.ai Desktop research patterns
 
 ## License
 

package/dist/codedna/parser.d.ts

@@ -1,6 +1,21 @@
 export interface EntitySpec {
     name: string;
     fields: Field[];
+    hooks?: LifecycleHooks;
+    permissions?: Permission[];
+}
+export interface LifecycleHooks {
+    beforeCreate?: string[];
+    afterCreate?: string[];
+    beforeUpdate?: string[];
+    afterUpdate?: string[];
+    beforeDelete?: string[];
+    afterDelete?: string[];
+}
+export interface Permission {
+    action: 'create' | 'read' | 'update' | 'delete';
+    roles?: string[];
+    condition?: string;
 }
 export interface Field {
     name: string;
@@ -9,13 +24,20 @@ export interface Field {
 }
 export type FieldType = {
     kind: 'primitive';
-    value: 'string' | 'integer' | 'decimal' | 'boolean' | 'datetime';
+    value: 'string' | 'integer' | 'decimal' | 'boolean' | 'datetime' | 'email' | 'url' | 'json';
+} | {
+    kind: 'array';
+    itemType: 'string' | 'integer' | 'decimal' | 'boolean';
 } | {
     kind: 'reference';
     entity: string;
+    relation?: 'oneToMany' | 'manyToMany';
 } | {
     kind: 'enum';
     values: string[];
+} | {
+    kind: 'computed';
+    expression: string;
 };
 export type Constraint = {
     kind: 'unique';
@@ -34,6 +56,21 @@ export type Constraint = {
 } | {
     kind: 'default';
     value: string;
+} | {
+    kind: 'length';
+    min?: number;
+    max?: number;
+} | {
+    kind: 'pattern';
+    regex: string;
+} | {
+    kind: 'email';
+} | {
+    kind: 'url';
+} | {
+    kind: 'nullable';
+} | {
+    kind: 'immutable';
 };
 export declare class EntityParser {
     /**
@@ -54,11 +91,11 @@ export declare class EntityParser {
      */
     private parseField;
     /**
-     * Parse field type (primitive, reference, enum)
+     * Parse field type (primitive, reference, enum, array, computed)
      */
     private parseType;
     /**
-     * Parse field constraint (unique, required, hashed, min, max, default)
+     * Parse field constraint (unique, required, hashed, min, max, default, length, pattern, email, url, nullable, immutable)
      */
     private parseConstraint;
 }

package/dist/codedna/parser.js

@@ -22,12 +22,12 @@ export class EntityParser {
         }
         const name = nameMatch[1];
         // Extract fields section
-        const fieldsMatch = spec.match(/\((.+)\)$/);
+        const fieldsMatch = spec.match(/\((.*)\)$/);
         if (!fieldsMatch) {
             throw new Error('Invalid entity spec: missing closing parenthesis');
         }
         const fieldsStr = fieldsMatch[1];
-        const fields = this.parseFields(fieldsStr);
+        const fields = fieldsStr.trim() ? this.parseFields(fieldsStr) : [];
         return { name, fields };
     }
     /**
@@ -84,14 +84,36 @@ export class EntityParser {
         return { name, type, constraints };
     }
     /**
-     * Parse field type (primitive, reference, enum)
+     * Parse field type (primitive, reference, enum, array, computed)
      */
     parseType(typeStr) {
-        // Check for reference: ref(EntityName)
+        // Check for reference with relation: refMany(EntityName) or refOne(EntityName)
+        // oneToMany = entity has many of this type (e.g., User has many Posts)
+        // manyToMany = entities have many-to-many relationship
+        const refManyMatch = typeStr.match(/^refMany\(([A-Z][a-zA-Z0-9]*)\)$/);
+        if (refManyMatch) {
+            return { kind: 'reference', entity: refManyMatch[1], relation: 'manyToMany' };
+        }
+        const refOneMatch = typeStr.match(/^refOne\(([A-Z][a-zA-Z0-9]*)\)$/);
+        if (refOneMatch) {
+            return { kind: 'reference', entity: refOneMatch[1], relation: 'oneToMany' };
+        }
+        // Check for reference: ref(EntityName) - default simple reference
         const refMatch = typeStr.match(/^ref\(([A-Z][a-zA-Z0-9]*)\)$/);
         if (refMatch) {
             return { kind: 'reference', entity: refMatch[1] };
         }
+        // Check for array: array(string), array(integer), etc.
+        const arrayMatch = typeStr.match(/^array\((string|integer|decimal|boolean)\)$/);
+        if (arrayMatch) {
+            const itemType = arrayMatch[1];
+            return { kind: 'array', itemType };
+        }
+        // Check for computed: computed(expression)
+        const computedMatch = typeStr.match(/^computed\((.+)\)$/);
+        if (computedMatch) {
+            return { kind: 'computed', expression: computedMatch[1] };
+        }
         // Check for enum: enum(val1,val2,val3)
         const enumMatch = typeStr.match(/^enum\((.+)\)$/);
         if (enumMatch) {
@@ -101,15 +123,15 @@ export class EntityParser {
             }
             return { kind: 'enum', values };
         }
-        // Primitive types
-        const primitives = ['string', 'integer', 'decimal', 'boolean', 'datetime'];
+        // Primitive types (including new email, url, json)
+        const primitives = ['string', 'integer', 'decimal', 'boolean', 'datetime', 'email', 'url', 'json'];
         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)
+     * Parse field constraint (unique, required, hashed, min, max, default, length, pattern, email, url, nullable, immutable)
      */
     parseConstraint(constraintStr) {
         // Simple constraints
@@ -121,7 +143,15 @@ export class EntityParser {
             return { kind: 'hashed' };
         if (constraintStr === 'index')
             return { kind: 'index' };
-        // Parameterized constraints: min(18), max(100), default(true)
+        if (constraintStr === 'email')
+            return { kind: 'email' };
+        if (constraintStr === 'url')
+            return { kind: 'url' };
+        if (constraintStr === 'nullable')
+            return { kind: 'nullable' };
+        if (constraintStr === 'immutable')
+            return { kind: 'immutable' };
+        // Parameterized constraints: min(18), max(100), default(true), length(10,100), pattern(/regex/)
         const paramMatch = constraintStr.match(/^([a-z]+)\((.+)\)$/);
         if (paramMatch) {
             const [, kind, value] = paramMatch;
@@ -142,6 +172,33 @@ export class EntityParser {
             if (kind === 'default') {
                 return { kind: 'default', value };
             }
+            if (kind === 'length') {
+                // Support both length(max) and length(min,max)
+                const parts = value.split(',').map(v => v.trim());
+                if (parts.length === 1) {
+                    const maxValue = Number(parts[0]);
+                    if (isNaN(maxValue)) {
+                        throw new Error(`Invalid length constraint value: ${parts[0]}`);
+                    }
+                    return { kind: 'length', max: maxValue };
+                }
+                else if (parts.length === 2) {
+                    const minValue = Number(parts[0]);
+                    const maxValue = Number(parts[1]);
+                    if (isNaN(minValue) || isNaN(maxValue)) {
+                        throw new Error(`Invalid length constraint values: ${value}`);
+                    }
+                    return { kind: 'length', min: minValue, max: maxValue };
+                }
+                else {
+                    throw new Error(`Invalid length constraint format: ${value}`);
+                }
+            }
+            if (kind === 'pattern') {
+                // Remove surrounding slashes if present
+                const regex = value.replace(/^\/(.+)\/$/, '$1');
+                return { kind: 'pattern', regex };
+            }
         }
         throw new Error(`Unknown constraint: ${constraintStr}`);
     }

package/dist/codedna/registry.js

@@ -8,12 +8,13 @@
 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));
 export class TemplateRegistry {
     baseUrl;
     cacheDir;
     useCache;
-    constructor(baseUrl = 'https://templates.claudetools.com', useCache = true) {
+    constructor(baseUrl = 'https://api.claudetools.dev/api/v1/codedna', useCache = true) {
         this.baseUrl = baseUrl;
         this.cacheDir = path.join(__dirname, '../../templates');
         this.useCache = useCache;
@@ -82,6 +83,8 @@ export class TemplateRegistry {
         }
         catch (error) {
             console.warn('Failed to fetch template from registry, using local fallback:', error);
+            // Track template fetch error
+            await errorTracker.trackTemplateFetchError(generatorId, templateFile, error instanceof Error ? error : new Error(String(error)));
             return this.getLocalTemplate(generatorId, templateFile);
         }
     }

package/dist/codedna/template-engine.js

@@ -30,6 +30,8 @@ export class TemplateEngine {
     addFilters() {
         // Pluralize: User → Users
         this.env.addFilter('plural', (str) => {
+            if (str === 'person')
+                return 'people';
             if (str.endsWith('y'))
                 return str.slice(0, -1) + 'ies';
             if (str.endsWith('s'))
@@ -44,64 +46,101 @@ export class TemplateEngine {
         this.env.addFilter('upper', (str) => {
             return str.toUpperCase();
         });
-        // camelCase: user_name → userName
+        // camelCase: user_name → userName, first-name → firstName, my value → myValue
         this.env.addFilter('camel', (str) => {
-            return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+            return str
+                .replace(/[-_\s]([a-zA-Z])/g, (_, letter) => letter.toUpperCase())
+                .replace(/^[A-Z]/, letter => letter.toLowerCase());
         });
-        // PascalCase: user_name → UserName
+        // PascalCase: user_name → UserName, first-name → FirstName, my value → MyValue
         this.env.addFilter('pascal', (str) => {
-            const camel = str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+            const camel = str.replace(/[-_\s]([a-zA-Z])/g, (_, letter) => letter.toUpperCase());
             return camel.charAt(0).toUpperCase() + camel.slice(1);
         });
-        // snake_case: userName → user_name
+        // snake_case: userName → user_name, FirstName → first_name
         this.env.addFilter('snake', (str) => {
-            return str.replace(/[A-Z]/g, letter => '_' + letter.toLowerCase());
+            return str
+                .replace(/[A-Z]/g, letter => '_' + letter.toLowerCase())
+                .replace(/^_/, '');
         });
-        // kebab-case: userName → user-name
+        // kebab-case: userName → user-name, FirstName → first-name
         this.env.addFilter('kebab', (str) => {
-            return str.replace(/[A-Z]/g, letter => '-' + letter.toLowerCase());
+            return str
+                .replace(/[A-Z]/g, letter => '-' + letter.toLowerCase())
+                .replace(/^-/, '');
         });
         // 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') {
+        // Get TypeScript type for field type
+        this.env.addFilter('tsType', (type) => {
+            if (type.kind === 'primitive') {
                 const typeMap = {
                     string: 'string',
                     integer: 'number',
                     decimal: 'number',
                     boolean: 'boolean',
                     datetime: 'Date',
+                    email: 'string',
+                    url: 'string',
+                    json: 'any',
                 };
-                return typeMap[field.type.value];
+                return typeMap[type.value] || 'any';
             }
-            if (field.type.kind === 'reference') {
-                return field.type.entity;
+            if (type.kind === 'array') {
+                const itemTypeMap = {
+                    string: 'string',
+                    integer: 'number',
+                    decimal: 'number',
+                    boolean: 'boolean',
+                };
+                return `${itemTypeMap[type.itemType]}[]`;
+            }
+            if (type.kind === 'reference') {
+                return type.entity;
+            }
+            if (type.kind === 'enum') {
+                return type.values.map((v) => `'${v}'`).join(' | ');
             }
-            if (field.type.kind === 'enum') {
-                return field.type.values.map(v => `'${v}'`).join(' | ');
+            if (type.kind === 'computed') {
+                return 'any'; // Computed fields can be any type
             }
             return 'any';
         });
-        // Get SQL type for field
-        this.env.addFilter('sqlType', (field) => {
-            if (field.type.kind === 'primitive') {
+        // Get SQL type for field type
+        this.env.addFilter('sqlType', (type) => {
+            if (type.kind === 'primitive') {
                 const typeMap = {
                     string: 'VARCHAR(255)',
                     integer: 'INTEGER',
                     decimal: 'DECIMAL(10,2)',
                     boolean: 'BOOLEAN',
                     datetime: 'TIMESTAMP',
+                    email: 'VARCHAR(255)',
+                    url: 'VARCHAR(512)',
+                    json: 'JSONB',
                 };
-                return typeMap[field.type.value];
+                return typeMap[type.value] || 'TEXT';
             }
-            if (field.type.kind === 'reference') {
+            if (type.kind === 'array') {
+                // PostgreSQL array syntax
+                const itemTypeMap = {
+                    string: 'TEXT',
+                    integer: 'INTEGER',
+                    decimal: 'DECIMAL(10,2)',
+                    boolean: 'BOOLEAN',
+                };
+                return `${itemTypeMap[type.itemType]}[]`;
+            }
+            if (type.kind === 'reference') {
                 return 'INTEGER'; // Foreign key
             }
-            if (field.type.kind === 'enum') {
-                return `ENUM(${field.type.values.map(v => `'${v}'`).join(',')})`;
+            if (type.kind === 'enum') {
+                return `ENUM(${type.values.map((v) => `'${v}'`).join(',')})`;
+            }
+            if (type.kind === 'computed') {
+                return 'GENERATED'; // Virtual/computed column
             }
             return 'TEXT';
         });
@@ -109,22 +148,17 @@ export class TemplateEngine {
         this.env.addFilter('hasConstraint', (field, constraintKind) => {
             return field.constraints.some(c => c.kind === constraintKind);
         });
-        // Get constraint value (for min, max, default)
+        // Get constraint object (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;
+            return field.constraints.find(c => c.kind === constraintKind) || null;
         });
         // Join array with custom separator
         this.env.addFilter('joinWith', (arr, separator) => {
             return arr.join(separator);
         });
-        // First letter uppercase
+        // First letter uppercase, rest lowercase
         this.env.addFilter('capitalize', (str) => {
-            return str.charAt(0).toUpperCase() + str.slice(1);
+            return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
         });
         // Indent lines
         this.env.addFilter('indent', (str, spaces = 2) => {

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

@@ -104,7 +104,7 @@ export declare function handleValidateSpec(args: any): Promise<{
         fields: {
             name: string;
             type: import("../codedna/parser.js").FieldType;
-            constraints: ("default" | "min" | "max" | "required" | "unique" | "hashed" | "index")[];
+            constraints: ("default" | "length" | "email" | "min" | "max" | "url" | "required" | "pattern" | "nullable" | "unique" | "hashed" | "index" | "immutable")[];
         }[];
     };
     summary: {

package/dist/handlers/codedna-handlers.js

@@ -8,6 +8,8 @@
 import { validateSpec } from '../codedna/parser.js';
 import { TemplateRegistry } from '../codedna/registry.js';
 import { ExpressApiGenerator } from '../codedna/generators/express-api.js';
+import { errorTracker } from '../helpers/error-tracking.js';
+import { analytics } from '../helpers/usage-analytics.js';
 // Singleton registry instance
 const registry = new TemplateRegistry();
 /**
@@ -18,6 +20,8 @@ export async function handleGenerateApi(args) {
     // Validate Entity DSL specification
     const validation = validateSpec(spec);
     if (!validation.valid) {
+        // Track validation error
+        await errorTracker.trackValidationError(spec, validation.errors || []);
         return {
             error: 'Invalid entity specification',
             details: validation.errors,
@@ -47,8 +51,24 @@ export async function handleGenerateApi(args) {
         };
     }
     try {
+        const startTime = Date.now();
         // Generate code
         const result = await generator.generate(validation.parsed, options);
+        const executionTime = Date.now() - startTime;
+        // Track successful generation
+        await analytics.trackGeneration({
+            operation: 'generate_api',
+            generator: `${framework}-api`,
+            framework,
+            entityName: validation.parsed.name,
+            fieldCount: validation.parsed.fields.length,
+            specLength: spec.length,
+            filesGenerated: result.metadata.filesGenerated,
+            linesOfCode: result.metadata.linesOfCode,
+            tokensSaved: result.metadata.estimatedTokensSaved,
+            options: options,
+            executionTimeMs: executionTime,
+        });
         return {
             success: true,
             files: result.files,
@@ -62,6 +82,8 @@ export async function handleGenerateApi(args) {
         };
     }
     catch (error) {
+        // Track generation error
+        await errorTracker.trackGenerationError(framework, spec, error instanceof Error ? error : new Error(String(error)));
         return {
             error: 'Code generation failed',
             message: error instanceof Error ? error.message : String(error),
@@ -129,6 +151,8 @@ export async function handleListGenerators() {
         };
     }
     catch (error) {
+        // Track network error for registry access
+        await errorTracker.trackNetworkError('list_generators', error instanceof Error ? error : new Error(String(error)));
         return {
             error: 'Failed to list generators',
             message: error instanceof Error ? error.message : String(error),
@@ -141,7 +165,9 @@ export async function handleListGenerators() {
 export async function handleValidateSpec(args) {
     const { spec } = args;
     const validation = validateSpec(spec);
+    // Track validation
     if (validation.valid && validation.parsed) {
+        await analytics.trackValidation(spec, true, validation.parsed.name, validation.parsed.fields.length);
         return {
             valid: true,
             entity: {
@@ -160,6 +186,7 @@ export async function handleValidateSpec(args) {
             },
         };
     }
+    await analytics.trackValidation(spec, false);
     return {
         valid: false,
         errors: validation.errors,

package/dist/helpers/api-client.js

@@ -2,12 +2,19 @@
 // API Client and Memory Operations
 // =============================================================================
 import { API_BASE_URL, DEFAULT_USER_ID } from './config.js';
+import { getConfig } from './config-manager.js';
 export async function apiRequest(endpoint, method = 'GET', body) {
+    const config = getConfig();
+    const apiKey = config.apiKey || process.env.CLAUDETOOLS_API_KEY || process.env.MEMORY_API_KEY;
+    if (!apiKey) {
+        throw new Error('No API key found. Set CLAUDETOOLS_API_KEY or MEMORY_API_KEY in environment or ~/.claudetools/config.json');
+    }
     const url = `${API_BASE_URL}${endpoint}`;
     const options = {
         method,
         headers: {
             'Content-Type': 'application/json',
+            'Authorization': `Bearer ${apiKey}`,
         },
     };
     if (body) {

package/dist/helpers/codedna-monitoring.d.ts

@@ -0,0 +1,34 @@
+import { type ErrorRateResult } from './error-tracking.js';
+export interface DashboardMetrics {
+    timeRange: string;
+    errorMetrics: ErrorRateResult;
+    alerts: Alert[];
+    recommendations: string[];
+}
+export interface Alert {
+    level: 'info' | 'warning' | 'critical';
+    message: string;
+    metric: string;
+    value: number;
+    threshold: number;
+}
+/**
+ * Get dashboard metrics for a time range
+ */
+export declare function getDashboardMetrics(startTime: string, endTime: string): Promise<DashboardMetrics>;
+/**
+ * Get error metrics for last 24 hours
+ */
+export declare function getLast24Hours(): Promise<DashboardMetrics>;
+/**
+ * Get error metrics for last 7 days
+ */
+export declare function getLast7Days(): Promise<DashboardMetrics>;
+/**
+ * Print dashboard to console
+ */
+export declare function printDashboard(metrics: DashboardMetrics): void;
+/**
+ * CLI command: npm run codedna:monitor
+ */
+export declare function runMonitoring(): Promise<void>;