@metabob/minibob 0.1.2

package/src/goal-processor.ts

@@ -0,0 +1,654 @@
+/**
+ * Goal Processor - Core orchestrator for goal-driven activity execution
+ * 
+ * This module transforms user goals into activity executions:
+ * 1. Receive user goal message
+ * 2. Get activity recommendations from metabob-activity-api (Thompson Sampling)
+ * 3. Execute recommended activity
+ * 4. Check goal completion
+ * 5. Loop until goal is complete or max attempts reached
+ * 
+ * Architecture:
+ *   User goal → GoalProcessor → Backend recommendations → ActivityExecutor → Goal complete
+ * 
+ * Key principle: Backend (metabob-activity-api) handles activity recommendation
+ * based on historical execution data, success rates, and goal alignment.
+ */
+
+import type { ActivityExecution, Impulse } from "./types"
+import { ActivityExecutor, loadTemplateFromMCPOrLocal } from "./activity"
+import { getMCPClient, isMCPEnabled } from "./mcp"
+import { GoalImproviser } from "./improviser"
+
+// =============================================================================
+// TYPES
+// =============================================================================
+
+/**
+ * Structured goal representation
+ */
+export interface Goal {
+  /** Original user message */
+  message: string
+  /** Goal type inferred from message */
+  type: "feature" | "bugfix" | "refactor" | "exploration" | "other"
+  /** Parsed intent (what user wants to accomplish) */
+  intent: string
+  /** Context from user (files, variables, etc.) */
+  context: Record<string, unknown>
+  /** Created timestamp */
+  createdAt: number
+}
+
+/**
+ * Activity recommendation from backend
+ */
+export interface ActivityRecommendation {
+  /** Template ID to execute */
+  templateId: string
+  /** Selection metadata from backend (Thompson Sampling) */
+  selectionMetadata: {
+    method: string
+    alpha?: number
+    beta?: number
+    sample?: number
+    score?: number
+  }
+  /** Suggested variables for execution (derived from goal context) */
+  variables: Record<string, unknown>
+}
+
+/**
+ * Goal execution result
+ */
+export interface GoalResult {
+  /** Goal that was executed */
+  goal: Goal
+  /** Activities executed during goal pursuit */
+  executions: ActivityExecution[]
+  /** Whether goal was completed */
+  completed: boolean
+  /** Completion reason */
+  completionReason: string
+  /** Total duration in milliseconds */
+  totalDuration: number
+  /** Total cost in dollars */
+  totalCost: number
+  /** Total tokens used */
+  totalTokens: {
+    input: number
+    output: number
+  }
+}
+
+// =============================================================================
+// GOAL PROCESSOR
+// =============================================================================
+
+export class GoalProcessor {
+  private readonly workingDirectory: string
+  private readonly executor: ActivityExecutor
+
+  constructor(config: {
+    workingDirectory: string
+    executor: ActivityExecutor
+  }) {
+    this.workingDirectory = config.workingDirectory
+    this.executor = config.executor
+  }
+
+  /**
+   * Parse user goal message into structured Goal
+   * 
+   * For now, simple parsing. Can be enhanced with LLM later.
+   */
+  parseGoal(message: string, context?: Record<string, unknown>): Goal {
+    // Simple type inference from keywords
+    let type: Goal["type"] = "other"
+    const lowerMessage = message.toLowerCase()
+    
+    if (lowerMessage.includes("add") || lowerMessage.includes("create") || lowerMessage.includes("implement")) {
+      type = "feature"
+    } else if (lowerMessage.includes("fix") || lowerMessage.includes("bug") || lowerMessage.includes("error")) {
+      type = "bugfix"
+    } else if (lowerMessage.includes("refactor") || lowerMessage.includes("clean") || lowerMessage.includes("reorganize")) {
+      type = "refactor"
+    }
+
+    return {
+      message,
+      type,
+      intent: message, // For now, intent = message
+      context: context || {},
+      createdAt: Date.now(),
+    }
+  }
+
+  /**
+   * Get activity recommendations from backend API
+   * 
+   * NOTE: This is a placeholder. In the real implementation, this will be called
+   * by opencode's MinibobIntegration which has access to MetabobCLI.recommendActivities().
+   * 
+   * The backend recommendation engine:
+   * - Applies Thompson Sampling for exploration/exploitation
+   * - Considers historical execution success rates
+   * - Aligns recommendations with goal category
+   * - Uses impulse state for context-aware recommendations
+   * 
+   * @param goal - Parsed goal
+   * @param loadedImpulseIds - IDs of currently loaded impulses
+   * @param limit - Max recommendations to return
+   * @returns Array of activity recommendations from backend
+   */
+  async getRecommendations(
+    goal: Goal,
+    loadedImpulseIds: string[] = [],
+    limit: number = 3
+  ): Promise<ActivityRecommendation[]> {
+    // Get recommendations from MCP backend using Thompson Sampling
+    const mcpClient = getMCPClient()
+    
+    if (!mcpClient) {
+      console.warn("[GoalProcessor] No MCP client available - cannot get recommendations")
+      console.warn("[GoalProcessor] Set MINIBOB_MCP_ENDPOINT environment variable or call initializeMCP()")
+      return []
+    }
+    
+    console.log(`[GoalProcessor] Requesting ${limit} recommendations from backend`)
+    console.log(`[GoalProcessor] Goal intent: ${goal.intent}`)
+    console.log(`[GoalProcessor] Goal type: ${goal.type}`)
+    
+    try {
+      const recommendations = await mcpClient.recommendActivities(
+        goal.intent,
+        goal.type !== 'other' ? goal.type : undefined,
+        loadedImpulseIds,
+        limit
+      )
+      
+      console.log(`[GoalProcessor] Received ${recommendations.length} recommendations from backend`)
+      
+      // Transform backend format to ActivityRecommendation
+      return recommendations.map(rec => ({
+        templateId: rec.template_id,
+        selectionMetadata: rec.selection_metadata || { method: 'thompson_sampling' },
+        variables: goal.context || {} // Use goal context as variable suggestions
+      }))
+    } catch (err) {
+      console.error("[GoalProcessor] Failed to get recommendations:", err instanceof Error ? err.message : String(err))
+      return []
+    }
+  }
+
+  /**
+   * Assess relevance of a recommendation to the goal
+   *
+   * Uses simple keyword matching and semantic similarity to determine if
+   * the recommended activity is likely to help achieve the goal.
+   *
+   * @param goal - The goal being pursued
+   * @param recommendation - The activity recommendation
+   * @returns Relevance score from 0.0 (not relevant) to 1.0 (highly relevant)
+   */
+  private assessRelevance(goal: Goal, recommendation: ActivityRecommendation): number {
+    const templateId = recommendation.templateId.toLowerCase()
+    const goalIntent = goal.intent.toLowerCase()
+    const goalType = goal.type.toLowerCase()
+
+    // Extract key terms from goal
+    const goalTerms = goalIntent.split(/\s+/).filter(term => term.length > 3)
+
+    // Check for type alignment
+    let score = 0.0
+
+    // Type match gives base score
+    if (templateId.includes(goalType) || templateId.includes(goal.type)) {
+      score += 0.3
+    }
+
+    // Keyword overlap
+    const matchedTerms = goalTerms.filter(term => templateId.includes(term))
+    if (matchedTerms.length > 0) {
+      score += 0.3 * (matchedTerms.length / Math.max(goalTerms.length, 1))
+    }
+
+    // Special patterns
+    if (goal.type === 'bugfix' && templateId.includes('fix')) score += 0.2
+    if (goal.type === 'bugfix' && templateId.includes('debug')) score += 0.2
+    if (goal.type === 'feature' && templateId.includes('add')) score += 0.2
+    if (goal.type === 'feature' && templateId.includes('implement')) score += 0.2
+    if (goal.type === 'refactor' && templateId.includes('refactor')) score += 0.2
+    if (goal.type === 'refactor' && templateId.includes('optimize')) score += 0.2
+
+    // Generic templates are less relevant (lower priority)
+    if (templateId.includes('generic') || templateId.includes('default')) {
+      score *= 0.7
+    }
+
+    return Math.min(score, 1.0)
+  }
+
+  /**
+   * Check if goal is complete based on executions
+   * 
+   * With optional goal verification:
+   * - If last activity succeeded AND goal provided, verify achievement objectively
+   * - If last activity failed, goal is incomplete
+   * - Without goal, uses simple status check (backward compatibility)
+   * 
+   * @param executions - Activity executions performed
+   * @param goal - Optional goal for objective verification
+   * @returns Completion status with reason
+   */
+  isGoalComplete(executions: ActivityExecution[], goal?: Goal): { complete: boolean; reason: string } {
+    if (executions.length === 0) {
+      return { complete: false, reason: "No activities executed yet" }
+    }
+
+    const lastExecution = executions[executions.length - 1]
+    if (!lastExecution) {
+      return { complete: false, reason: "No execution data available" }
+    }
+    
+    if (lastExecution.status === "failed") {
+      return { complete: false, reason: "Last activity failed" }
+    }
+
+    if (lastExecution.status === "completed") {
+      // With goal provided, verify achievement objectively
+      if (goal) {
+        const verification = this.verifyGoalAchievement(goal, executions)
+        if (!verification.verified) {
+          console.warn("[GoalProcessor] Activity succeeded but goal not achieved:", verification.reason)
+          return { complete: false, reason: `Activity succeeded but goal not achieved: ${verification.reason}` }
+        }
+        return { complete: true, reason: verification.reason }
+      }
+      // Backward compatibility: without goal, trust activity status
+      return { complete: true, reason: "Activity completed successfully" }
+    }
+
+    return { complete: false, reason: "Activity still in progress" }
+  }
+
+  /**
+   * Verify goal was actually achieved using objective criteria
+   * Prevents LLM hallucination where activity claims success but did nothing
+   * 
+   * @param goal - The goal being evaluated
+   * @param executions - Activity executions performed
+   * @returns Verification result with reason
+   */
+  private verifyGoalAchievement(goal: Goal, executions: ActivityExecution[]): { verified: boolean; reason: string } {
+    // File modification goals
+    if (goal.intent.match(/change|modify|edit|update|replace/i)) {
+      const filesModified = executions.reduce((sum, exec) => 
+        sum + (exec.executionTrace?.filesModified.length || 0), 0
+      )
+      if (filesModified === 0) {
+        return { verified: false, reason: "No files were modified" }
+      }
+      return { verified: true, reason: `Verified: ${filesModified} file(s) modified` }
+    }
+    
+    // Test execution goals
+    if (goal.intent.match(/test/i)) {
+      const hasTestOutput = executions.some(exec => 
+        exec.taskResults?.some(tr => tr.output?.toLowerCase().includes('test'))
+      )
+      if (!hasTestOutput) {
+        return { verified: false, reason: "No test execution detected" }
+      }
+      return { verified: true, reason: "Verified: Tests executed" }
+    }
+    
+    // Code creation goals
+    if (goal.intent.match(/create|add|implement|write/i)) {
+      const filesModified = executions.reduce((sum, exec) => 
+        sum + (exec.executionTrace?.filesModified.length || 0), 0
+      )
+      if (filesModified === 0) {
+        return { verified: false, reason: "No files created or modified" }
+      }
+      return { verified: true, reason: `Verified: ${filesModified} file(s) modified` }
+    }
+    
+    // Analysis/exploration goals
+    if (goal.intent.match(/analyze|explore|find|search/i)) {
+      const toolsUsed = executions.reduce((sum, exec) => {
+        const taskToolCalls = exec.taskResults?.reduce((taskSum, tr) => 
+          taskSum + (tr.metadata?.toolCalls?.length || 0), 0
+        ) || 0
+        return sum + taskToolCalls
+      }, 0)
+      if (toolsUsed === 0) {
+        return { verified: false, reason: "No tools were used" }
+      }
+      return { verified: true, reason: `Verified: ${toolsUsed} tool call(s)` }
+    }
+    
+    // Default: require measurable work
+    const filesModified = executions.reduce((sum, exec) => 
+      sum + (exec.executionTrace?.filesModified.length || 0), 0
+    )
+    const toolsUsed = executions.reduce((sum, exec) => {
+      const taskToolCalls = exec.taskResults?.reduce((taskSum, tr) => 
+        taskSum + (tr.metadata?.toolCalls?.length || 0), 0
+      ) || 0
+      return sum + taskToolCalls
+    }, 0)
+    
+    if (filesModified === 0 && toolsUsed === 0) {
+      console.warn("[GoalProcessor] No verifiable work detected for goal:", goal.intent)
+      return { verified: false, reason: "No files modified and no tools used" }
+    }
+    
+    return { verified: true, reason: "Activity completed with measurable outcomes" }
+  }
+
+  /**
+   * Create impulses from execution output for context propagation
+   */
+  private createImpulsesFromExecution(execution: ActivityExecution): Impulse[] {
+    const impulses: Impulse[] = []
+    const timestamp = Date.now()
+
+    // Create impulse for overall execution trace
+    impulses.push({
+      id: `impulse:trace:${execution.id}`,
+      pointer: {
+        type: 'activityExecutionTrace',
+        executionId: execution.id,
+      },
+      budget: 4000,  // Generous budget for execution context
+      priority: 'high',
+      loaded: false,
+      createdAt: timestamp,
+      tags: ['execution-output', execution.templateId],
+    })
+
+    // Create impulses for individual task outputs (if they have significant output)
+    execution.taskResults?.forEach((taskResult, index) => {
+      if (taskResult.output && taskResult.output.length > 100) {
+        impulses.push({
+          id: `impulse:output:${execution.id}:${taskResult.taskId}`,
+          pointer: {
+            type: 'activityOutput',
+            activityId: execution.id,
+            taskId: taskResult.taskId,
+          },
+          budget: 2000,
+          priority: 'medium',
+          loaded: false,
+          createdAt: timestamp,
+          tags: ['task-output', execution.templateId],
+        })
+      }
+    })
+
+    // Create impulses for modified files
+    execution.executionTrace?.filesModified?.forEach((filePath, index) => {
+      // Only create file impulses for the first few files to avoid context bloat
+      if (index < 3) {
+        impulses.push({
+          id: `impulse:file:${execution.id}:${index}`,
+          pointer: {
+            type: 'file',
+            path: filePath,
+          },
+          budget: 3000,
+          priority: 'medium',
+          loaded: false,
+          createdAt: timestamp,
+          tags: ['modified-file', filePath],
+        })
+      }
+    })
+
+    return impulses
+  }
+
+  /**
+   * Execute goal-seeking process
+   *
+   * Main loop:
+   * 1. Parse goal
+   * 2. Get recommendations from backend (Thompson Sampling)
+   * 3. Execute top-ranked activity with context from previous steps
+   * 4. Create impulses from execution output
+   * 5. Check completion
+   * 6. Repeat until complete or max attempts
+   *
+   * @param message - User goal message
+   * @param context - Additional context (files, variables, etc.)
+   * @param options - Execution options
+   * @returns Goal execution result
+   */
+  async executeGoal(
+    message: string,
+    context?: Record<string, unknown>,
+    options?: {
+      maxActivities?: number
+      maxCost?: number
+    }
+  ): Promise<GoalResult> {
+    const maxActivities = options?.maxActivities || 5
+    const maxCost = options?.maxCost || 10.0
+
+    const startTime = Date.now()
+    const executions: ActivityExecution[] = []
+    const accumulatedImpulses: Impulse[] = []  // Accumulate context across iterations
+    let totalCost = 0
+    let totalTokens = { input: 0, output: 0 }
+
+    // Parse goal
+    const goal = this.parseGoal(message, context)
+
+    console.log(`[GoalProcessor] Starting goal execution: ${goal.intent}`)
+    console.log(`[GoalProcessor] Goal type: ${goal.type}`)
+
+    // Execute activities until goal complete or limits reached
+    for (let i = 0; i < maxActivities; i++) {
+      console.log(`[GoalProcessor] Activity iteration ${i + 1}/${maxActivities}`)
+      console.log(`[GoalProcessor] Context: ${accumulatedImpulses.length} impulses from previous executions`)
+
+      // Get impulse IDs for context-aware recommendations
+      const impulseIds = accumulatedImpulses.map(imp => imp.id)
+
+      // Get recommendations from backend (with context from previous executions)
+      const recommendations = await this.getRecommendations(goal, impulseIds, 3)
+      
+      if (recommendations.length === 0) {
+        console.warn("[GoalProcessor] No recommendations from backend, stopping")
+        break
+      }
+
+      console.log(`[GoalProcessor] Received ${recommendations.length} recommendations from backend`)
+
+      // Execute top recommendation (backend already ranked them)
+      const topRecommendation = recommendations[0]
+      if (!topRecommendation) {
+        console.warn("[GoalProcessor] No valid recommendation, stopping")
+        break
+      }
+
+      // Assess relevance of top recommendation
+      const relevanceScore = this.assessRelevance(goal, topRecommendation)
+      const RELEVANCE_THRESHOLD = 0.3 // Require at least 30% relevance
+
+      console.log(`[GoalProcessor] Top recommendation: ${topRecommendation.templateId}`)
+      console.log(`[GoalProcessor] Relevance score: ${relevanceScore.toFixed(2)}`)
+
+      let execution: ActivityExecution
+
+      if (relevanceScore < RELEVANCE_THRESHOLD) {
+        console.log(`[GoalProcessor] Relevance too low (${relevanceScore.toFixed(2)} < ${RELEVANCE_THRESHOLD})`)
+        console.log(`[GoalProcessor] Falling back to improvisation`)
+
+        // Improvise instead of using irrelevant template
+        const improviser = new GoalImproviser({
+          workingDirectory: this.workingDirectory,
+        })
+
+        const improvResult = await improviser.improvise(goal.intent, {
+          maxSteps: 10,
+        })
+
+        // Convert improvisation result to ActivityExecution
+        // The improviser already stores the trace via MCP
+        execution = {
+          id: improvResult.execution_id,
+          templateId: `improvised-${goal.type}`,
+          status: improvResult.outcome.status === 'success' ? 'completed' : 'failed',
+          variables: {},
+          impulses: [],
+          taskResults: improvResult.steps.map(step => ({
+            taskId: `step-${step.step}`,
+            status: step.result.success ? 'completed' : 'failed',
+            output: step.result.output,
+            error: step.result.error,
+          })),
+          startedAt: Date.parse(improvResult.started_at),
+          completedAt: improvResult.completed_at ? Date.parse(improvResult.completed_at) : undefined,
+          error: improvResult.outcome.error,
+          executionTrace: {
+            tasks: improvResult.steps.map(step => ({
+              id: `step-${step.step}`,
+              description: step.thought,
+              actualPrompt: step.thought,
+              toolCalls: [{
+                id: `tool:${step.action}:step-${step.step}:${Date.now()}`,
+                name: step.action,
+                arguments: step.params,
+                result: {
+                  success: step.result.success,
+                  output: step.result.output,
+                  error: step.result.error,
+                },
+              }],
+              response: step.result.output || step.result.error || '',
+              result: {
+                status: step.result.success ? 'success' : 'failure',
+                error: step.result.error,
+              },
+              inputState: {
+                filesAvailable: [],
+                environment: {},
+                impulses: [],
+                variables: {},
+              },
+              outputState: {
+                filesModified: [
+                  ...(improvResult.outcome.files_modified || []),
+                  ...(improvResult.outcome.files_created || []),
+                ],
+                filesCreated: improvResult.outcome.files_created || [],
+                filesDeleted: improvResult.outcome.files_deleted || [],
+              },
+            })),
+            filesModified: [
+              ...(improvResult.outcome.files_modified || []),
+              ...(improvResult.outcome.files_created || []),
+            ],
+            impulsesCreated: [],
+          },
+          metrics: {
+            duration: 0, // Improviser doesn't track per-step duration
+            cost: 0, // Will be calculated from tokens
+            totalTokens: {
+              input: 0,
+              output: 0,
+            },
+          },
+        }
+
+        console.log(`[GoalProcessor] Improvisation ${execution.status}: ${execution.id}`)
+        console.log(`[GoalProcessor] Note: Ribosome will extract template from successful improvisation`)
+      } else {
+        console.log(`[GoalProcessor] Relevance acceptable (${relevanceScore.toFixed(2)} >= ${RELEVANCE_THRESHOLD})`)
+        console.log(`[GoalProcessor] Executing template: ${topRecommendation.templateId}`)
+
+        // Load template
+        const template = await loadTemplateFromMCPOrLocal(topRecommendation.templateId)
+        if (!template) {
+          console.warn(`[GoalProcessor] Template not found: ${topRecommendation.templateId}, trying next`)
+          continue
+        }
+
+        // Execute activity with template and accumulated context
+        execution = await this.executor.execute({
+          template,
+          variables: topRecommendation.variables,
+          impulses: accumulatedImpulses,  // Pass context from previous executions
+          reason: `Goal: ${goal.intent}`,
+        })
+      }
+
+      executions.push(execution)
+
+      console.log(`[GoalProcessor] Activity ${execution.id} completed with status: ${execution.status}`)
+
+      // Create impulses from execution output for next iteration
+      const newImpulses = this.createImpulsesFromExecution(execution)
+      accumulatedImpulses.push(...newImpulses)
+      console.log(`[GoalProcessor] Created ${newImpulses.length} impulses from execution output`)
+
+      // Track costs
+      if (execution.metrics) {
+        totalCost += execution.metrics.cost
+        totalTokens.input += execution.metrics.totalTokens.input
+        totalTokens.output += execution.metrics.totalTokens.output
+        // Note: minibob metrics doesn't have cache field yet
+      }
+
+      console.log(`[GoalProcessor] Total cost so far: $${totalCost.toFixed(4)}`)
+
+      // Check cost limit
+      if (totalCost > maxCost) {
+        console.warn(`[GoalProcessor] Cost limit exceeded ($${maxCost})`)
+        return {
+          goal,
+          executions,
+          completed: false,
+          completionReason: `Cost limit exceeded ($${maxCost})`,
+          totalDuration: Date.now() - startTime,
+          totalCost,
+          totalTokens,
+        }
+      }
+
+      // Check goal completion
+      const { complete, reason } = this.isGoalComplete(executions, goal)
+      
+      console.log(`[GoalProcessor] Goal complete check: ${complete} - ${reason}`)
+      
+      if (complete) {
+        return {
+          goal,
+          executions,
+          completed: true,
+          completionReason: reason,
+          totalDuration: Date.now() - startTime,
+          totalCost,
+          totalTokens,
+        }
+      }
+    }
+
+    // Max activities reached
+    const { complete, reason } = this.isGoalComplete(executions, goal)
+    
+    console.log(`[GoalProcessor] Reached max activities (${maxActivities})`)
+    
+    return {
+      goal,
+      executions,
+      completed: complete,
+      completionReason: complete ? reason : `Max activities (${maxActivities}) reached`,
+      totalDuration: Date.now() - startTime,
+      totalCost,
+      totalTokens,
+    }
+  }
+}