@claudetools/tools 0.9.0 → 0.9.2

package/dist/templates/claude-md.js

@@ -102,169 +102,55 @@ codebase_context("src/auth.ts")  # Get file dependencies
 analyze_impact("validateToken")  # See what changing a function affects
 \`\`\`
 
-## CodeDNA: Generate Code, Save 99% Tokens
+## Code Generation (saves 95-99% tokens)
 
-**BEFORE writing ANY code, check if CodeDNA can generate it.** Call \`codedna_list_generators()\` to see available generators.
+**ALWAYS use \`codegen\` instead of writing boilerplate.** One line of natural language → 10+ production files.
 
-### Available Generators (20+)
-
-| Category | Frameworks | Tool |
-|----------|------------|------|
-| **API** | Express, FastAPI, NestJS, Hono, Elysia, tRPC | \`codedna_generate_api\` |
-| **Frontend** | React, Vue, SvelteKit, Astro, React Router v7, TanStack Start | \`codedna_generate_frontend\` |
-| **ORM** | Prisma, Drizzle | \`codedna_generate_api\` with database option |
-| **Auth** | Better Auth, Auth.js, Lucia | \`codedna_generate_api\` with auth option |
-| **Components** | Forms, Tables, Cards, Modals (React/Vue/Svelte) | \`codedna_generate_component\` |
-
-### Usage Examples
+### Quick Reference
 
 \`\`\`typescript
-// API with auth and validation
-codedna_generate_api({
-  spec: "User(email:string:unique, password:string:hashed)",
-  framework: "express",  // or: fastapi, nestjs, hono, elysia, trpc
-  options: { auth: true, validation: true, tests: true }
-})
-
-// Frontend with forms and data fetching
-codedna_generate_frontend({
-  spec: "User(email:string, name:string, role:enum(admin,user))",
-  framework: "react",  // or: vue, nextjs, sveltekit, astro
-  options: { forms: true, tables: true, ui: "shadcn" }
-})
-
-// Single component
-codedna_generate_component({
-  spec: "Product(name:string, price:decimal, inStock:boolean)",
-  type: "form",  // or: table, card, modal
-  framework: "react",
-  options: { validation: true, ui: "shadcn" }
-})
-\`\`\`
-
-### Entity DSL Quick Reference
-
-\`\`\`
-EntityName(field:type:modifier, field2:type:modifier)
-
-Types: string, integer, decimal, boolean, datetime, text, json
-Modifiers: unique, required, optional, hashed, email, min(n), max(n), default(v)
-Relations: userId:User (reference), posts:Post[] (array)
-Enums: role:enum(admin,user,guest)
-\`\`\`
-
-**Token savings:** 30,000 tokens → 200 tokens (99% reduction per generation)
-
-## Kappa v2.5: Declarative Full-Stack Generation
-
-**For even higher-level generation**, use Kappa DSL - a declarative specification language that generates complete applications from compact specs.
-
-### When to Use Kappa vs CodeDNA
-
-| Use Case | Tool |
-|----------|------|
-| Single entity/component | CodeDNA (\`codedna_generate_*\`) |
-| Full application with multiple entities | Kappa (\`kappa_generate_all\`) |
-| Pages, forms, routing together | Kappa |
-| Design system + components | Kappa |
-
-### Kappa Tools
-
-| Tool | Purpose |
-|------|---------|
-| \`kappa_parse\` | Parse and validate Kappa spec |
-| \`kappa_generate_schema\` | Generate Drizzle schema + Zod + types |
-| \`kappa_generate_api\` | Generate API routes (Hono/Express/tRPC) |
-| \`kappa_generate_pages\` | Generate pages (TanStack Start/Next.js) |
-| \`kappa_generate_forms\` | Generate forms (React Hook Form + Zod + shadcn) |
-| \`kappa_generate_components\` | Generate React components (compound, forwardRef) |
-| \`kappa_generate_design\` | Generate CSS variables + Tailwind config |
-| \`kappa_generate_all\` | Generate complete full-stack application |
-
-### Kappa DSL Example
+// Entities → schema + types + validators + API + tests
+codegen({ describe: "User with email, password, role (admin/user)" })
+codegen({ describe: "Post with title, content, belongs to User as author" })
 
-\`\`\`
-// Complete app specification in ~50 lines
-project TaskManager {
-  database postgres
-  framework tanstack-start
-}
-
-entity Task {
-  title string required max(100)
-  description text
-  status enum(todo, in_progress, done) default(todo)
-  dueDate datetime
-  assignee User
-}
-
-entity User {
-  email string unique email
-  name string required
-  tasks Task[]
-}
-
-api /tasks {
-  GET / -> list Task[]
-  POST / -> create Task
-  GET /:id -> get Task
-  PUT /:id -> update Task
-  DELETE /:id -> delete Task
-}
+// Forms → React Hook Form + Zod + shadcn inputs
+codegen({ describe: "Login form with email, password, submit to /auth/login" })
 
-page /tasks {
-  layout dashboard
-  load tasks from /api/tasks
-  components [TaskList, TaskForm]
-}
+// Components → Radix/shadcn with variants
+codegen({ describe: "Button with label, onClick, variant (primary/secondary)" })
 
-form TaskForm for Task {
-  fields [title, description, status, dueDate]
-  submit POST /api/tasks
-}
+// Pages → TanStack Start or Next.js routes
+codegen({ describe: "Dashboard page at /dashboard, requires auth, loads User" })
 
-design {
-  colors {
-    primary #3B82F6
-    secondary #6B7280
-  }
-  typography {
-    fontFamily "Inter"
-    scale { sm: "0.875rem", base: "1rem", lg: "1.125rem" }
-  }
-}
+// Generate specific outputs
+codegen({ describe: "User with email", generate: ['schema', 'types'] })
+codegen({ describe: "User with email", generate: ['tests'] })
+codegen({ describe: "User with email", generate: ['all'] })  // everything
 \`\`\`
 
-### Usage
-
-\`\`\`typescript
-// Generate everything from spec
-kappa_generate_all({
-  spec: \`project MyApp { ... }\`,
-  options: {
-    framework: "tanstack-start",
-    ui: "shadcn",
-    dbDialect: "postgres"
-  }
-})
-
-// Or generate incrementally
-kappa_parse({ spec: "..." })  // Validate first
-kappa_generate_schema({ spec: "...", outputs: ["drizzle", "zod", "types"] })
-kappa_generate_api({ spec: "...", framework: "hono" })
-kappa_generate_pages({ spec: "...", framework: "tanstack-start" })
-\`\`\`
+### What It Generates
+| Type | Output Files |
+|------|-------------|
+| Entity | schema.ts, types.ts, validators.ts, routes.ts |
+| Tests | *.test.ts, *.factory.ts, *.mock.ts |
+| Form | *-form.tsx (RHF + Zod + shadcn) |
+| Component | *.tsx (Radix primitives + Tailwind) |
+| Page | route.tsx (loaders, guards, layouts) |
 
-**Token savings:** ~50 lines of Kappa → thousands of lines of production code (95%+ reduction)
+### Smart Inference
+- Field names → types: \`email\` → email, \`password\` → hashed, \`price\` → decimal
+- Enums: \`role (admin/user)\` → enum type
+- Relationships: \`belongs to User as author\` → foreign key + relation
+- Forms: \`email\` → email input, \`message\` → textarea
+- Pages: \`requires auth\` → guard, \`loads User\` → data loader
 
 ## Best Practices
 
 1. **Trust auto-injection** - Context is injected automatically, don't call memory_search
 2. **Store decisions** - Use \`memory_store_fact\` for architectural choices
 3. **Use task tracking** - Break complex work into tasks
-4. **Use Kappa for full apps** - For multi-entity apps with pages/forms, use \`kappa_generate_all\`
-5. **Use CodeDNA for single components** - For individual entities or components, use \`codedna_generate_*\`
-6. **Minimize tool calls** - Every MCP call costs context tokens
+4. **Use codegen for boilerplate** - Generate schemas, types, validators, routes
+5. **Minimize tool calls** - Every MCP call costs context tokens
 ${SECTION_END}
 `;
 /**
@@ -297,12 +183,11 @@ task_start({ task_id: "task_xxx" })
 task_complete({ task_id: "task_xxx", summary: "What was done" })
 \`\`\`
 
-## CodeDNA (saves 95-99% tokens)
-\`\`\`
-codedna_list_generators()  // See all available generators
-codedna_generate_api("User(email:string:unique, password:string)", "express")
-codedna_generate_frontend("User(email:string, name:string)", "react")
-codedna_generate_component("Product(name:string, price:decimal)", "form", "react")
+## Code Generation (95-99% token savings)
+\`\`\`typescript
+codegen({ describe: "User with email, password, role (admin/user)" })  // → schema + types + API + tests
+codegen({ describe: "Login form with email, password" })               // → RHF + Zod form
+codegen({ describe: "Dashboard page at /dashboard, requires auth" })   // → TanStack/Next route
 \`\`\`
 ${SECTION_END}
 `;

package/dist/templates/orchestrator-prompt.d.ts

@@ -18,9 +18,9 @@ export declare function buildOrchestratorPrompt(params: {
     availableWorkers?: string[];
 }): string;
 /**
- * Get CodeDNA usage hint for task descriptions
+ * Get codegen usage hint for task descriptions
  */
