prjct-cli 0.9.2 → 0.10.2

package/core/agentic/prompt-builder.js

@@ -2,18 +2,59 @@
  * Prompt Builder
  * Builds prompts for Claude based on templates and context
  * Claude decides what to do - NO if/else logic here
+ *
+ * P1.1: Includes learned patterns from memory system
+ * P3.1: Includes think blocks for anti-hallucination
+ * P3.3: Includes relevant memories from semantic database
+ * P3.4: Includes plan mode instructions
  */
 
 class PromptBuilder {
   /**
    * Build concise prompt - only essentials
+   * CRITICAL: Includes full agent content if agent is provided
+   * P1.1: Includes learned patterns to avoid repetitive questions
+   * P3.1: Includes think blocks for critical decisions
+   * P3.3: Includes relevant memories from semantic database
+   * P3.4: Includes plan mode status and constraints
    */
-  build(template, context, state, agent = null) {
+  build(template, context, state, agent = null, learnedPatterns = null, thinkBlock = null, relevantMemories = null, planInfo = null) {
     const parts = []
 
     // Agent assignment (if applicable)
+    // CRITICAL: Include full agent content, not just name
     if (agent) {
-      parts.push(`AGENT: ${agent.name}\n`)
+      parts.push(`# AGENT ASSIGNMENT\n`)
+      parts.push(`Agent: ${agent.name}\n`)
+      
+      // Include role if available
+      if (agent.role) {
+        parts.push(`Role: ${agent.role}\n`)
+      }
+      
+      // Include domain if available
+      if (agent.domain) {
+        parts.push(`Domain: ${agent.domain}\n`)
+      }
+      
+      // Include skills if available
+      if (agent.skills && agent.skills.length > 0) {
+        parts.push(`Skills: ${agent.skills.join(', ')}\n`)
+      }
+      
+      parts.push(`\n## AGENT INSTRUCTIONS\n`)
+      
+      // CRITICAL: Include full agent content
+      // This is the specialized knowledge for this project
+      if (agent.content) {
+        parts.push(agent.content)
+        parts.push(`\n`)
+      } else if (agent.name) {
+        // Fallback if content not loaded
+        parts.push(`You are the ${agent.name} agent for this project.\n`)
+        parts.push(`Apply your specialized expertise to complete the task.\n\n`)
+      }
+      
       parts.push(`CONTEXT: ${context.filteredSize || 'all'} files (${context.reduction || 0}% reduced)\n\n`)
     }
 
@@ -49,6 +90,75 @@ class PromptBuilder {
       parts.push('\n')
     }
 
+    // Enforcement (Strict Mode)
+    parts.push(this.buildEnforcement());
+
+    // P1.1: Learned Patterns (avoid asking user questions we already know)
+    if (learnedPatterns && Object.keys(learnedPatterns).some(k => learnedPatterns[k])) {
+      parts.push('\n## LEARNED PATTERNS (use these, do NOT ask user)\n')
+      for (const [key, value] of Object.entries(learnedPatterns)) {
+        if (value) {
+          parts.push(`- ${key}: ${value}\n`)
+        }
+      }
+    }
+
+    // P3.1: Think Block (reasoning before action)
+    if (thinkBlock && thinkBlock.plan && thinkBlock.plan.length > 0) {
+      parts.push('\n## THINK FIRST (reasoning from analysis)\n')
+      if (thinkBlock.conclusions && thinkBlock.conclusions.length > 0) {
+        parts.push('Conclusions:\n')
+        thinkBlock.conclusions.forEach(c => parts.push(`  → ${c}\n`))
+      }
+      parts.push('Plan:\n')
+      thinkBlock.plan.forEach((p, i) => parts.push(`  ${i + 1}. ${p}\n`))
+      parts.push(`Confidence: ${Math.round((thinkBlock.confidence || 0.5) * 100)}%\n`)
+    }
+
+    // P3.3: Relevant Memories (context from past decisions)
+    if (relevantMemories && relevantMemories.length > 0) {
+      parts.push('\n## RELEVANT MEMORIES (apply these learnings)\n')
+      for (const memory of relevantMemories) {
+        parts.push(`- **${memory.title}**: ${memory.content}\n`)
+        if (memory.tags && memory.tags.length > 0) {
+          parts.push(`  Tags: ${memory.tags.join(', ')}\n`)
+        }
+      }
+    }
+
+    // P3.4: Plan Mode instructions
+    if (planInfo) {
+      if (planInfo.isPlanning) {
+        parts.push('\n## PLAN MODE ACTIVE\n')
+        parts.push('You are in PLANNING mode. Follow these constraints:\n')
+        parts.push('1. **READ-ONLY**: Only use read tools (Read, Glob, Grep)\n')
+        parts.push('2. **GATHER INFO**: Collect all necessary information\n')
+        parts.push('3. **ANALYZE**: Understand the context and implications\n')
+        parts.push('4. **PROPOSE**: Generate a plan with clear steps\n')
+        parts.push('5. **WAIT FOR APPROVAL**: Do NOT execute until user approves\n')
+
+        if (planInfo.active) {
+          parts.push(`\nCurrent Status: ${planInfo.active.status}\n`)
+          if (planInfo.active.gatheredInfo?.length > 0) {
+            parts.push(`Info gathered: ${planInfo.active.gatheredInfo.length} items\n`)
+          }
+        }
+      }
+
+      if (planInfo.requiresApproval) {
+        parts.push('\n## APPROVAL REQUIRED\n')
+        parts.push('This command is DESTRUCTIVE. You MUST:\n')
+        parts.push('1. Show exactly what will change\n')
+        parts.push('2. List affected files/resources\n')
+        parts.push('3. Ask for explicit user confirmation (y/n)\n')
+        parts.push('4. Only proceed after approval\n')
+      }
+
+      if (planInfo.allowedTools) {
+        parts.push(`\nAllowed tools: ${planInfo.allowedTools.join(', ')}\n`)
+      }
+    }
+
     // Simple execution directive
     parts.push('\nEXECUTE: Follow flow. Use tools. Decide.\n')
 
@@ -91,6 +201,21 @@ class PromptBuilder {
 
     return parts.join('')
   }
+
+  /**
+   * Build enforcement section
+   * Forces Claude to follow the process strictly
+   */
+  buildEnforcement() {
+    return `
+## PROCESS ENFORCEMENT
+1. FOLLOW the Flow strictly. Do not skip steps.
+2. USE the allowed tools only.
+3. IF you are stuck, use the "Ask" tool or stop.
+4. DO NOT hallucinate files or commands.
+5. ALWAYS verify your changes.
+`;
+  }
 }
 
 module.exports = new PromptBuilder()

package/core/agentic/response-templates.js

@@ -0,0 +1,290 @@
+/**
+ * Response Templates
+ * Minimal output templates for all commands
+ * Rule: < 4 lines, always actionable
+ *
+ * OPTIMIZATION (P0.3): Minimal Output
+ * - Concise responses (< 4 lines)
+ * - Always suggest next action
+ * - Use symbols for status, not words
+ *
+ * Source: Claude Code, Kiro patterns
+ */
+
+/**
+ * Format duration from milliseconds or ISO strings
+ * @param {number|string|Date} start - Start time
+ * @param {number|string|Date} end - End time (defaults to now)
+ * @returns {string} Human-readable duration
+ */
+function formatDuration(start, end = new Date()) {
+  const startMs = new Date(start).getTime()
+  const endMs = new Date(end).getTime()
+  const diffMs = endMs - startMs
+
+  const hours = Math.floor(diffMs / (1000 * 60 * 60))
+  const minutes = Math.floor((diffMs % (1000 * 60 * 60)) / (1000 * 60))
+
+  if (hours > 0) {
+    return `${hours}h ${minutes}m`
+  }
+  return `${minutes}m`
+}
+
+/**
+ * Truncate text to max length with ellipsis
+ * @param {string} text - Text to truncate
+ * @param {number} maxLength - Maximum length
+ * @returns {string}
+ */
+function truncate(text, maxLength = 40) {
+  if (!text) return ''
+  if (text.length <= maxLength) return text
+  return text.substring(0, maxLength - 3) + '...'
+}
+
+/**
+ * Response templates for each command
+ * Each template is a function that returns minimal formatted output
+ */
+const templates = {
+  /**
+   * /p:done - Task completed
+   */
+  done: ({ task, duration, nextTask }) => {
+    let output = `✓ '${truncate(task)}' (${duration})`
+    if (nextTask) {
+      output += `\n→ Next: '${truncate(nextTask)}'`
+    }
+    output += '\n\n/p:ship to release'
+    return output
+  },
+
+  /**
+   * /p:now - Current task set/shown
+   */
+  now: ({ task, started, isNew }) => {
+    if (!task) {
+      return `No active task\n→ /p:now "task" to start`
+    }
+    if (isNew) {
+      return `🎯 Started: '${truncate(task)}'\n→ /p:done when complete`
+    }
+    return `🎯 Working on: '${truncate(task)}'\n⏱️ ${started || 'just now'}\n→ /p:done when complete`
+  },
+
+  /**
+   * /p:next - Priority queue
+   */
+  next: ({ tasks, total }) => {
+    if (!tasks || tasks.length === 0) {
+      return `Queue empty\n→ /p:feature or /p:idea to add`
+    }
+    const top3 = tasks.slice(0, 3).map((t, i) =>
+      `${i + 1}. ${truncate(t.name, 35)}`
+    ).join('\n')
+    const more = total > 3 ? `\n+${total - 3} more` : ''
+    return `${top3}${more}\n\n/p:now 1 to start`
+  },
+
+  /**
+   * /p:ship - Feature shipped
+   */
+  ship: ({ feature, agent, duration, version }) => {
+    let output = `🚀 Shipped: '${truncate(feature)}'`
+    if (agent) output += ` (${agent})`
+    if (duration) output += ` | ${duration}`
+    if (version) output += ` | v${version}`
+    output += '\n→ /compact recommended'
+    return output
+  },
+
+  /**
+   * /p:idea - Idea captured
+   */
+  idea: ({ idea, addedToQueue }) => {
+    let output = `💡 Captured: '${truncate(idea)}'`
+    if (addedToQueue) {
+      output += '\n→ Added to queue'
+    }
+    output += '\n\n/p:next to see queue'
+    return output
+  },
+
+  /**
+   * /p:feature - Feature added
+   */
+  feature: ({ feature, tasks, impact, effort }) => {
+    let output = `📋 Feature: '${truncate(feature)}'`
+    if (tasks) output += ` (${tasks} tasks)`
+    if (impact) output += `\nImpact: ${impact}`
+    if (effort) output += ` | Effort: ${effort}`
+    output += '\n\n/p:now to start'
+    return output
+  },
+
+  /**
+   * /p:bug - Bug reported
+   */
+  bug: ({ description, priority, addedAt }) => {
+    const priorityIcon = {
+      'critical': '🔴',
+      'high': '🟠',
+      'medium': '🟡',
+      'low': '🟢'
+    }[priority] || '🟡'
+
+    let output = `${priorityIcon} Bug: '${truncate(description)}'\nPriority: ${priority}`
+    if (addedAt) {
+      output += ` | Added: ${addedAt}`
+    }
+    output += '\n\n/p:now to fix'
+    return output
+  },
+
+  /**
+   * /p:pause - Task paused
+   */
+  pause: ({ task, duration }) => {
+    return `⏸️ Paused: '${truncate(task)}' (${duration})\n→ /p:resume to continue`
+  },
+
+  /**
+   * /p:resume - Task resumed
+   */
+  resume: ({ task, pausedFor }) => {
+    return `▶️ Resumed: '${truncate(task)}'\nPaused for: ${pausedFor}\n→ /p:done when complete`
+  },
+
+  /**
+   * /p:recap - Project overview
+   */
+  recap: ({ shipped, inProgress, queued, momentum }) => {
+    const momentumIcon = {
+      'high': '🔥',
+      'medium': '✨',
+      'low': '💤'
+    }[momentum] || '✨'
+
+    return `${momentumIcon} ${shipped} shipped | ${inProgress ? '1 active' : '0 active'} | ${queued} queued`
+  },
+
+  /**
+   * /p:progress - Progress metrics
+   */
+  progress: ({ period, shipped, velocity, trend }) => {
+    const trendIcon = trend > 0 ? '↑' : trend < 0 ? '↓' : '→'
+    return `📊 ${period}: ${shipped} shipped\nVelocity: ${velocity}/week ${trendIcon}`
+  },
+
+  /**
+   * /p:analyze - Analysis complete
+   */
+  analyze: ({ stack, files, agents }) => {
+    return `🔍 Analyzed: ${stack}\n${files} files | ${agents} agents generated\n\n/p:sync to update`
+  },
+
+  /**
+   * /p:sync - Sync complete
+   */
+  sync: ({ updated, agents }) => {
+    return `🔄 Synced: ${updated} files updated\n${agents} agents refreshed`
+  },
+
+  /**
+   * /p:help - Help shown
+   */
+  help: ({ context, suggestions }) => {
+    const sugs = suggestions.slice(0, 3).map(s => `• ${s}`).join('\n')
+    return `📚 ${context}\n\n${sugs}`
+  },
+
+  /**
+   * /p:suggest - Suggestions
+   */
+  suggest: ({ urgency, suggestion, command }) => {
+    const urgencyIcon = {
+      'high': '🔥',
+      'medium': '💡',
+      'low': '✨'
+    }[urgency] || '💡'
+
+    return `${urgencyIcon} ${suggestion}\n→ ${command}`
+  },
+
+  /**
+   * /p:spec - Spec created/updated
+   */
+  spec: ({ name, status, tasks, requirements, isNew }) => {
+    let output = isNew
+      ? `📋 Created spec: '${truncate(name)}'`
+      : `📋 Updated spec: '${truncate(name)}'`
+
+    if (requirements) output += `\n${requirements} requirements`
+    if (tasks) output += ` | ${tasks} tasks`
+    if (status) output += ` | Status: ${status}`
+
+    output += '\n\n→ Review and approve to start'
+    return output
+  },
+
+  /**
+   * Generic success response
+   */
+  success: ({ message, nextAction }) => {
+    let output = `✓ ${message}`
+    if (nextAction) {
+      output += `\n→ ${nextAction}`
+    }
+    return output
+  },
+
+  /**
+   * Generic error response
+   */
+  error: ({ error, suggestion }) => {
+    let output = `❌ ${error}`
+    if (suggestion) {
+      output += `\n→ ${suggestion}`
+    }
+    return output
+  }
+}
+
+/**
+ * Format a response using the appropriate template
+ *
+ * @param {string} commandName - Command name
+ * @param {Object} data - Data for the template
+ * @returns {string} Formatted response
+ */
+function format(commandName, data) {
+  const template = templates[commandName]
+  if (!template) {
+    // Fallback to generic success/error
+    if (data.error) {
+      return templates.error(data)
+    }
+    return templates.success(data)
+  }
+
+  return template(data)
+}
+
+/**
+ * Check if response exceeds recommended length
+ * @param {string} response - Response text
+ * @returns {boolean} True if too long
+ */
+function isTooLong(response) {
+  const lines = response.split('\n').filter(l => l.trim())
+  return lines.length > 4
+}
+
+module.exports = {
+  format,
+  templates,
+  formatDuration,
+  truncate,
+  isTooLong
+}