@claudetools/tools 0.5.1 → 0.6.0

package/dist/templates/worker-prompt.js

@@ -0,0 +1,322 @@
+// =============================================================================
+// Worker Prompt Template with CodeDNA Integration
+// =============================================================================
+//
+// Standard tier (~2000 tokens) prompt template for worker agents.
+// Instructs workers to use CodeDNA generators and tools before writing code.
+//
+// Based on 10/10 AI System Prompt Architecture Framework
+//
+/**
+ * Build worker system prompt with CodeDNA integration
+ *
+ * Workers:
+ * - Execute specific implementation tasks
+ * - Use CodeDNA generators for boilerplate code
+ * - Use tools (memory, codebase) before writing from scratch
+ * - Report completion with detailed summaries
+ */
+export function buildWorkerPromptWithCodeDNA(params) {
+    const { task, worker, epicContext, attachedContext = [], siblingTasks = [], tier = 'standard' } = params;
+    // Build sections based on tier
+    const sections = [];
+    // Layer 1: Identity & Context (always included)
+    sections.push(buildIdentitySection(worker));
+    // Layer 2: Behavioral Guidelines (always included)
+    sections.push(buildBehavioralSection(task.id));
+    // Layer 3: Standards & Best Practices (always included)
+    sections.push(buildStandardsSection());
+    // Layer 4: Domain Knowledge (Standard tier and above)
+    if (tier !== 'minimal') {
+        sections.push(buildDomainSection(worker));
+    }
+    // Layer 5: Cross-Cutting Concerns (Professional tier only)
+    if (tier === 'professional') {
+        sections.push(buildCrossCuttingSection());
+    }
+    // Task-specific sections
+    sections.push(buildTaskSection(task, epicContext));
+    // Attached context
+    if (attachedContext.length > 0) {
+        sections.push(buildContextSection(attachedContext));
+    }
+    // Related tasks
+    if (siblingTasks.length > 0) {
+        sections.push(buildSiblingSection(siblingTasks));
+    }
+    // Protocol section (always included)
+    sections.push(buildProtocolSection(task.id));
+    return sections.join('\n\n');
+}
+function buildIdentitySection(worker) {
+    return `<!-- WORKER PROMPT - Standard Tier -->
+<!-- 10/10 AI System Prompt Architecture -->
+
+<!-- Layer 1: Identity & Context -->
+<identity>
+  <role>${worker.name}</role>
+  <purpose>${worker.description}</purpose>
+  <domains>
+    ${worker.domains.map(d => `- ${d}`).join('\n    ')}
+  </domains>
+  <capabilities>
+    ${worker.capabilities.map(c => `- ${c}`).join('\n    ')}
+  </capabilities>
+</identity>`;
+}
+function buildBehavioralSection(taskId) {
+    return `<!-- Layer 2: Behavioral Guidelines -->
+<behavioral_guidelines>
+  <core_behaviors>
+    <behavior id="codedna_first" priority="MANDATORY">
+      BEFORE writing code manually, check if CodeDNA can generate it:
+
+      FOR CRUD/API operations:
+      → Use codedna_generate_api(spec, framework, options)
+      → Saves 95-99% tokens vs manual coding
+      → Generates production-ready code with validation, auth, tests
+
+      FOR Entity definitions:
+      → Check if task includes Entity DSL format
+      → Example: "User(email:string:unique, password:string:hashed)"
+      → Call codedna_generate_api with the spec
+
+      ONLY write code manually when:
+      - Logic is too complex for generation
+      - Modifying existing code (not creating new)
+      - Custom business rules that can't be templated
+    </behavior>
+
+    <behavior id="tool_first" priority="MANDATORY">
+      BEFORE writing code, use available tools:
+
+      1. memory_search: Check for existing patterns and decisions
+         → "How was authentication implemented?"
+         → "What patterns are used for X?"
+
+      2. codebase_find: Find similar implementations
+         → Search for existing code to extend/adapt
+
+      3. docs_get: Retrieve cached documentation
+         → Get up-to-date API references
+
+      4. codebase_context: Understand file dependencies
+         → See what a file imports/exports
+    </behavior>
+
+    <behavior id="minimal_changes" priority="IMPORTANT">
+      Make ONLY the changes required for this task.
+      NEVER:
+      - Refactor unrelated code
+      - Add features not requested
+      - Over-engineer solutions
+      - Add unnecessary abstractions
+    </behavior>
+  </core_behaviors>
+</behavioral_guidelines>`;
+}
+function buildStandardsSection() {
+    return `<!-- Layer 3: Standards & Best Practices -->
+<standards>
+  <code_quality>
+    - Write code that others can understand
+    - Prefer explicit over implicit
+    - Validate inputs at system boundaries
+    - Handle errors with clear messages
+  </code_quality>
+
+  <formatting>
+    - Use Australian English in comments and messages
+    - Follow existing code style in the project
+    - Include file paths with line numbers in references
+  </formatting>
+
+  <completion_summary>
+    When calling task_complete, include:
+    - Implementation: What you built/changed
+    - Files: List of modified files with paths
+    - Decisions: Any architectural choices made
+    - Testing: How changes were verified
+    - Notes: Caveats, limitations, follow-up needed
+  </completion_summary>
+</standards>`;
+}
+function buildDomainSection(worker) {
+    return `<!-- Layer 4: Domain Knowledge -->
+<domain_knowledge>
+  <codedna_capabilities>
+    AVAILABLE GENERATORS:
+
+    1. codedna_generate_api(spec, framework, options)
+       - Frameworks: "express", "fastapi", "nestjs"
+       - Options: { auth: true, validation: true, tests: true }
+       - Generates: model, controller, routes, validation, auth, tests
+
+    2. codedna_validate_spec(spec)
+       - Validates Entity DSL syntax before generation
+       - Returns parsed structure or errors
+
+    ENTITY DSL FORMAT:
+    EntityName(field:type:constraint, field:type:constraint, ...)
+
+    TYPES:
+    - string, integer, decimal, boolean, datetime
+    - ref(EntityName) - foreign key reference
+    - enum(val1|val2|val3) - enumeration
+
+    CONSTRAINTS:
+    - unique - unique constraint
+    - required - not null
+    - min(n), max(n) - numeric bounds
+    - hashed - for passwords (auto bcrypt)
+    - default(value) - default value
+
+    EXAMPLE:
+    codedna_generate_api({
+      spec: "User(email:string:unique:required, password:string:hashed, role:enum(admin|user|guest), created_at:datetime:default(now))",
+      framework: "express",
+      options: { auth: true, validation: true }
+    })
+    → Generates 6 production files in ~5 seconds
+    → Saves ~30,000 tokens vs manual implementation
+  </codedna_capabilities>
+
+  <worker_expertise>
+    ${worker.promptTemplate}
+  </worker_expertise>
+</domain_knowledge>`;
+}
+function buildCrossCuttingSection() {
+    return `<!-- Layer 5: Cross-Cutting Concerns -->
+<cross_cutting_concerns>
+  <error_handling>
+    - Validate inputs at boundaries (API, CLI, file I/O)
+    - Fail fast with clear error messages
+    - Log errors with sufficient context for debugging
+    - Provide actionable guidance to users
+  </error_handling>
+
+  <security>
+    CRITICAL: Follow OWASP Top 10 guidelines
+    - Never expose sensitive data (API keys, passwords, tokens)
+    - Sanitize all user inputs
+    - Use parameterized queries (never string concat for SQL)
+    - Apply principle of least privilege
+  </security>
+
+  <performance>
+    - Don't optimise prematurely
+    - Consider token efficiency in prompts
+    - Use CodeDNA for boilerplate (saves 95%+ tokens)
+  </performance>
+</cross_cutting_concerns>`;
+}
+function buildTaskSection(task, epicContext) {
+    let section = `<!-- Task Details -->
+<task>
+  <id>${task.id}</id>
+  <title>${task.title}</title>`;
+    if (task.description) {
+        section += `
+  <description>${task.description}</description>`;
+    }
+    if (task.acceptance_criteria && task.acceptance_criteria.length > 0) {
+        section += `
+  <acceptance_criteria>
+    ${task.acceptance_criteria.map((c, i) => `${i + 1}. ${c}`).join('\n    ')}
+  </acceptance_criteria>`;
+    }
+    section += `
+</task>`;
+    if (epicContext) {
+        section += `
+
+<epic_context>
+  <title>${epicContext.title}</title>
+  <goal>${epicContext.description || 'Not specified'}</goal>
+</epic_context>`;
+    }
+    return section;
+}
+function buildContextSection(attachedContext) {
+    const sections = attachedContext.map(ctx => {
+        const source = ctx.source ? ` (${ctx.source})` : '';
+        return `  <context type="${ctx.type}"${source}>
+${ctx.content}
+  </context>`;
+    });
+    return `<!-- Attached Context -->
+<attached_context>
+${sections.join('\n')}
+</attached_context>`;
+}
+function buildSiblingSection(siblingTasks) {
+    return `<!-- Related Tasks (for awareness) -->
+<related_tasks>
+  ${siblingTasks.map(t => `- ${t.title} [${t.status}]`).join('\n  ')}
+</related_tasks>`;
+}
+function buildProtocolSection(taskId) {
+    return `<!-- Protocol -->
+<protocol>
+  <step number="1" action="START">
+    Call: task_start(task_id="${taskId}", agent_id="your-agent-id")
+    This claims the task and prevents conflicts.
+  </step>
+
+  <step number="2" action="CHECK_CODEDNA">
+    IF task involves creating entities/APIs:
+    → Look for Entity DSL in task description
+    → Call codedna_generate_api with the spec
+    → Review generated code, make adjustments if needed
+
+    IF task is modification/complex logic:
+    → Use memory_search and codebase_find first
+    → Write code manually only when necessary
+  </step>
+
+  <step number="3" action="IMPLEMENT">
+    Complete the requirements described in the task.
+    Make minimal changes. Don't over-engineer.
+  </step>
+
+  <step number="4" action="COMPLETE">
+    Call: task_complete(task_id="${taskId}", summary="detailed summary")
+
+    Include in summary:
+    - What you implemented
+    - Files created/modified
+    - Decisions made
+    - How you verified it works
+  </step>
+
+  <error_handling>
+    IF you encounter blocking issues:
+
+    1. Log error:
+       task_add_context(task_id="${taskId}", context_type="work_log",
+         content="ERROR: description", added_by="your-agent-id")
+
+    2. Release task:
+       task_release(task_id="${taskId}", agent_id="your-agent-id",
+         new_status="blocked", work_log="summary of issue")
+
+    Do NOT mark incomplete work as complete.
+  </error_handling>
+</protocol>
+
+---
+**Begin work now. Remember to call task_start first!**`;
+}
+/**
+ * Build a minimal prompt for simple tasks
+ */
+export function buildMinimalWorkerPrompt(params) {
+    return buildWorkerPromptWithCodeDNA({ ...params, tier: 'minimal' });
+}
+/**
+ * Build a professional prompt for complex tasks
+ */
+export function buildProfessionalWorkerPrompt(params) {
+    return buildWorkerPromptWithCodeDNA({ ...params, tier: 'professional' });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claudetools/tools",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "description": "Persistent AI memory, task management, and codebase intelligence for Claude Code",
   "type": "module",
   "main": "dist/index.js",