-export declare function getCodeDNAHint(entitySpec: string): string;
+export declare function getCodegenHint(entityDescription: string): string;
 /**
  * Validate task description doesn't contain code
  */

package/dist/templates/orchestrator-prompt.js

@@ -85,22 +85,17 @@ export function buildOrchestratorPrompt(params) {
       - File-by-file change lists
     </behavior>
 
-    <behavior id="codedna_specs" priority="MANDATORY">
+    <behavior id="codegen_specs" priority="MANDATORY">
       When tasks involve creating entities/models/APIs:
 
-      INSTEAD OF writing code like:
-      \`\`\`typescript
-      interface User {
-        id: string;
-        email: string;
-        password: string;
-      }
-      \`\`\`
+      INSTEAD OF writing code, USE natural language:
+      "User with email, password, role (admin/user)"
 
-      USE Entity DSL format:
-      "User(id:string:unique, email:string:required, password:string:hashed)"
+      Workers use codegen() which infers types from field names:
+      - email → email type, password → hashed, createdAt → timestamp
+      - (admin/user) → enum, price → decimal, isActive → boolean
 
-      This tells workers to use CodeDNA generators (95-99% token savings).
+      Token savings: 95-99% vs manual coding.
     </behavior>
 
     <behavior id="parallel_dispatch" priority="IMPORTANT">
@@ -161,19 +156,18 @@ export function buildOrchestratorPrompt(params) {
     - Random .md files scattered in src/ or root
   </documentation_standards>
 
-  <entity_dsl_format>
-    When defining data models, use Entity DSL:
+  <entity_format>
+    When defining data models, use natural language:
 
-    FORMAT: EntityName(field:type:constraint, field:type:constraint, ...)
-
-    TYPES: string, integer, decimal, boolean, datetime, ref(Entity), enum(val1|val2)
-    CONSTRAINTS: unique, required, min(n), max(n), hashed, default(val)
+    FORMAT: "EntityName with field1, field2, field3 (enum values)"
 
     EXAMPLES:
-    - "User(email:string:unique:required, password:string:hashed, role:enum(admin|user))"
-    - "Product(name:string:required, price:decimal:min(0), category:ref(Category))"
-    - "Order(user:ref(User), total:decimal, status:enum(pending|paid|shipped))"
-  </entity_dsl_format>
+    - "User with email, password, role (admin/user)"
+    - "Product with name, price, categoryId"
+    - "Order with userId, total, status (pending/paid/shipped)"
+
+    Types are inferred from field names (email→email, password→hashed, price→decimal)
+  </entity_format>
 
   <acceptance_criteria_format>
     Good acceptance criteria are:
@@ -219,24 +213,23 @@ export function buildOrchestratorPrompt(params) {
     - general-expert: Tasks that don't fit other domains`}
   </available_workers>
 
