prjct-cli 0.9.2 → 0.10.2

package/core/agentic/command-executor.js

@@ -2,6 +2,17 @@
  * Command Executor
  * WITH MANDATORY AGENT ASSIGNMENT
  * Every task MUST use a specialized agent
+ *
+ * OPTIMIZATION (P0.2): Explicit Validation
+ * - Pre-flight checks before execution
+ * - Specific error messages, never generic failures
+ * - Actionable suggestions in every error
+ *
+ * P3.4: Plan Mode + Approval Flow
+ * - Separates planning from execution
+ * - Requires approval for destructive commands
+ *
+ * Source: Claude Code, Devin, Augment Code patterns
  */
 
 const templateLoader = require('./template-loader')
@@ -10,68 +21,242 @@ const promptBuilder = require('./prompt-builder')
 const toolRegistry = require('./tool-registry')
 const MandatoryAgentRouter = require('./agent-router')
 const ContextFilter = require('./context-filter')
+const ContextEstimator = require('../domain/context-estimator')
+const { validate, formatError } = require('./validation-rules')
+const loopDetector = require('./loop-detector')
+const chainOfThought = require('./chain-of-thought')
+const semanticCompression = require('./semantic-compression')
+const responseTemplates = require('./response-templates')
+const memorySystem = require('./memory-system')
+const groundTruth = require('./ground-truth')
+const thinkBlocks = require('./think-blocks')
+const parallelTools = require('./parallel-tools')
+const planMode = require('./plan-mode')
+// P3.5, P3.6, P3.7: DELEGATED TO CLAUDE CODE
+// - semantic-search → Claude Code has Grep/Glob with semantic understanding
+// - code-intelligence → Claude Code has native LSP integration
+// - browser-preview → Claude Code can use Bash directly
 
 class CommandExecutor {
   constructor() {
     this.agentRouter = new MandatoryAgentRouter()
     this.contextFilter = new ContextFilter()
+    this.contextEstimator = null
   }
 
   /**
    * Execute command with MANDATORY agent assignment
    */
   async execute(commandName, params, projectPath) {
+    // Context for loop detection
+    const loopContext = params.task || params.description || ''
+
+    // Check if we're in a loop BEFORE attempting
+    if (loopDetector.shouldEscalate(commandName, loopContext)) {
+      const escalation = loopDetector.getEscalationInfo(commandName, loopContext)
+      return {
+        success: false,
+        error: escalation.message,
+        escalation,
+        isLoopDetected: true,
+        suggestion: escalation.suggestion
+      }
+    }
+
     try {
       // 1. Load template
       const template = await templateLoader.load(commandName)
 
-      // 2. Build FULL context (before filtering)
-      const fullContext = await contextBuilder.build(projectPath, params)
+      // 2. Build METADATA context only (lazy loading - no file reads yet)
+      const metadataContext = await contextBuilder.build(projectPath, params)
+
+      // 2.5. VALIDATE: Pre-flight checks with specific errors
+      const validation = await validate(commandName, metadataContext)
+      if (!validation.valid) {
+        return {
+          success: false,
+          error: formatError(validation),
+          validation,
+          isValidationError: true
+        }
+      }
 
-      // 3. Check if command requires agent
-      const requiresAgent = template.metadata?.['required-agent'] ||
-                           this.isTaskCommand(commandName)
+      // 2.55. P3.4 PLAN MODE: Check if command requires planning
+      const requiresPlanning = planMode.requiresPlanning(commandName)
+      const isDestructive = planMode.isDestructive(commandName)
+      const isInPlanningMode = planMode.isInPlanningMode(metadataContext.projectId)
+
+      // Start planning mode if required and not already in it
+      let activePlan = null
+      if (requiresPlanning && !isInPlanningMode && !params.skipPlanning) {
+        activePlan = planMode.startPlanning(metadataContext.projectId, commandName, params)
+      } else if (isInPlanningMode) {
+        activePlan = planMode.getActivePlan(metadataContext.projectId)
+      }
 
-      let context = fullContext
+      // 2.6. GROUND TRUTH: Verify actual state before critical operations
+      let groundTruthResult = null
+      if (groundTruth.requiresVerification(commandName)) {
+        const preState = await contextBuilder.loadStateForCommand(metadataContext, commandName)
+        groundTruthResult = await groundTruth.verify(commandName, metadataContext, preState)
+
+        // Log warnings but don't block (user can override)
+        if (!groundTruthResult.verified && groundTruthResult.warnings.length > 0) {
+          console.log(groundTruth.formatWarnings(groundTruthResult))
+        }
+      }
+
+      // 2.7. THINK BLOCKS (P3.1): Dynamic reasoning based on triggers
+      // ANTI-HALLUCINATION FIX: Load state BEFORE using it (was undefined)
+      let thinkBlock = null
+      const preThinkState = groundTruthResult?.actual || await contextBuilder.loadStateForCommand(metadataContext, commandName)
+      const thinkTrigger = thinkBlocks.detectTrigger(commandName, metadataContext, preThinkState)
+      if (thinkTrigger) {
+        thinkBlock = await thinkBlocks.generate(thinkTrigger, commandName, metadataContext, preThinkState)
+
+        // Log think block if in debug mode
+        if (process.env.PRJCT_DEBUG === 'true') {
+          console.log(thinkBlocks.format(thinkBlock, true))
+        }
+      }
+
+      // 2.8. CHAIN OF THOUGHT: Reasoning for critical commands
+      let reasoning = null
+      if (chainOfThought.requiresReasoning(commandName)) {
+        // Load state for reasoning
+        const reasoningState = await contextBuilder.loadStateForCommand(metadataContext, commandName)
+        reasoning = await chainOfThought.reason(commandName, metadataContext, reasoningState)
+
+        // If reasoning shows critical issues, warn but continue
+        if (reasoning.reasoning && !reasoning.reasoning.allPassed) {
+          console.log('⚠️  Chain of Thought detected issues:')
+          console.log(chainOfThought.formatPlan(reasoning))
+        }
+      }
+
+      // 3. CRITICAL: Force agent assignment for ALL task-related commands
+      const requiresAgent = template.metadata?.['required-agent'] !== false &&
+                           (template.metadata?.['required-agent'] === true ||
+                            this.isTaskCommand(commandName) ||
+                            this.shouldUseAgent(commandName))
+
+      let context = metadataContext
       let assignedAgent = null
 
+      // MANDATORY: Assign specialized agent for task commands
       if (requiresAgent) {
-        // 4. MANDATORY: Assign specialized agent
+        // 4. Create task object for analysis
         const task = {
           description: params.task || params.description || commandName,
           type: commandName
         }
 
+        // 5. LAZY CONTEXT: Analyze task FIRST, then estimate files needed
+        // This avoids reading all files before knowing what we need
         const agentAssignment = await this.agentRouter.executeTask(
           task,
-          fullContext,
+          metadataContext, // Only metadata, no files yet
           projectPath
         )
 
         assignedAgent = agentAssignment.agent
+        const taskAnalysis = agentAssignment.taskAnalysis
+
+        // Validate agent was assigned
+        if (!assignedAgent || !assignedAgent.name) {
+          throw new Error(
+            `CRITICAL: Failed to assign agent for command "${commandName}". ` +
+            `System requires ALL task commands to use specialized agents.`
+          )
+        }
+
+        // 6. PRE-FILTER: Estimate which files are needed BEFORE reading
+        if (!this.contextEstimator) {
+          this.contextEstimator = new ContextEstimator()
+        }
+
+        const estimatedFiles = await this.contextEstimator.estimateFiles(
+          taskAnalysis,
+          projectPath
+        )
 
-        // 5. Filter context for this specific agent (70-90% reduction)
+        // 7. Build context ONLY with estimated files (lazy loading)
         const filtered = await this.contextFilter.filterForAgent(
           assignedAgent,
           task,
           projectPath,
-          fullContext
+          {
+            ...metadataContext,
+            estimatedFiles, // Pre-filtered file list
+            fileCount: estimatedFiles.length
+          }
         )
 
         context = {
           ...filtered,
           agent: assignedAgent,
-          originalSize: fullContext.files?.length || 0,
+          originalSize: estimatedFiles.length, // Estimated, not actual full size
           filteredSize: filtered.files?.length || 0,
-          reduction: filtered.metrics?.reductionPercent || 0
+          reduction: filtered.metrics?.reductionPercent || 0,
+          lazyLoaded: true // Flag indicating lazy loading was used
         }
       }
 
       // 6. Load state with filtered context
-      const state = await contextBuilder.loadState(context)
+      const rawState = await contextBuilder.loadState(context)
+
+      // 6.5. SEMANTIC COMPRESSION: Compress state for reduced token usage
+      const compressedState = {}
+      for (const [key, content] of Object.entries(rawState)) {
+        if (content) {
+          const compressed = semanticCompression.compress(content, key)
+          compressedState[key] = {
+            raw: content,
+            summary: compressed.summary,
+            compressed
+          }
+        } else {
+          compressedState[key] = { raw: null, summary: 'Empty', compressed: null }
+        }
+      }
 
-      // 7. Build prompt with agent assignment
-      const prompt = promptBuilder.build(template, context, state, assignedAgent)
+      // Use compressed summaries for prompt, keep raw for tool execution
+      const state = {
+        ...rawState,
+        _compressed: compressedState,
+        _compressionMetrics: semanticCompression.getMetrics()
+      }
+
+      // 7. MEMORY: Load learned patterns AND relevant memories for this command
+      let learnedPatterns = null
+      let relevantMemories = null
+      if (context.projectId) {
+        learnedPatterns = {
+          commit_footer: await memorySystem.getSmartDecision(context.projectId, 'commit_footer'),
+          branch_naming: await memorySystem.getSmartDecision(context.projectId, 'branch_naming'),
+          test_before_ship: await memorySystem.getSmartDecision(context.projectId, 'test_before_ship'),
+          preferred_agent: await memorySystem.getSmartDecision(context.projectId, `preferred_agent_${commandName}`)
+        }
+
+        // P3.3: Get relevant memories for context
+        relevantMemories = await memorySystem.getRelevantMemories(
+          context.projectId,
+          { commandName, params },
+          5 // Top 5 relevant memories
+        )
+      }
+
+      // 9. Build prompt with agent assignment, learned patterns, think blocks, memories, AND plan mode
+      const planInfo = {
+        isPlanning: requiresPlanning || isInPlanningMode,
+        requiresApproval: isDestructive && !params.approved,
+        active: activePlan,
+        allowedTools: planMode.getAllowedTools(
+          isInPlanningMode,
+          template.frontmatter['allowed-tools'] || []
+        )
+      }
+      const prompt = promptBuilder.build(template, context, state, assignedAgent, learnedPatterns, thinkBlock, relevantMemories, planInfo)
 
       // 8. Log agent usage
       if (assignedAgent) {
@@ -79,6 +264,9 @@ class CommandExecutor {
         console.log(`📉 Context reduced by: ${context.reduction}%`)
       }
 
+      // Record successful attempt
+      loopDetector.recordSuccess(commandName, loopContext)
+
       return {
         success: true,
         template,
@@ -86,12 +274,89 @@ class CommandExecutor {
         state,
         prompt,
         assignedAgent,
-        contextReduction: context.reduction
+        contextReduction: context.reduction,
+        reasoning, // Chain of thought results
+        thinkBlock, // Think blocks (P3.1)
+        groundTruth: groundTruthResult, // Ground truth verification (P1.3)
+        compressionMetrics: state._compressionMetrics,
+        learnedPatterns, // Memory system patterns
+        relevantMemories, // P3.3: Semantic memories
+        // Response formatter helper
+        formatResponse: (data) => responseTemplates.format(commandName, data),
+        // Think block formatter helper
+        formatThinkBlock: (verbose) => thinkBlocks.format(thinkBlock, verbose),
+        // P3.2: Parallel tools helper
+        parallel: {
+          execute: (toolCalls) => parallelTools.execute(toolCalls),
+          readAll: (paths) => parallelTools.readAll(paths),
+          canParallelize: (tools) => parallelTools.canParallelize(tools),
+          getMetrics: () => parallelTools.getMetrics()
+        },
+        // P3.3: Memory system helpers
+        memory: {
+          create: (memory) => memorySystem.createMemory(context.projectId, memory),
+          autoRemember: (type, value, ctx) => memorySystem.autoRemember(context.projectId, type, value, ctx),
+          search: (query) => memorySystem.searchMemories(context.projectId, query),
+          findByTags: (tags) => memorySystem.findByTags(context.projectId, tags),
+          getStats: () => memorySystem.getMemoryStats(context.projectId)
+        },
+        // P3.4: Plan Mode helpers
+        plan: {
+          active: activePlan,
+          isPlanning: requiresPlanning || isInPlanningMode,
+          isDestructive,
+          requiresApproval: isDestructive && !params.approved,
+          // Planning phase methods
+          recordInfo: (info) => planMode.recordGatheredInfo(context.projectId, info),
+          setAnalysis: (analysis) => planMode.setAnalysis(context.projectId, analysis),
+          propose: (plan) => planMode.proposePlan(context.projectId, plan),
+          // Approval methods
+          approve: (feedback) => planMode.approvePlan(context.projectId, feedback),
+          reject: (reason) => planMode.rejectPlan(context.projectId, reason),
+          getApprovalPrompt: () => planMode.generateApprovalPrompt(commandName, context),
+          // Execution methods
+          startExecution: () => planMode.startExecution(context.projectId),
+          getNextStep: () => planMode.getNextStep(context.projectId),
+          completeStep: (result) => planMode.completeStep(context.projectId, result),
+          failStep: (error) => planMode.failStep(context.projectId, error),
+          abort: (reason) => planMode.abortPlan(context.projectId, reason),
+          // Status
+          getStatus: () => planMode.formatStatus(context.projectId),
+          getAllowedTools: () => planMode.getAllowedTools(
+            isInPlanningMode,
+            template.frontmatter['allowed-tools'] || []
+          )
+        }
+        // P3.5, P3.6: DELEGATED TO CLAUDE CODE
+        // Use Claude Code's native tools instead:
+        // - Grep for semantic search
+        // - Glob for file patterns
+        // - Native LSP for code intelligence
       }
     } catch (error) {
+      // Record failed attempt for loop detection
+      const attemptInfo = loopDetector.recordAttempt(commandName, loopContext, {
+        success: false,
+        error: error.message
+      })
+
+      // Check if we should escalate after this failure
+      if (attemptInfo.shouldEscalate) {
+        const escalation = loopDetector.getEscalationInfo(commandName, loopContext)
+        return {
+          success: false,
+          error: escalation.message,
+          escalation,
+          isLoopDetected: true,
+          suggestion: escalation.suggestion
+        }
+      }
+
       return {
         success: false,
         error: error.message,
+        attemptNumber: attemptInfo.attemptNumber,
+        isLooping: attemptInfo.isLooping
       }
     }
   }
@@ -100,10 +365,27 @@ class CommandExecutor {
    * Check if command is task-related
    */
   isTaskCommand(commandName) {
-    const taskCommands = ['work', 'now', 'build', 'feature', 'bug', 'done']
+    const taskCommands = [
+      'work', 'now', 'build', 'feature', 'bug', 'done',
+      'task', 'design', 'cleanup', 'fix', 'test'
+    ]
     return taskCommands.includes(commandName)
   }
 
+  /**
+   * Determine if command should use an agent
+   * Expanded list of commands that benefit from agent specialization
+   */
+  shouldUseAgent(commandName) {
+    // Commands that should ALWAYS use agents
+    const agentCommands = [
+      'work', 'now', 'build', 'feature', 'bug', 'done',
+      'task', 'design', 'cleanup', 'fix', 'test',
+      'sync', 'analyze' // These analyze/modify code, need specialization
+    ]
+    return agentCommands.includes(commandName)
+  }
+
   /**
    * Execute tool with permission check
    * @param {string} toolName - Tool name

package/core/agentic/context-builder.js

@@ -2,6 +2,13 @@
  * Context Builder
  * Builds project context for Claude to make decisions
  * NO if/else logic - just data collection
+ *
+ * OPTIMIZATION (P0.1): Smart Context Caching
+ * - Parallel file reads with Promise.all()
+ * - Session-based caching to avoid redundant reads
+ * - Selective loading based on command needs
+ *
+ * Source: Windsurf, Cursor patterns
  */
 
 const fs = require('fs').promises
@@ -9,6 +16,28 @@ const pathManager = require('../infrastructure/path-manager')
 const configManager = require('../infrastructure/config-manager')
 
 class ContextBuilder {
+  constructor() {
+    // Session cache - cleared between commands or after timeout
+    this._cache = new Map()
+    // ANTI-HALLUCINATION: Reduced from 30s to 5s to prevent stale data
+    this._cacheTimeout = 5000 // 5 seconds (was 30s - caused stale context issues)
+    this._lastCacheTime = null
+    // Track file modification times for additional staleness detection
+    this._mtimes = new Map()
+  }
+
+  /**
+   * Clear cache if stale or force clear
+   * @param {boolean} force - Force clear regardless of timeout
+   */
+  _clearCacheIfStale(force = false) {
+    if (force || !this._lastCacheTime ||
+        Date.now() - this._lastCacheTime > this._cacheTimeout) {
+      this._cache.clear()
+      this._lastCacheTime = Date.now()
+    }
+  }
+
   /**
    * Build full project context for Claude
    * @param {string} projectPath - Local project path
@@ -34,7 +63,9 @@ class ContextBuilder {
         metrics: pathManager.getFilePath(projectId, 'progress', 'metrics.md'),
         ideas: pathManager.getFilePath(projectId, 'planning', 'ideas.md'),
         roadmap: pathManager.getFilePath(projectId, 'planning', 'roadmap.md'),
+        specs: pathManager.getFilePath(projectId, 'planning', 'specs'),
         memory: pathManager.getFilePath(projectId, 'memory', 'context.jsonl'),
+        patterns: pathManager.getFilePath(projectId, 'memory', 'patterns.json'),
         analysis: pathManager.getFilePath(projectId, 'analysis', 'repo-summary.md'),
       },
 
@@ -49,25 +80,182 @@ class ContextBuilder {
   }
 
   /**
-   * Load current project state
+   * Load current project state - PARALLEL VERSION
+   * Uses Promise.all() for 40-60% faster file I/O
+   *
    * @param {Object} context - Context from build()
+   * @param {string[]} onlyKeys - Optional: only load specific keys (selective loading)
    * @returns {Promise<Object>} Current state
    */
-  async loadState(context) {
+  async loadState(context, onlyKeys = null) {
+    this._clearCacheIfStale()
+
     const state = {}
+    const entries = Object.entries(context.paths)
+
+    // Filter to only requested keys if specified
+    const filteredEntries = onlyKeys
+      ? entries.filter(([key]) => onlyKeys.includes(key))
+      : entries
+
+    // ANTI-HALLUCINATION: Verify mtime before trusting cache
+    // Files can change between commands - stale cache causes hallucinations
+    for (const [, filePath] of filteredEntries) {
+      if (this._cache.has(filePath)) {
+        try {
+          const stat = await fs.stat(filePath)
+          const cachedMtime = this._mtimes.get(filePath)
+          if (!cachedMtime || stat.mtimeMs > cachedMtime) {
+            // File changed since cached - invalidate
+            this._cache.delete(filePath)
+            this._mtimes.delete(filePath)
+          }
+        } catch {
+          // File doesn't exist - invalidate cache
+          this._cache.delete(filePath)
+          this._mtimes.delete(filePath)
+        }
+      }
+    }
+
+    // Separate cached vs uncached files
+    const uncachedEntries = []
+    for (const [key, filePath] of filteredEntries) {
+      if (this._cache.has(filePath)) {
+        state[key] = this._cache.get(filePath)
+      } else {
+        uncachedEntries.push([key, filePath])
+      }
+    }
+
+    // PARALLEL READ: All uncached files at once
+    if (uncachedEntries.length > 0) {
+      const readPromises = uncachedEntries.map(async ([key, filePath]) => {
+        try {
+          const [content, stat] = await Promise.all([
+            fs.readFile(filePath, 'utf-8'),
+            fs.stat(filePath)
+          ])
+          return { key, filePath, content, mtime: stat.mtimeMs }
+        } catch {
+          return { key, filePath, content: null, mtime: null }
+        }
+      })
 
-    // Read all core files
-    for (const [key, filePath] of Object.entries(context.paths)) {
-      try {
-        state[key] = await fs.readFile(filePath, 'utf-8')
-      } catch {
-        state[key] = null
+      const results = await Promise.all(readPromises)
+
+      // Populate state and cache (with mtime for anti-hallucination)
+      for (const { key, filePath, content, mtime } of results) {
+        state[key] = content
+        this._cache.set(filePath, content)
+        if (mtime) {
+          this._mtimes.set(filePath, mtime)
+        }
       }
     }
 
     return state
   }
 
+  /**
+   * Load state for specific command - optimized selective loading
+   * Each command only loads what it needs
+   *
+   * @param {Object} context - Context from build()
+   * @param {string} commandName - Command name for selective loading
+   * @returns {Promise<Object>} Current state (filtered)
+   */
+  async loadStateForCommand(context, commandName) {
+    // Command-specific file requirements
+    // Minimizes context window usage
+    const commandFileMap = {
+      // Core workflow
+      'now': ['now', 'next'],
+      'done': ['now', 'next', 'metrics'],
+      'next': ['next'],
+
+      // Progress
+      'ship': ['now', 'shipped', 'metrics'],
+      'recap': ['shipped', 'metrics', 'now'],
+      'progress': ['shipped', 'metrics'],
+
+      // Planning
+      'idea': ['ideas', 'next'],
+      'feature': ['roadmap', 'next', 'ideas'],
+      'roadmap': ['roadmap'],
+      'spec': ['roadmap', 'next', 'specs'],
+
+      // Analysis
+      'analyze': ['analysis', 'context'],
+      'sync': ['analysis', 'context', 'now'],
+
+      // All files (fallback)
+      'default': null // null means load all
+    }
+
+    const requiredFiles = commandFileMap[commandName] || commandFileMap.default
+    return this.loadState(context, requiredFiles)
+  }
+
+  /**
+   * Batch read multiple files in parallel
+   * Utility for custom file sets
+   *
+   * @param {string[]} filePaths - Array of file paths
+   * @returns {Promise<Map<string, string|null>>} Map of path -> content
+   */
+  async batchRead(filePaths) {
+    this._clearCacheIfStale()
+
+    const results = new Map()
+    const uncachedPaths = []
+
+    // Check cache first
+    for (const filePath of filePaths) {
+      if (this._cache.has(filePath)) {
+        results.set(filePath, this._cache.get(filePath))
+      } else {
+        uncachedPaths.push(filePath)
+      }
+    }
+
+    // Parallel read uncached
+    if (uncachedPaths.length > 0) {
+      const readPromises = uncachedPaths.map(async (filePath) => {
+        try {
+          const content = await fs.readFile(filePath, 'utf-8')
+          return { filePath, content }
+        } catch {
+          return { filePath, content: null }
+        }
+      })
+
+      const readResults = await Promise.all(readPromises)
+
+      for (const { filePath, content } of readResults) {
+        results.set(filePath, content)
+        this._cache.set(filePath, content)
+      }
+    }
+
+    return results
+  }
+
+  /**
+   * Invalidate cache for specific file (after write)
+   * @param {string} filePath - File that was written
+   */
+  invalidateCache(filePath) {
+    this._cache.delete(filePath)
+  }
+
+  /**
+   * Force clear entire cache
+   */
+  clearCache() {
+    this._clearCacheIfStale(true)
+  }
+
   /**
    * Check file existence
    * @param {string} filePath - File path
@@ -81,6 +269,18 @@ class ContextBuilder {
       return false
     }
   }
+
+  /**
+   * Get cache stats (for debugging/metrics)
+   * @returns {Object} Cache statistics
+   */
+  getCacheStats() {
+    return {
+      size: this._cache.size,
+      lastRefresh: this._lastCacheTime,
+      timeout: this._cacheTimeout
+    }
+  }
 }
 
 module.exports = new ContextBuilder()