@metabob/minibob 0.1.2

package/src/improviser.ts

@@ -0,0 +1,591 @@
+/**
+ * Goal Improviser - Execute goals without templates
+ *
+ * Pure improvisation: LLM figures out what to do step by step,
+ * using available tools. Everything is recorded for template extraction.
+ */
+
+import type { LLMClient } from './llm'
+import type { ToolHandler, ToolResult, Message, ActivityExecution, TaskResult } from './types'
+import { createLLMClient } from './llm'
+import { createToolHandlers } from './tools'
+
+// ============================================================================
+// TYPES
+// ============================================================================
+
+export interface ImprovisationStep {
+  step: number
+  thought: string              // LLM's reasoning about what to do
+  action: string               // Tool name to use
+  params: Record<string, unknown>
+  result: ToolResult
+  duration_ms: number
+  timestamp: string
+  cost_estimate: number        // Tokens used this step
+}
+
+export interface ImprovisationTrace {
+  execution_id: string
+  goal: string
+  improvisation: true
+  context?: Record<string, unknown>
+  started_at: string
+  completed_at?: string
+  steps: ImprovisationStep[]
+  outcome: {
+    status: 'success' | 'failure' | 'stuck'
+    goal_achieved: boolean
+    total_duration_ms: number
+    total_cost: number
+    total_tokens: {
+      input: number
+      output: number
+    }
+    files_modified: string[]
+    files_created: string[]
+    files_deleted: string[]
+    error?: string
+  }
+}
+
+export interface ImprovisationConfig {
+  maxSteps?: number           // Max steps before giving up (default: 50)
+  temperature?: number        // LLM temperature for creativity (default: 0.7)
+  stuckThreshold?: number     // Same action repeated N times = stuck (default: 3)
+  saveTrace?: boolean         // Save to backend (default: true)
+}
+
+// ============================================================================
+// IMPROVISER
+// ============================================================================
+
+export interface ImproviserConfig {
+  provider?: string
+  apiKey?: string
+  model?: string
+  workingDirectory: string
+}
+
+export class GoalImproviser {
+  private llm: LLMClient
+  private tools: Record<string, ToolHandler>
+  private config: ImproviserConfig
+
+  constructor(config: ImproviserConfig) {
+    this.config = config
+    const provider = (config.provider || 'anthropic') as 'anthropic' | 'openai'
+    const apiKey = config.apiKey || process.env.ANTHROPIC_API_KEY || ''
+    this.llm = createLLMClient(provider, apiKey)
+    this.tools = createToolHandlers({
+      workingDirectory: config.workingDirectory
+    })
+  }
+
+  /**
+   * Improvise solution to a goal without pre-defined template
+   */
+  async improvise(
+    goal: string,
+    config: ImprovisationConfig = {}
+  ): Promise<ImprovisationTrace> {
+
+    const {
+      maxSteps = 50,
+      temperature = 0.7,
+      stuckThreshold = 3,
+      saveTrace = true
+    } = config
+
+    console.log(`[Improviser] Starting improvisation for goal: ${goal} (max ${maxSteps} steps)`)
+
+    // Initialize trace
+    const trace: ImprovisationTrace = {
+      execution_id: `exec_improv_${Date.now()}_${this.randomId()}`,
+      goal,
+      improvisation: true,
+      started_at: new Date().toISOString(),
+      steps: [],
+      outcome: {
+        status: 'success',
+        goal_achieved: false,
+        total_duration_ms: 0,
+        total_cost: 0,
+        total_tokens: { input: 0, output: 0 },
+        files_modified: [],
+        files_created: [],
+        files_deleted: []
+      }
+    }
+
+    const startTime = Date.now()
+    const messages: Message[] = []
+
+    // System prompt for improvisation
+    messages.push({
+      role: 'system',
+      content: this.buildSystemPrompt(goal)
+    })
+
+    // Initial user message
+    messages.push({
+      role: 'user',
+      content: 'Start working toward the goal. What should you do first?'
+    })
+
+    let stepNumber = 0
+    let goalAchieved = false
+    const maxRetriesPerStep = 3
+
+    // Improvise step by step
+    while (!goalAchieved && stepNumber < maxSteps) {
+      stepNumber++
+      const stepStartTime = Date.now()
+      let retryCount = 0
+      let decision: any = null
+      let lastResponse: any = null
+
+      // Retry loop for JSON parse errors
+      while (retryCount <= maxRetriesPerStep && !decision) {
+        try {
+          // Get LLM decision
+          console.log(`[Improviser] Step ${stepNumber}: Requesting LLM decision${retryCount > 0 ? ` (retry ${retryCount}/${maxRetriesPerStep})` : ''}`)
+
+          lastResponse = await this.llm.complete({
+            model: this.config.model || 'claude-sonnet-4-20250514',
+            messages,
+            temperature,
+            maxTokens: 2000
+          })
+
+          // Parse decision (LLM should output structured JSON)
+          try {
+            decision = this.parseDecision(lastResponse.content)
+            // Successfully parsed - will break the while loop
+          } catch (parseError) {
+            // If JSON parse error and we have retries left, provide detailed feedback
+            if (parseError instanceof SyntaxError && retryCount < maxRetriesPerStep) {
+              const errorDetails = this.formatJSONParseError(parseError, lastResponse.content)
+              console.warn(`[Improviser] JSON parse error on step ${stepNumber}, retry ${retryCount + 1}/${maxRetriesPerStep}`)
+              console.warn(`[Improviser] Error: ${errorDetails}`)
+
+              // Add error feedback to messages and retry
+              messages.push({
+                role: 'assistant',
+                content: lastResponse.content
+              })
+              messages.push({
+                role: 'user',
+                content: `Your JSON output has a syntax error. Please fix it and try again.
+
+${errorDetails}
+
+Remember the correct format:
+{
+  "thought": "your reasoning",
+  "action": "tool_name",
+  "params": { ... },
+  "goal_achieved": true/false
+}
+
+Please output the corrected JSON now.`
+              })
+
+              retryCount++
+              continue // Retry the LLM call
+            }
+
+            // Out of retries or different error type
+            throw parseError
+          }
+        } catch (error) {
+          // If we've exhausted retries, throw the error up
+          if (retryCount >= maxRetriesPerStep) {
+            throw error
+          }
+        }
+      }
+
+      // At this point we have a valid decision
+      if (!decision) {
+        throw new Error('Failed to get valid decision after retries')
+      }
+
+      try {
+
+        console.log(`[Improviser] Step ${stepNumber}: ${decision.action} - ${decision.thought}`)
+
+        // Execute the action
+        const toolHandler = this.tools[decision.action]
+        if (!toolHandler) {
+          throw new Error(`Unknown tool: ${decision.action}`)
+        }
+
+        const toolResult = await toolHandler(decision.params)
+
+        // Record step
+        const step: ImprovisationStep = {
+          step: stepNumber,
+          thought: decision.thought,
+          action: decision.action,
+          params: decision.params,
+          result: toolResult,
+          duration_ms: Date.now() - stepStartTime,
+          timestamp: new Date().toISOString(),
+          cost_estimate: this.estimateCost(lastResponse)
+        }
+        trace.steps.push(step)
+
+        // Update conversation history
+        messages.push({
+          role: 'assistant',
+          content: JSON.stringify({
+            thought: decision.thought,
+            action: decision.action,
+            params: decision.params
+          })
+        })
+
+        messages.push({
+          role: 'user',
+          content: this.formatToolResult(toolResult, decision.action)
+        })
+
+        // Check if goal achieved
+        goalAchieved = decision.goal_achieved || false
+
+        if (goalAchieved) {
+          console.log(`[Improviser] Goal achieved at step ${stepNumber}!`)
+          break
+        }
+
+        // Check if stuck
+        if (this.isStuck(trace.steps, stuckThreshold)) {
+          console.warn(`[Improviser] Appears stuck - repeated action: ${trace.steps.slice(-1)[0]?.action}`)
+          trace.outcome.status = 'stuck'
+          trace.outcome.error = 'Repeated same action too many times'
+          break
+        }
+
+      } catch (error) {
+        console.error(`[Improviser] Step ${stepNumber} failed:`, error instanceof Error ? error.message : String(error))
+
+        // Add error to conversation so LLM can recover
+        messages.push({
+          role: 'user',
+          content: `Error occurred: ${error instanceof Error ? error.message : String(error)}\nHow can you recover?`
+        })
+      }
+    }
+
+    // Finalize trace
+    trace.completed_at = new Date().toISOString()
+    trace.outcome.total_duration_ms = Date.now() - startTime
+    trace.outcome.goal_achieved = goalAchieved
+    trace.outcome.status = goalAchieved ? 'success' : (trace.outcome.status || 'failure')
+
+    // Extract file changes
+    trace.outcome.files_modified = this.extractFilesModified(trace.steps)
+    trace.outcome.files_created = this.extractFilesCreated(trace.steps)
+    trace.outcome.files_deleted = this.extractFilesDeleted(trace.steps)
+
+    // Calculate totals
+    trace.outcome.total_cost = trace.steps.reduce((sum, s) => sum + s.cost_estimate, 0)
+
+    console.log(`[Improviser] Complete: ${trace.execution_id} - ${trace.outcome.goal_achieved ? 'SUCCESS' : 'FAILED'} (${trace.steps.length} steps, ${trace.outcome.total_duration_ms}ms, $${trace.outcome.total_cost.toFixed(4)})`)
+
+    // Save trace if configured
+    if (saveTrace) {
+      await this.saveTrace(trace)
+    }
+
+    return trace
+  }
+
+  // ==========================================================================
+  // HELPER METHODS
+  // ==========================================================================
+
+  private buildSystemPrompt(goal: string): string {
+    return `You are MiniBob, an autonomous agent that achieves goals through improvisation.
+
+GOAL: ${goal}
+
+You have access to these tools:
+- bash: Execute shell commands
+- read: Read file contents
+- write: Create new files
+- edit: Modify existing files
+- git: Git operations
+
+Your approach:
+1. Think about what to do next (reasoning)
+2. Choose a tool and parameters
+3. Execute the action
+4. Observe the result
+5. Decide if goal is achieved or continue
+
+IMPORTANT OUTPUT FORMAT:
+After reasoning, output ONLY valid JSON in this format:
+{
+  "thought": "your reasoning about what to do and why",
+  "action": "tool_name",
+  "params": { "param1": "value1", ... },
+  "goal_achieved": true/false
+}
+
+Start by understanding the current state, then work systematically toward the goal.
+Take concrete actions - don't just plan, actually do things.`
+  }
+
+  private formatJSONParseError(error: SyntaxError, content: string): string {
+    const errorMessage = error.message
+
+    // Extract JSON from content
+    const jsonMatch = content.match(/\{[\s\S]*\}/)
+    if (!jsonMatch) {
+      return `No JSON object found in output. Make sure to output a valid JSON object.`
+    }
+
+    const jsonStr = jsonMatch[0]
+
+    // Try to extract position information from error message
+    const positionMatch = errorMessage.match(/position (\d+)/)
+    if (positionMatch && positionMatch[1]) {
+      const position = parseInt(positionMatch[1], 10)
+      const before = jsonStr.substring(Math.max(0, position - 50), position)
+      const after = jsonStr.substring(position, Math.min(jsonStr.length, position + 50))
+
+      return `JSON Syntax Error: ${errorMessage}
+
+Context around error position ${position}:
+...${before}⚠️HERE⚠️${after}...
+
+The JSON you generated:
+${jsonStr.substring(0, 500)}${jsonStr.length > 500 ? '...' : ''}
+
+Common issues:
+- Unterminated strings (missing closing quote)
+- Unescaped quotes inside strings (use \\" instead of ")
+- Unescaped newlines in strings (use \\n)
+- Missing commas between fields
+- Trailing commas before closing braces`
+    }
+
+    // If no position info, provide general feedback
+    return `JSON Syntax Error: ${errorMessage}
+
+The JSON you generated:
+${jsonStr.substring(0, 500)}${jsonStr.length > 500 ? '...' : ''}
+
+Common issues:
+- Unterminated strings (missing closing quote)
+- Unescaped quotes inside strings (use \\" instead of ")
+- Unescaped newlines in strings (use \\n)
+- Missing commas between fields
+- Trailing commas before closing braces
+- Make sure all strings are properly quoted`
+  }
+
+  private parseDecision(content: string): {
+    thought: string
+    action: string
+    params: Record<string, unknown>
+    goal_achieved: boolean
+  } {
+    // Extract JSON from content (may have markdown formatting)
+    const jsonMatch = content.match(/\{[\s\S]*\}/)
+    if (!jsonMatch) {
+      throw new Error('LLM did not return valid JSON')
+    }
+
+    const decision = JSON.parse(jsonMatch[0])
+
+    if (!decision.thought || !decision.action) {
+      throw new Error('Decision missing required fields')
+    }
+
+    return {
+      thought: decision.thought,
+      action: decision.action,
+      params: decision.params || {},
+      goal_achieved: decision.goal_achieved || false
+    }
+  }
+
+  private formatToolResult(result: ToolResult, action: string): string {
+    return `Tool ${action} result:
+Success: ${result.success}
+${result.output ? `Output:\n${result.output}` : ''}
+${result.error ? `Error:\n${result.error}` : ''}
+
+What should you do next?`
+  }
+
+  private isStuck(steps: ImprovisationStep[], threshold: number): boolean {
+    if (steps.length < threshold) return false
+
+    const lastN = steps.slice(-threshold)
+    const actions = lastN.map(s => s.action)
+
+    // Stuck if all last N actions are the same
+    return actions.every(a => a === actions[0])
+  }
+
+  private extractFilesModified(steps: ImprovisationStep[]): string[] {
+    return [...new Set(
+      steps
+        .filter(s => s.action === 'edit' && s.result.success)
+        .map(s => s.params.path as string)
+        .filter(Boolean)
+    )]
+  }
+
+  private extractFilesCreated(steps: ImprovisationStep[]): string[] {
+    return [...new Set(
+      steps
+        .filter(s => s.action === 'write' && s.result.success)
+        .map(s => s.params.path as string)
+        .filter(Boolean)
+    )]
+  }
+
+  private extractFilesDeleted(steps: ImprovisationStep[]): string[] {
+    return [...new Set(
+      steps
+        .filter(s => s.action === 'bash' && s.params.command?.toString().includes('rm '))
+        .map(s => {
+          // Extract file from rm command
+          const cmd = s.params.command as string
+          const match = cmd.match(/rm\s+(.+)/)
+          return match ? match[1] : null
+        })
+        .filter(Boolean) as string[]
+    )]
+  }
+
+  private estimateCost(response: any): number {
+    // Rough estimate: $0.003 per 1K input tokens, $0.015 per 1K output tokens
+    const inputTokens = response.usage?.input_tokens || 0
+    const outputTokens = response.usage?.output_tokens || 0
+
+    return (inputTokens / 1000) * 0.003 + (outputTokens / 1000) * 0.015
+  }
+
+  private async saveTrace(trace: ImprovisationTrace): Promise<void> {
+    // Convert ImprovisationTrace to ActivityExecution format
+    // This unifies all execution modes (template, goal-seeking, improvisation)
+    // to use the same backend storage and learning mechanisms
+    try {
+      const { getMCPClient, isMCPEnabled } = await import('./mcp')
+      if (!isMCPEnabled()) return
+
+      const mcp = getMCPClient()
+      if (!mcp) return
+
+      // Generate templateId from goal (enables learning which goals work)
+      // Format: "improvised-{sanitized-goal}-{hash}"
+      const goalSlug = trace.goal
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .substring(0, 50)
+      const templateId = `improvised-${goalSlug}`
+
+      // Convert to ActivityExecution format
+      const activityExecution = {
+        id: trace.execution_id,
+        templateId: templateId,
+        status: trace.outcome.status === 'success' ? 'completed' as const : 'failed' as const,
+        variables: trace.context || {},
+        impulses: [], // Improvisation starts with no impulses
+        taskResults: trace.steps.map((step, idx) => ({
+          taskId: `step-${step.step}`,
+          status: step.result.success ? 'completed' as const : 'failed' as const,
+          output: step.result.output,
+          error: step.result.error,
+          duration: step.duration_ms,
+        })),
+        startedAt: Date.parse(trace.started_at),
+        completedAt: trace.completed_at ? Date.parse(trace.completed_at) : undefined,
+        error: trace.outcome.error,
+        executionTrace: {
+          tasks: trace.steps.map(step => ({
+            id: `step-${step.step}`,
+            description: step.thought,
+            actualPrompt: step.thought, // The thought is the prompt in improvisation
+            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' as const : 'failure' as const,
+              error: step.result.error,
+            },
+            inputState: {
+              filesAvailable: [],
+              environment: {},
+              impulses: [],
+              variables: {},
+            },
+            outputState: {
+              filesModified: trace.outcome.files_modified,
+              filesCreated: trace.outcome.files_created,
+              filesDeleted: trace.outcome.files_deleted,
+            },
+            stateTransition: {
+              before: {},
+              after: {},
+              workingDirectory: process.cwd(),
+            },
+            impulsesUsed: [],
+            impulsesCreated: [],
+            llmInteractions: [{
+              messages: [
+                {
+                  role: 'user' as const,
+                  content: step.thought,
+                },
+              ],
+              response: {
+                content: JSON.stringify({ action: step.action, params: step.params }),
+                toolCalls: [],
+              },
+              tokens: { input: 0, output: 0 },
+              cost: 0,
+              duration: step.duration_ms,
+            }],
+            duration: step.duration_ms,
+          })),
+          impulsesCreated: [],
+          filesModified: trace.outcome.files_modified,
+          goalContext: {
+            goal: trace.goal,
+            intent: 'improvisation',
+            context: trace.context || {},
+          },
+        },
+        metrics: {
+          duration: trace.outcome.total_duration_ms,
+          cost: trace.outcome.total_cost,
+          totalTokens: trace.outcome.total_tokens,
+        },
+      }
+
+      await mcp.storeExecutionTrace(activityExecution)
+      console.log(`[Improviser] Trace saved to backend: ${trace.execution_id} (template: ${templateId})`)
+    } catch (error) {
+      console.error('[Improviser] Failed to save trace:', error)
+    }
+  }
+
+  private randomId(): string {
+    return Math.random().toString(36).substring(7)
+  }
+}