-  <codedna_generators priority="CRITICAL">
-    CodeDNA generates production code from Entity DSL - workers MUST check availability first.
+  <codegen priority="CRITICAL">
+    codegen() generates production code from natural language descriptions.
 
-    BEFORE creating any task involving APIs, CRUD, or UI components:
-    1. Workers should call codedna_list_generators() to see available generators
-    2. If a generator exists, use it instead of writing code manually
+    USAGE: codegen({ describe: "User with email, password, role (admin/user)" })
 
-    AVAILABLE DOMAINS:
-    - api: Express, FastAPI, NestJS (full CRUD with auth, validation, tests)
-    - frontend: React/Next.js, Vue 3 (pages, forms, tables)
-    - component: Forms, tables, cards, modals (React, Vue, Svelte)
+    GENERATES:
+    - Drizzle schema (database tables)
+    - TypeScript types
+    - Zod validators
+    - API routes (Hono/Express)
 
     INCLUDE IN TASK DESCRIPTIONS:
-    When tasks involve entities, include the DSL spec so workers know to use CodeDNA:
-    "Create user registration. Entity: User(email:string:unique, password:string:hashed)"
+    When tasks involve entities, describe them naturally:
+    "Create user registration. Entity: User with email, password, role (admin/user)"
 
-    Token savings: 95-99% vs manual coding
-  </codedna_generators>
+    Stack auto-detected from package.json. Token savings: 95-99% vs manual coding.
+  </codegen>
 
   ${epicTitle ? `<epic_context>
     <title>${epicTitle}</title>
@@ -259,10 +252,10 @@ export function buildOrchestratorPrompt(params) {
 </user_input>`;
 }
 /**
- * Get CodeDNA usage hint for task descriptions
+ * Get codegen usage hint for task descriptions
  */
