@claudetools/tools 0.9.0 → 0.9.2

package/dist/templates/worker-prompt.js

@@ -1,22 +1,22 @@
 // =============================================================================
-// Worker Prompt Template with CodeDNA Integration
+// Worker Prompt Template
 // =============================================================================
 //
 // Standard tier (~2000 tokens) prompt template for worker agents.
-// Instructs workers to use CodeDNA generators and tools before writing code.
+// Instructs workers to use codegen and tools before writing code.
 //
 // Based on 10/10 AI System Prompt Architecture Framework
 //
 /**
- * Build worker system prompt with CodeDNA integration
+ * Build worker system prompt
  *
  * Workers:
  * - Execute specific implementation tasks
- * - Use CodeDNA generators for boilerplate code
+ * - Use codegen for boilerplate code
  * - Use tools (memory, codebase) before writing from scratch
  * - Report completion with detailed summaries
  */
-export function buildWorkerPromptWithCodeDNA(params) {
+export function buildWorkerPrompt(params) {
     const { task, worker, epicContext, attachedContext = [], siblingTasks = [], tier = 'standard' } = params;
     // Build sections based on tier
     const sections = [];
@@ -67,9 +67,9 @@ function buildIdentitySection(worker) {
 function buildBehavioralSection(taskId) {
     return `<!-- Layer 2: Behavioral Guidelines -->
 <behavioral_guidelines>
-  <behavior id="codedna_first" priority="MANDATORY">
-    BEFORE writing code: codedna_list_generators() → check if task matches generator
-    Entity DSL: "User(email:string:unique, password:string:hashed)"
+  <behavior id="codegen_first" priority="MANDATORY">
+    BEFORE writing boilerplate: codegen({ describe: "..." }) → generates schema, types, validators, routes
+    Natural language: "User with email, password, role (admin/user)"
     Only write manually for: complex logic, modifications, custom business rules
   </behavior>
 
@@ -109,12 +109,12 @@ function buildStandardsSection() {
 function buildDomainSection(worker) {
     return `<!-- Layer 4: Domain Knowledge -->
 <domain_knowledge>
-  <codedna_capabilities>
-    Discovery: codedna_list_generators() → detect framework → validate spec → generate
-    DSL: EntityName(field:type:constraint, ...)
-    Types: string, integer, decimal, boolean, datetime, ref(Entity), enum(a|b)
-    Constraints: unique, required, min(n), max(n), hashed, default(v), textarea, switch
-  </codedna_capabilities>
+  <codegen>
+    Usage: codegen({ describe: "User with email, password, role (admin/user)" })
+    Generates: Drizzle schema, TypeScript types, Zod validators, API routes
+    Smart inference: email→email type, password→hashed, createdAt→timestamp, price→decimal
+    Stack auto-detected from package.json (Drizzle, Hono, Express, etc.)
+  </codegen>
 
   <worker_expertise>
     ${worker.promptTemplate}
@@ -126,7 +126,7 @@ function buildCrossCuttingSection() {
 <cross_cutting_concerns>
   <error_handling>Validate boundaries. Fail fast. Clear messages. Actionable guidance.</error_handling>
   <security>OWASP Top 10. No exposed secrets. Sanitize inputs. Parameterized queries. Least privilege.</security>
-  <performance>No premature optimization. Token efficiency. CodeDNA for boilerplate.</performance>
+  <performance>No premature optimization. Token efficiency. codegen for boilerplate.</performance>
 </cross_cutting_concerns>`;
 }
 function buildTaskSection(task, epicContext) {
@@ -178,7 +178,7 @@ function buildProtocolSection(taskId) {
     return `<!-- Protocol -->
 <protocol>
   <step number="1">task_start(task_id="${taskId}")</step>
-  <step number="2">Check CodeDNA for entities/APIs, else use tools (memory_search, codebase_find)</step>
+  <step number="2">Check codegen for entities/APIs, else use tools (memory_search, codebase_find)</step>
   <step number="3">Implement requirements. Minimal changes.</step>
   <step number="4">task_complete(task_id="${taskId}", summary="impl, files, decisions, testing")</step>
 
@@ -195,11 +195,11 @@ function buildProtocolSection(taskId) {
  * Build a minimal prompt for simple tasks
  */
 export function buildMinimalWorkerPrompt(params) {
-    return buildWorkerPromptWithCodeDNA({ ...params, tier: 'minimal' });
+    return buildWorkerPrompt({ ...params, tier: 'minimal' });
 }
 /**
  * Build a professional prompt for complex tasks
  */
 export function buildProfessionalWorkerPrompt(params) {
-    return buildWorkerPromptWithCodeDNA({ ...params, tier: 'professional' });
+    return buildWorkerPrompt({ ...params, tier: 'professional' });
 }

package/dist/tools.js

@@ -533,7 +533,14 @@ High hit rate memories (frequently fetched after being indexed) are good candida
             },
             {
                 name: 'task_complete',
-                description: 'PROACTIVE: When finished with a task, mark it complete with a summary of work done. Use this after completing any task.',
+                description: `PROACTIVE: When finished with a task, mark it complete with a summary of work done.
+
+IMPORTANT: For code changes, include verification evidence:
+- tests_passed: Did you run tests? What was the result?
+- type_check_passed: Did TypeScript compile without errors?
+- manually_verified: Did you verify the change works as expected?
+
+Tasks without verification may need follow-up. Be honest about what was tested.`,
                 inputSchema: {
                     type: 'object',
                     properties: {
@@ -549,6 +556,28 @@ High hit rate memories (frequently fetched after being indexed) are good candida
                             type: 'string',
                             description: 'Your agent identifier (default: claude-code)',
                         },
+                        verification: {
+                            type: 'object',
+                            description: 'Verification evidence for code changes (recommended)',
+                            properties: {
+                                tests_passed: {
+                                    type: 'boolean',
+                                    description: 'Were tests run and did they pass?',
+                                },
+                                type_check_passed: {
+                                    type: 'boolean',
+                                    description: 'Did TypeScript type checking pass?',
+                                },
+                                manually_verified: {
+                                    type: 'boolean',
+                                    description: 'Was the change manually verified to work?',
+                                },
+                                evidence: {
+                                    type: 'string',
+                                    description: 'Brief description of verification performed (e.g., "npm test passed", "tested in browser")',
+                                },
+                            },
+                        },
                     },
                     required: ['task_id', 'summary'],
                 },
@@ -1145,446 +1174,81 @@ Explicit lock_duration_minutes parameter overrides the effort-based default.`,
                 },
             },
             // =========================================================================
-            // CODEDNA CODE GENERATION TOOLS
+            // CODEGEN TOOL (Cloud-Only)
             // =========================================================================
             {
-                name: 'codedna_generate_api',
-                description: 'Generate a complete REST API with CRUD operations from an Entity DSL specification. Saves 95-99% tokens vs writing code manually. Example: codedna_generate_api("User(email:string:unique, password:string:hashed)", "express", { auth: true })',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        spec: {
-                            type: 'string',
-                            description: 'Entity DSL specification (e.g., "User(email:string:unique:required, password:string:hashed, age:integer:min(18))")',
-                        },
-                        framework: {
-                            type: 'string',
-                            enum: ['express', 'fastapi', 'nestjs'],
-                            description: 'API framework to use',
-                        },
-                        options: {
-                            type: 'object',
-                            properties: {
-                                auth: {
-                                    type: 'boolean',
-                                    description: 'Include JWT authentication middleware',
-                                },
-                                validation: {
-                                    type: 'boolean',
-                                    description: 'Add input validation',
-                                },
-                                tests: {
-                                    type: 'boolean',
-                                    description: 'Generate test files',
-                                },
-                                database: {
-                                    type: 'string',
-                                    enum: ['postgresql', 'mysql', 'mongodb'],
-                                    description: 'Target database',
-                                },
-                            },
-                        },
-                        package_json: {
-                            type: 'object',
-                            description: 'Optional: package.json content for pattern detection. If provided, generator will detect patterns (zod, yup, etc.) and use matching template variants.',
-                        },
-                    },
-                    required: ['spec', 'framework'],
-                },
-            },
-            {
-                name: 'codedna_generate_frontend',
-                description: 'Generate frontend application with forms and tables from Entity DSL. Saves 95-99% tokens vs writing components manually.',
+                name: 'codegen',
+                description: `Generate code from natural language descriptions. Describe entities and the system generates schema, types, validators, and API routes.
+
+EXAMPLES:
+- "User with email, password, role (admin/user)"
+- "Post with title, content, published, belongs to User as author"
+- "Product with name, price, stock, category (electronics/clothing/food)"
+
+HOW IT WORKS:
+1. Describe entities in natural language
+2. Field types are inferred automatically:
+   - email → email type with unique constraint
+   - password → string with hashing
+   - createdAt → timestamp with auto
+   - id → uuid primary key (auto-added)
+   - role (admin/user) → enum
+3. Stack is auto-detected from package.json
+
+OUTPUTS (configurable):
+- Drizzle schema
+- TypeScript types
+- Zod validators
+- API routes (Hono/Express)
+- React components
+- Forms and pages
+- Tests`,
                 inputSchema: {
                     type: 'object',
                     properties: {
-                        spec: {
+                        describe: {
                             type: 'string',
-                            description: 'Entity DSL specification',
+                            description: 'Natural language description. Example: "User with email, password, role (admin/user)"',
                         },
-                        framework: {
-                            type: 'string',
-                            enum: ['nextjs', 'react', 'vue'],
-                            description: 'Frontend framework to use',
-                        },
-                        options: {
+                        stack: {
                             type: 'object',
+                            description: 'Override auto-detected stack',
                             properties: {
-                                ui: {
-                                    type: 'string',
-                                    enum: ['shadcn', 'mui', 'chakra'],
-                                    description: 'UI component library',
-                                },
-                                forms: {
-                                    type: 'boolean',
-                                    description: 'Generate forms',
-                                },
-                                tables: {
-                                    type: 'boolean',
-                                    description: 'Generate data tables',
-                                },
-                                routing: {
-                                    type: 'boolean',
-                                    description: 'Setup routing',
-                                },
+                                orm: { type: 'string', enum: ['drizzle', 'prisma', 'typeorm', 'mongoose'] },
+                                api: { type: 'string', enum: ['hono', 'express', 'trpc', 'gofiber', 'laravel'] },
+                                db: { type: 'string', enum: ['sqlite', 'postgres', 'mysql', 'mongodb'] },
+                                framework: { type: 'string', enum: ['tanstack-start', 'nextjs'] },
+                                ui: { type: 'string', enum: ['radix', 'shadcn', 'mantine'] },
                             },
                         },
-                        package_json: {
-                            type: 'object',
-                            description: 'Optional: package.json content for pattern detection. Detects React Hook Form, Zod, TanStack Query, etc. and uses matching template variants.',
-                        },
-                    },
-                    required: ['spec', 'framework'],
-                },
-            },
-            {
-                name: 'codedna_generate_component',
-                description: 'Generate single UI component (form, table, card, modal) from Entity DSL.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        spec: {
-                            type: 'string',
-                            description: 'Entity DSL specification or component spec',
-                        },
-                        type: {
-                            type: 'string',
-                            enum: ['form', 'table', 'card', 'modal'],
-                            description: 'Component type to generate',
-                        },
-                        framework: {
-                            type: 'string',
-                            enum: ['react', 'vue', 'svelte'],
-                            description: 'Frontend framework',
-                        },
-                        options: {
-                            type: 'object',
-                            properties: {
-                                ui: {
-                                    type: 'string',
-                                    enum: ['shadcn', 'mui', 'chakra'],
-                                    description: 'UI library',
-                                },
-                                validation: {
-                                    type: 'boolean',
-                                    description: 'Include validation',
-                                },
+                        generate: {
+                            type: 'array',
+                            items: {
+                                type: 'string',
+                                enum: ['schema', 'types', 'validators', 'api', 'components', 'forms', 'pages', 'tests', 'all'],
                             },
-                        },
-                        package_json: {
-                            type: 'object',
-                            description: 'Optional: package.json content for pattern detection. Detects form libraries, validation tools, etc. and uses matching template variants.',
-                        },
-                    },
-                    required: ['spec', 'type', 'framework'],
-                },
-            },
-            {
-                name: 'codedna_list_generators',
-                description: 'CALL THIS BEFORE writing any API, CRUD, or UI component code. Lists available code generators that save 95-99% tokens vs manual coding. Returns generators grouped by domain (api/frontend/component) with their capabilities. If a generator exists for your task, use codedna_generate_* instead of writing code manually.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        domain: {
-                            type: 'string',
-                            enum: ['api', 'frontend', 'component'],
-                            description: 'Filter by domain: "api" for backend APIs, "frontend" for full frontend apps, "component" for individual UI components',
+                            description: 'What to generate (default: schema, types, validators)',
                         },
                     },
+                    required: ['describe'],
                 },
             },
             {
-                name: 'codedna_validate_spec',
-                description: 'Validate Entity DSL syntax without generating code. Returns parsed structure or errors.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        spec: {
-                            type: 'string',
-                            description: 'Entity DSL specification to validate',
-                        },
-                    },
-                    required: ['spec'],
-                },
-            },
-            // =========================================================================
-            // CodeDNA Pattern Library Tools
-            // =========================================================================
-            {
-                name: 'codedna_list_patterns',
-                description: 'List coding patterns from the library. Returns best practices (compound components, TanStack Query, Zod) and anti-patterns to avoid (prop drilling, useEffect fetch). Use to understand what patterns are available for a project.',
+                name: 'codegen_list',
+                description: 'List available generators. Shows all published generators with quality scores and usage counts.',
                 inputSchema: {
                     type: 'object',
                     properties: {
                         category: {
                             type: 'string',
-                            enum: ['components', 'hooks', 'forms', 'state', 'validation', 'styling', 'anti-patterns'],
+                            enum: ['schema', 'types', 'api', 'components', 'forms', 'pages', 'tests', 'auth', 'infra'],
                             description: 'Filter by category',
                         },
-                        recommended_only: {
-                            type: 'boolean',
-                            description: 'Only return recommended best-practice patterns',
-                        },
-                        include_anti_patterns: {
-                            type: 'boolean',
-                            description: 'Include anti-patterns in results (default: true)',
-                        },
-                    },
-                },
-            },
-            {
-                name: 'codedna_get_pattern',
-                description: 'Get detailed documentation for a specific pattern including code examples, when to use/avoid, and migration guides. Use after codedna_list_patterns to get full details.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        pattern_id: {
-                            type: 'string',
-                            description: 'Pattern ID (e.g., "compound-components", "tanstack-query", "prop-drilling")',
-                        },
-                    },
-                    required: ['pattern_id'],
-                },
-            },
-            {
-                name: 'codedna_detect_patterns',
-                description: 'Detect which patterns are used in an existing codebase. Analyzes package.json dependencies and code samples to identify patterns and anti-patterns. Use before making changes to understand project conventions.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        package_json: {
-                            type: 'object',
-                            description: 'The project package.json object (with dependencies/devDependencies)',
-                        },
-                        code_samples: {
-                            type: 'array',
-                            items: { type: 'string' },
-                            description: 'Code snippets to analyze for pattern signals',
-                        },
-                    },
-                },
-            },
-            {
-                name: 'codedna_init_project',
-                description: 'Initialize a project with recommended patterns. For NEW projects, applies best-practice defaults. For EXISTING projects, use with auto_detect to match existing conventions.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        project_id: {
-                            type: 'string',
-                            description: 'Project ID from claudetools',
-                        },
-                        patterns: {
-                            type: 'array',
-                            items: { type: 'string' },
-                            description: 'Specific pattern IDs to apply (optional - uses recommended if not specified)',
-                        },
-                        project_type: {
-                            type: 'string',
-                            enum: ['new', 'existing'],
-                            description: '"new" for greenfield (uses recommended), "existing" for updating (detects patterns)',
-                        },
-                    },
-                    required: ['project_id'],
-                },
-            },
-            // =========================================================================
-            // Kappa v2.5 DSL Tools
-            // =========================================================================
-            // Kappa is a declarative specification language for full-stack applications.
-            // It generates production-ready code from compact specifications, saving 95-99% tokens.
-            {
-                name: 'kappa_parse',
-                description: 'Parse and validate a Kappa v2.5 specification. Returns the AST and validation results. Use this to check syntax before generating code.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        spec: {
-                            type: 'string',
-                            description: 'Kappa specification to parse (e.g., "project MyApp { stack: tanstack-start } entity User { id: uuid, primary }")',
-                        },
-                    },
-                    required: ['spec'],
-                },
-            },
-            {
-                name: 'kappa_generate_schema',
-                description: 'Generate database schema (Drizzle), Zod validators, and TypeScript types from Kappa entity definitions. Saves 95%+ tokens vs writing manually.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        spec: {
-                            type: 'string',
-                            description: 'Kappa specification with entity blocks',
-                        },
-                        outputs: {
-                            type: 'array',
-                            items: { type: 'string', enum: ['drizzle', 'zod', 'types'] },
-                            description: 'What to generate (default: all three)',
-                        },
-                        options: {
-                            type: 'object',
-                            properties: {
-                                provenance: { type: 'boolean', description: 'Add generation comments (default: true)' },
-                                dbDialect: { type: 'string', enum: ['sqlite', 'postgres', 'mysql'], description: 'Database dialect (default: sqlite)' },
-                            },
-                        },
-                    },
-                    required: ['spec'],
-                },
-            },
-            {
-                name: 'kappa_generate_api',
-                description: 'Generate API routes from Kappa API blocks. Supports Hono, Express, and Fastify frameworks.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        spec: {
-                            type: 'string',
-                            description: 'Kappa specification with API blocks',
-                        },
-                        framework: {
-                            type: 'string',
-                            enum: ['hono', 'express', 'trpc'],
-                            description: 'API framework (default: hono)',
-                        },
-                        options: {
-                            type: 'object',
-                            properties: {
-                                provenance: { type: 'boolean' },
-                                typescript: { type: 'boolean' },
-                            },
-                        },
-                    },
-                    required: ['spec'],
-                },
-            },
-            {
-                name: 'kappa_generate_pages',
-                description: 'Generate page/route components from Kappa page blocks. Supports TanStack Start and Next.js App Router with loaders, guards, and layouts.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        spec: {
-                            type: 'string',
-                            description: 'Kappa specification with page blocks',
-                        },
                         framework: {
                             type: 'string',
-                            enum: ['tanstack-start', 'nextjs'],
-                            description: 'Page framework (default: tanstack-start)',
-                        },
-                        options: {
-                            type: 'object',
-                            properties: {
-                                provenance: { type: 'boolean' },
-                                typescript: { type: 'boolean' },
-                            },
-                        },
-                    },
-                    required: ['spec'],
-                },
-            },
-            {
-                name: 'kappa_generate_forms',
-                description: 'Generate React forms with React Hook Form and Zod validation from Kappa form blocks. Supports shadcn/ui components.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        spec: {
-                            type: 'string',
-                            description: 'Kappa specification with form blocks',
-                        },
-                        ui: {
-                            type: 'string',
-                            enum: ['shadcn', 'plain'],
-                            description: 'UI component library (default: shadcn)',
-                        },
-                        options: {
-                            type: 'object',
-                            properties: {
-                                provenance: { type: 'boolean' },
-                                typescript: { type: 'boolean' },
-                                zod: { type: 'boolean', description: 'Generate Zod validation (default: true)' },
-                            },
-                        },
-                    },
-                    required: ['spec'],
-                },
-            },
-            {
-                name: 'kappa_generate_components',
-                description: 'Generate React components from Kappa component blocks. Supports simple components, compound components with Context, and variants.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        spec: {
-                            type: 'string',
-                            description: 'Kappa specification with component blocks',
-                        },
-                        options: {
-                            type: 'object',
-                            properties: {
-                                provenance: { type: 'boolean' },
-                                typescript: { type: 'boolean' },
-                                forwardRef: { type: 'boolean', description: 'Use forwardRef (default: false)' },
-                                basePath: { type: 'string', description: 'Component output path (default: components)' },
-                            },
-                        },
-                    },
-                    required: ['spec'],
-                },
-            },
-            {
-                name: 'kappa_generate_design',
-                description: 'Generate CSS variables and Tailwind config from Kappa design blocks. Supports colors, typography, spacing, borders, shadows, and motion tokens.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        spec: {
-                            type: 'string',
-                            description: 'Kappa specification with design block',
-                        },
-                        format: {
-                            type: 'string',
-                            enum: ['css', 'tailwind', 'both'],
-                            description: 'Output format (default: both)',
-                        },
-                        options: {
-                            type: 'object',
-                            properties: {
-                                provenance: { type: 'boolean' },
-                                prefix: { type: 'string', description: 'CSS variable prefix' },
-                                hsl: { type: 'boolean', description: 'Use HSL colors (default: false)' },
-                            },
-                        },
-                    },
-                    required: ['spec'],
-                },
-            },
-            {
-                name: 'kappa_generate_all',
-                description: 'Generate complete full-stack application from Kappa specification. Includes schema, API, pages, forms, components, and design tokens. Maximum token savings.',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        spec: {
-                            type: 'string',
-                            description: 'Complete Kappa specification',
-                        },
-                        options: {
-                            type: 'object',
-                            properties: {
-                                framework: { type: 'string', enum: ['tanstack-start', 'nextjs'], description: 'Page framework (default: tanstack-start)' },
-                                apiFramework: { type: 'string', enum: ['hono', 'express', 'trpc'], description: 'API framework (default: hono)' },
-                                ui: { type: 'string', enum: ['shadcn', 'plain'], description: 'UI library (default: shadcn)' },
-                                dbDialect: { type: 'string', enum: ['sqlite', 'postgres', 'mysql'], description: 'Database (default: sqlite)' },
-                                provenance: { type: 'boolean' },
-                                typescript: { type: 'boolean' },
-                            },
+                            description: 'Filter by framework (e.g., drizzle, hono, react)',
                         },
                     },
-                    required: ['spec'],
                 },
             },
         ],