@claudetools/tools 0.9.1 → 0.9.2

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
  */

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' });
 }