-export function getCodeDNAHint(entitySpec) {
-    return `Entity spec: "${entitySpec}" (workers will use CodeDNA generators)`;
+export function getCodegenHint(entityDescription) {
+    return `Entity: ${entityDescription} (workers will use codegen)`;
 }
 /**
  * Validate task description doesn't contain code

package/dist/templates/self-critique.d.ts

@@ -0,0 +1,50 @@
+export interface SelfCritiqueContext {
+    taskDescription: string;
+    proposedSolution: string;
+    codeSnippet?: string;
+    targetAudience?: string;
+}
+export interface SelfCritiqueResult {
+    passed: boolean;
+    issues: SelfCritiqueIssue[];
+    suggestions: string[];
+    overallScore: number;
+}
+export interface SelfCritiqueIssue {
+    category: 'universality' | 'simplicity' | 'hardcoding' | 'assumptions';
+    severity: 'low' | 'medium' | 'high';
+    description: string;
+    suggestion: string;
+}
+/**
+ * Generate a self-critique prompt for AI agents.
+ * This prompt guides the AI to check its own work for common issues.
+ */
+export declare function generateSelfCritiquePrompt(context: SelfCritiqueContext): string;
+/**
+ * Quick check prompts for specific concerns.
+ * Use these for targeted self-critique on specific aspects.
+ */
+export declare const QUICK_CRITIQUE_PROMPTS: {
+    universality: string;
+    simplicity: string;
+    hardcoding: string;
+    assumptions: string;
+};
+/**
+ * Generate a pre-commit checklist for AI agents.
+ * A lightweight version of self-critique for quick checks.
+ */
+export declare function generatePreCommitChecklist(taskType: 'code' | 'design' | 'analysis'): string;
+/**
+ * Parse a self-critique response from an LLM.
+ */
+export declare function parseSelfCritiqueResponse(response: string): SelfCritiqueResult | null;
+/**
+ * Determine if a self-critique result warrants action.
+ */
+export declare function shouldTakeAction(result: SelfCritiqueResult): {
+    shouldRevise: boolean;
+    shouldAskUser: boolean;
+    reason: string;
+};

package/dist/templates/self-critique.js

@@ -0,0 +1,209 @@
+// =============================================================================
+// Self-Critique Prompt Template
+// =============================================================================
+// A template for AI agents to self-critique their work before finalizing.
+// Catches issues like hardcoded patterns, over-engineering, and assumptions
+// before they require user intervention.
+// =============================================================================
+/**
+ * Generate a self-critique prompt for AI agents.
+ * This prompt guides the AI to check its own work for common issues.
+ */
+export function generateSelfCritiquePrompt(context) {
+    const codeSection = context.codeSnippet
+        ? `\n## Code to Review\n\`\`\`\n${context.codeSnippet.slice(0, 2000)}\n\`\`\``
+        : '';
+    const audienceNote = context.targetAudience
+        ? `Target audience: ${context.targetAudience}`
+        : 'Target audience: All users (universal)';
+    return `# Self-Critique Review
+
+You are reviewing your own proposed solution before finalizing. Be critical and honest.
+
+## Task
+${context.taskDescription}
+
+## Proposed Solution
+${context.proposedSolution}
+${codeSection}
+
+## Review Criteria
+
+${audienceNote}
+
+Evaluate the solution against these criteria:
+
+### 1. Universality (Does this work for ALL users?)
+- Does this assume a specific communication style?
+- Would this work for users from different cultures/backgrounds?
+- Are there hardcoded patterns that only match certain phrasings?
+- Would a user with a different vocabulary trigger this correctly?
+
+### 2. Simplicity (Is this over-engineered?)
+- Is there a simpler way to achieve the same result?
+- Are there unnecessary abstractions or indirections?
+- Is the complexity justified by the requirements?
+- Would a junior developer understand this easily?
+
+### 3. Hardcoding (Am I hardcoding things that should be inferred?)
+- Are there magic strings that should be configurable?
+- Are there hardcoded patterns that limit flexibility?
+- Should any of this logic be LLM-inferred instead of rule-based?
+- Are there assumptions baked into constants that might not hold?
+
+### 4. Assumptions (What am I assuming that might be wrong?)
+- What implicit assumptions does this solution make?
+- Are these assumptions documented or validated?
+- What happens if an assumption is violated?
+- Would a user from a different context have different expectations?
+
+## Output Format
+
+Respond with a JSON object:
+{
+  "passed": true/false,
+  "issues": [
+    {
+      "category": "universality|simplicity|hardcoding|assumptions",
+      "severity": "low|medium|high",
+      "description": "What the issue is",
+      "suggestion": "How to fix it"
+    }
+  ],
+  "suggestions": ["List of improvement suggestions"],
+  "overallScore": 0-100
+}
+
+A solution passes if:
+- No high-severity issues
+- overallScore >= 70
+- All critical universality concerns addressed
+
+Be critical. It's better to catch issues now than to require user intervention later.`;
+}
+/**
+ * Quick check prompts for specific concerns.
+ * Use these for targeted self-critique on specific aspects.
+ */
+export const QUICK_CRITIQUE_PROMPTS = {
+    universality: `Before finalizing, ask yourself:
+- Would this work for a user who communicates differently than me?
+- Am I assuming English idioms or Western communication patterns?
+- Would this handle indirect, polite, or terse communication styles?
+- If I replaced keywords with synonyms, would it still work?`,
+    simplicity: `Before finalizing, ask yourself:
+- Can I explain this in one sentence?
+- Is there a 3-line solution I'm missing?
+- Would a code reviewer ask "why is this so complicated?"
+- Am I solving future problems that don't exist yet?`,
+    hardcoding: `Before finalizing, ask yourself:
+- Am I matching specific strings that could be phrased differently?
+- Should this regex be an LLM inference instead?
+- Are my constants actually universal, or just common in my experience?
+- Would this break if the user uses different terminology?`,
+    assumptions: `Before finalizing, ask yourself:
+- What am I assuming about the user's environment?
+- What am I assuming about their technical level?
+- What am I assuming about their preferences?
+- What happens if any of these assumptions are wrong?`,
+};
+/**
+ * Generate a pre-commit checklist for AI agents.
+ * A lightweight version of self-critique for quick checks.
+ */
+export function generatePreCommitChecklist(taskType) {
+    const baseChecks = `
+## Pre-Commit Checklist
+
+Before finalizing, verify:
+
+☐ **Universality**: Works for diverse users, not just specific communication styles
+☐ **Simplicity**: No unnecessary complexity; a simpler solution doesn't exist
+☐ **No Hardcoding**: Dynamic where needed; LLM inference over rigid patterns
+☐ **Assumptions Documented**: Any assumptions are explicit and validated
+`;
+    const typeSpecificChecks = {
+        code: `
+### Code-Specific
+☐ No magic strings that should be configurable
+☐ No regex patterns that could be LLM inference
+☐ Error messages are helpful, not cryptic
+☐ Edge cases are handled, not assumed away
+`,
+        design: `
+### Design-Specific
+☐ Scales to 10x users without architecture changes
+☐ Failure modes are graceful, not catastrophic
+☐ New developers can understand the design in 5 minutes
+☐ No premature optimization or over-abstraction
+`,
+        analysis: `
+### Analysis-Specific
+☐ Conclusions are supported by evidence
+☐ Alternative interpretations are considered
+☐ Limitations are acknowledged
+☐ Recommendations are actionable
+`,
+    };
+    return baseChecks + (typeSpecificChecks[taskType] || '');
+}
+/**
+ * Parse a self-critique response from an LLM.
+ */
+export function parseSelfCritiqueResponse(response) {
+    try {
+        // Extract JSON from response (handles markdown code blocks)
+        let jsonStr = response.trim();
+        if (jsonStr.startsWith('```')) {
+            jsonStr = jsonStr.replace(/```json?\n?/g, '').replace(/```$/g, '').trim();
+        }
+        const parsed = JSON.parse(jsonStr);
+        // Validate structure
+        if (typeof parsed.passed !== 'boolean')
+            return null;
+        if (!Array.isArray(parsed.issues))
+            return null;
+        if (typeof parsed.overallScore !== 'number')
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Determine if a self-critique result warrants action.
+ */
+export function shouldTakeAction(result) {
+    // High severity issues always require revision
+    const highSeverityIssues = result.issues.filter(i => i.severity === 'high');
+    if (highSeverityIssues.length > 0) {
+        return {
+            shouldRevise: true,
+            shouldAskUser: false,
+            reason: `${highSeverityIssues.length} high-severity issue(s) found: ${highSeverityIssues.map(i => i.description).join('; ')}`,
+        };
+    }
+    // Low score requires revision
+    if (result.overallScore < 70) {
+        return {
+            shouldRevise: true,
+            shouldAskUser: false,
+            reason: `Score ${result.overallScore}/100 is below threshold (70)`,
+        };
+    }
+    // Multiple medium issues warrant user consultation
+    const mediumIssues = result.issues.filter(i => i.severity === 'medium');
+    if (mediumIssues.length >= 3) {
+        return {
+            shouldRevise: false,
+            shouldAskUser: true,
+            reason: `Multiple medium-severity issues found. User should review: ${mediumIssues.map(i => i.description).join('; ')}`,
+        };
+    }
+    return {
+        shouldRevise: false,
+        shouldAskUser: false,
+        reason: 'Solution passed self-critique',
+    };
+}

package/dist/templates/worker-prompt.d.ts

@@ -27,15 +27,15 @@ export interface WorkerPromptParams {
     tier?: 'minimal' | 'standard' | 'professional';
 }
 /**
- * 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 declare function buildWorkerPromptWithCodeDNA(params: WorkerPromptParams): string;
+export declare function buildWorkerPrompt(params: WorkerPromptParams): string;
 /**
  * Build a minimal prompt for simple tasks
  */