prjct-cli 0.11.5 → 0.12.1

package/core/agentic/prompt-builder.js

@@ -1,352 +0,0 @@
-/**
- * Prompt Builder
- * Builds prompts for Claude based on templates and context.
- * Claude decides what to do - NO if/else logic here.
- *
- * @module agentic/prompt-builder
- * @version 4.1
- */
-
-const fs = require('fs')
-const path = require('path')
-
-/**
- * Builds prompts for Claude using templates, context, and learned patterns.
- * Supports plan mode, think blocks, and quality checklists.
- */
-class PromptBuilder {
-  constructor() {
-    /** @type {Object<string, string>|null} */
-    this._checklistsCache = null
-    /** @type {string|null} */
-    this._checklistRoutingCache = null
-  }
-
-  /**
-   * Load quality checklists from templates/checklists/
-   *
-   * @returns {Object<string, string>} Map of checklist name to content
-   */
-  loadChecklists() {
-    if (this._checklistsCache) return this._checklistsCache
-
-    const checklistsDir = path.join(__dirname, '..', '..', 'templates', 'checklists')
-    const checklists = {}
-
-    try {
-      if (fs.existsSync(checklistsDir)) {
-        const files = fs.readdirSync(checklistsDir).filter(f => f.endsWith('.md'))
-        for (const file of files) {
-          const name = file.replace('.md', '')
-          const content = fs.readFileSync(path.join(checklistsDir, file), 'utf-8')
-          checklists[name] = content
-        }
-      }
-    } catch (err) {
-      // Silent fail - checklists are optional enhancement
-    }
-
-    this._checklistsCache = checklists
-    return checklists
-  }
-
-  /**
-   * Load checklist routing template for Claude to decide which checklists apply
-   *
-   * @returns {string|null} Routing template content or null if not found
-   */
-  loadChecklistRouting() {
-    if (this._checklistRoutingCache) return this._checklistRoutingCache
-
-    const routingPath = path.join(__dirname, '..', '..', 'templates', 'agentic', 'checklist-routing.md')
-
-    try {
-      if (fs.existsSync(routingPath)) {
-        this._checklistRoutingCache = fs.readFileSync(routingPath, 'utf-8')
-      }
-    } catch (err) {
-      // Silent fail
-    }
-
-    return this._checklistRoutingCache || null
-  }
-  /**
-   * Build a complete prompt for Claude from template, context, and enhancements
-   *
-   * @param {Object} template - Template with frontmatter and content
-   * @param {Object} context - Project context (projectPath, projectId, files, params)
-   * @param {Object} state - Current prjct state (now, next, analysis, etc.)
-   * @param {Object|null} [agent] - Specialized agent config (name, role, skills)
-   * @param {Object|null} [learnedPatterns] - User preferences from memory system
-   * @param {Object|null} [thinkBlock] - Reasoning block (plan, conclusions, confidence)
-   * @param {Array|null} [relevantMemories] - Past decisions from semantic database
-   * @param {Object|null} [planInfo] - Plan mode status (isPlanning, requiresApproval)
-   * @returns {string} Complete prompt ready for Claude
-   */
-  build(template, context, state, agent = null, learnedPatterns = null, thinkBlock = null, relevantMemories = null, planInfo = null) {
-    const parts = []
-    
-    // Store context for use in helper methods
-    this._currentContext = context
-
-    // Agent assignment (CONDITIONAL - only for code-modifying commands)
-    // Commands like done, ship, recap, next don't need specialized agents
-    const commandName = template.frontmatter?.name?.replace('p:', '') || ''
-    const agentCommands = ['now', 'build', 'feature', 'design', 'fix', 'bug', 'test', 'work', 'cleanup', 'spec']
-    const needsAgent = agentCommands.includes(commandName)
-
-    if (agent && needsAgent) {
-      // COMPRESSED: Only essential agent info (500 bytes vs 3-5KB)
-      parts.push(`# AGENT: ${agent.name}\n`)
-      if (agent.role) parts.push(`Role: ${agent.role}\n`)
-      if (agent.skills?.length) parts.push(`Skills: ${agent.skills.join(', ')}\n`)
-      parts.push(`\nApply specialized expertise. Read agent file for details if needed.\n\n`)
-    }
-
-    // Core instruction (concise)
-    parts.push(`TASK: ${template.frontmatter.description}\n`)
-
-    // Tools (inline)
-    if (template.frontmatter['allowed-tools']) {
-      parts.push(`TOOLS: ${template.frontmatter['allowed-tools'].join(', ')}\n`)
-    }
-
-    // Critical parameters only
-    if (context.params?.task || context.params?.description) {
-      parts.push(`INPUT: ${context.params.task || context.params.description}\n`)
-    }
-
-    parts.push('\n---\n')
-
-    // Template (only the flow section, skip verbose explanations)
-    const flowMatch = template.content.match(/## Flow([\s\S]*?)(?=##|$)/)
-    if (flowMatch) {
-      parts.push(flowMatch[0])
-    } else {
-      // Fallback to full template if no flow section
-      parts.push(template.content)
-    }
-
-    // Current state (only if exists and relevant)
-    const relevantState = this.filterRelevantState(state)
-    if (relevantState) {
-      parts.push('\n## PRJCT STATE (Project Management Data)\n')
-      parts.push(relevantState)
-      parts.push('\n')
-    }
-
-    // COMPRESSED: File list (5 files vs 20, saves ~400 bytes)
-    if (context.files?.length > 0) {
-      const top5 = context.files.slice(0, 5).join(', ')
-      parts.push(`\n## FILES: ${context.files.length} available. Top: ${top5}\n`)
-      parts.push('Read BEFORE modifying. Use Glob/Grep to find more.\n\n')
-    } else if (context.projectPath) {
-      parts.push(`\n## PROJECT: ${context.projectPath}\nRead files before modifying.\n\n`)
-    }
-
-    // OPTIMIZED: Only include patterns for code-modifying commands
-    // Commands like done, ship, recap, next don't need full patterns
-    const codeCommands = ['now', 'build', 'feature', 'design', 'cleanup', 'fix', 'bug', 'test', 'init', 'spec', 'work']
-    const needsPatterns = codeCommands.includes(commandName)
-
-    // Include code patterns analysis for code-modifying commands
-    // COMPRESSED: Extract only conventions and anti-patterns (800 bytes max vs 6KB)
-    const codePatternsContent = state?.codePatterns || ''
-    if (needsPatterns && codePatternsContent && codePatternsContent.trim()) {
-      const patternSummary = this.extractPatternSummary(codePatternsContent)
-      if (patternSummary) {
-        parts.push('\n## CODE PATTERNS\n')
-        parts.push(patternSummary)
-        parts.push('\nFull patterns: Read analysis/patterns.md\n')
-      }
-    }
-
-    const analysisContent = state?.analysis || ''
-    if (needsPatterns && analysisContent && analysisContent.trim()) {
-      // Extract stack info compactly
-      const stackMatch = analysisContent.match(/Stack[:\s]+([^\n]+)/i) ||
-                        analysisContent.match(/Technology[:\s]+([^\n]+)/i)
-      const stack = stackMatch ? stackMatch[1].trim() : 'detected'
-
-      parts.push(`\n## STACK\nStack: ${stack}\n`)
-      if (!codePatternsContent) {
-        parts.push('Read analysis/repo-summary.md + similar files before coding. Match patterns exactly.\n')
-      }
-    }
-
-    // CRITICAL: Compressed rules (replaces 78 lines with 12)
-    parts.push(this.buildCriticalRules());
-
-    // 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 (OPTIMIZED: 30 lines → 5 lines)
-    if (planInfo?.isPlanning) {
-      parts.push(`\n## PLAN MODE\nRead-only. Gather info → Analyze → Propose plan → Wait for approval.\n`)
-      if (planInfo.allowedTools) parts.push(`Tools: ${planInfo.allowedTools.join(', ')}\n`)
-    }
-    if (planInfo?.requiresApproval) {
-      parts.push(`\n## APPROVAL REQUIRED\nShow changes, list affected files, ask for confirmation.\n`)
-    }
-
-    // P4.1: Quality Checklists (Claude decides which to apply)
-    // Only for code-modifying commands that benefit from quality gates
-    const checklistCommands = ['now', 'build', 'feature', 'design', 'fix', 'bug', 'cleanup', 'spec', 'work']
-    if (checklistCommands.includes(commandName)) {
-      const routing = this.loadChecklistRouting()
-      const checklists = this.loadChecklists()
-
-      if (routing && Object.keys(checklists).length > 0) {
-        parts.push('\n## QUALITY CHECKLISTS\n')
-        parts.push('Apply relevant checklists based on task. Read checklist-routing.md for guidance.\n')
-        parts.push(`Available: ${Object.keys(checklists).join(', ')}\n`)
-        parts.push('Path: templates/checklists/{name}.md\n')
-        parts.push('Use Read tool to load checklists you determine are relevant.\n')
-      }
-    }
-
-    // Simple execution directive
-    parts.push('\nEXECUTE: Follow flow. Use tools. Decide.\n')
-
-    return parts.join('')
-  }
-
-  /**
-   * Filter state data to include only relevant portions for the prompt
-   *
-   * @param {Object} state - Full prjct state object
-   * @returns {string|null} Formatted relevant state or null if empty
-   */
-  filterRelevantState(state) {
-    if (!state || Object.keys(state).length === 0) return null
-
-    const relevant = []
-    for (const [key, content] of Object.entries(state)) {
-      if (content && content.trim()) {
-        // Include full content for critical files (now, next, context, patterns)
-        const criticalFiles = ['now', 'next', 'context', 'analysis', 'codePatterns']
-        if (criticalFiles.includes(key)) {
-          // Include full content for critical files (up to 2000 chars)
-          const display = content.length > 2000 
-            ? content.substring(0, 2000) + '\n... (truncated)'
-            : content
-          relevant.push(`### ${key}\n${display}`)
-        } else if (content.length < 1000) {
-          // Include full content for small files
-          relevant.push(`### ${key}\n${content}`)
-        } else {
-          // Truncate large files but show more context
-          relevant.push(`### ${key}\n${content.substring(0, 500)}... (truncated, use Read tool for full content)`)
-        }
-      }
-    }
-
-    return relevant.length > 0 ? relevant.join('\n\n') : null
-  }
-
-  /**
-   * Build an analysis prompt for pre-action investigation tasks
-   *
-   * @param {string} analysisType - Type of analysis (e.g., 'patterns', 'stack')
-   * @param {Object} context - Project context with projectPath and projectId
-   * @returns {string} Analysis prompt
-   */
-  buildAnalysis(analysisType, context) {
-    const parts = []
-
-    parts.push(`# Analyze: ${analysisType}\n\n`)
-    parts.push('Read the project context and provide your analysis.\n')
-    parts.push('No predetermined patterns - decide based on what you find.\n\n')
-
-    parts.push('## Project Context\n')
-    parts.push(`- Path: ${context.projectPath}\n`)
-    parts.push(`- ID: ${context.projectId}\n\n`)
-
-    return parts.join('')
-  }
-
-  /**
-   * Extract compressed pattern summary (conventions + high-priority anti-patterns)
-   *
-   * @param {string} content - Full patterns file content
-   * @returns {string|null} Compressed summary (max 800 bytes) or null
-   */
-  extractPatternSummary(content) {
-    if (!content) return null
-
-    const parts = []
-
-    // Extract conventions section
-    const conventionsMatch = content.match(/## Conventions[\s\S]*?(?=##|$)/i)
-    if (conventionsMatch) {
-      // Compress to key lines only
-      const conventions = conventionsMatch[0]
-        .split('\n')
-        .filter(line => line.includes(':') || line.startsWith('-'))
-        .slice(0, 6)
-        .join('\n')
-      if (conventions) parts.push(conventions)
-    }
-
-    // Extract high priority anti-patterns only
-    const antiPatternsMatch = content.match(/### High Priority[\s\S]*?(?=###|##|$)/i)
-    if (antiPatternsMatch) {
-      const antiPatterns = antiPatternsMatch[0].substring(0, 300)
-      parts.push('\nAvoid:\n' + antiPatterns)
-    }
-
-    const result = parts.join('\n').substring(0, 800)
-    return result || null
-  }
-
-  /**
-   * Build critical anti-hallucination rules section
-   *
-   * @returns {string} Formatted rules block
-   */
-  buildCriticalRules() {
-    const fileCount = this._currentContext?.files?.length || this._currentContext?.filteredSize || 0
-    return `
-## RULES (CRITICAL)
-1. **READ FIRST**: Use Read tool BEFORE modifying any file. Never assume code structure.
-2. **MATCH PATTERNS**: Follow existing style, architecture, naming, imports exactly.
-3. **NO HALLUCINATIONS**: Don't invent files, functions, or paths. If unsure, READ first.
-4. **GIT SAFETY**: Never use checkout/reset --hard/clean. Always check status first.
-5. **VERIFY**: After writing, confirm code matches project patterns.
-Context: ${fileCount} files available. Read what you need.
-`;
-  }
-
-}
-
-module.exports = new PromptBuilder()

package/core/agentic/response-templates.js

@@ -1,290 +0,0 @@
-/**
- * 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
-}