@metabob/minibob 0.1.2

package/src/boredom.ts

@@ -0,0 +1,423 @@
+/**
+ * minibob Boredom Task System
+ *
+ * Enables autonomous operation by polling backend for tasks when idle.
+ * Transforms minibob from request-response to continuous autonomous agent.
+ *
+ * Two execution modes:
+ * 1. Template-based: Load and execute a specific template
+ * 2. Goal-based: Use SearchFirstExecutor for dynamic decomposition and reuse
+ */
+
+import { getMCPClient, isMCPEnabled } from "./mcp"
+import { loadTemplateFromMCPOrLocal } from "./activity"
+import { SearchFirstExecutor, type SearchFirstConfig } from "./search-first-executor"
+import type { ActivityTemplate } from "./types"
+
+// =============================================================================
+// BOREDOM TASK TYPES
+// =============================================================================
+
+export interface BoredomTask {
+  id: string
+  templateId?: string  // Optional - if provided, use template execution
+  goal?: string        // Optional - if provided, use search-first execution
+  priority: "critical" | "high" | "medium" | "low"
+  variables: Record<string, unknown>
+  reason?: string
+  createdAt: number
+  assignedTo?: string
+}
+
+export interface BoredomTaskResult {
+  taskId: string
+  success: boolean
+  executionId?: string
+  duration?: number
+  error?: string
+}
+
+// =============================================================================
+// BOREDOM TASK EXECUTOR
+// =============================================================================
+
+export interface BoredomExecutorConfig {
+  pollInterval?: number
+  idleThreshold?: number
+  // Template-based execution callback
+  onExecuteTask: (template: ActivityTemplate, variables: Record<string, unknown>, reason?: string) => Promise<unknown>
+  // LLM config for goal-based execution
+  llmConfig: {
+    provider: "anthropic" | "openai"
+    apiKey: string
+    model: string
+    workingDirectory: string
+  }
+}
+
+export class BoredomTaskExecutor {
+  private isRunning = false
+  private pollInterval: number
+  private idleThreshold: number
+  private lastActivityTime: number
+  private onExecuteTask: (template: ActivityTemplate, variables: Record<string, unknown>, reason?: string) => Promise<unknown>
+  private searchFirstExecutor: SearchFirstExecutor
+
+  constructor(config: BoredomExecutorConfig) {
+    this.pollInterval = config.pollInterval ?? 30000 // 30 seconds
+    this.idleThreshold = config.idleThreshold ?? 60000 // 60 seconds idle before fetching tasks
+    this.lastActivityTime = Date.now()
+    this.onExecuteTask = config.onExecuteTask
+
+    // Initialize SearchFirstExecutor for goal-based tasks
+    this.searchFirstExecutor = new SearchFirstExecutor({
+      provider: config.llmConfig.provider,
+      apiKey: config.llmConfig.apiKey,
+      model: config.llmConfig.model,
+      workingDirectory: config.llmConfig.workingDirectory,
+      maxSteps: 4,           // Conservative for autonomous execution
+      maxTokensPerStep: 4096, // Prevent token overflow
+    })
+  }
+
+  /**
+   * Start the boredom task executor loop
+   * 
+   * Only starts if:
+   * 1. MCP is enabled (backend connection available)
+   * 2. Cluster mode is enabled (3+ pods)
+   * 
+   * Boredom system is disabled in local/Docker/single-pod environments to avoid resource waste.
+   */
+  start(clusterMode = false): void {
+    if (this.isRunning) {
+      console.log("[Boredom] Already running")
+      return
+    }
+
+    if (!isMCPEnabled()) {
+      console.log("[Boredom] MCP not enabled, boredom tasks disabled")
+      return
+    }
+
+    if (!clusterMode) {
+      console.log("[Boredom] Not in cluster mode, boredom tasks disabled")
+      return
+    }
+
+    this.isRunning = true
+    console.log(`[Boredom] Starting task executor (poll interval: ${this.pollInterval}ms, idle threshold: ${this.idleThreshold}ms)`)
+    
+    this.loop().catch((error) => {
+      console.error("[Boredom] Fatal error in loop:", error)
+      this.isRunning = false
+    })
+  }
+
+  /**
+   * Stop the boredom task executor
+   */
+  stop(): void {
+    this.isRunning = false
+    console.log("[Boredom] Stopping task executor")
+  }
+
+  /**
+   * Mark activity (resets idle timer)
+   */
+  markActivity(): void {
+    this.lastActivityTime = Date.now()
+  }
+
+  /**
+   * Check if vessel is idle
+   */
+  isIdle(): boolean {
+    const idleTime = Date.now() - this.lastActivityTime
+    return idleTime >= this.idleThreshold
+  }
+
+  /**
+   * Main executor loop
+   */
+  private async loop(): Promise<void> {
+    while (this.isRunning) {
+      try {
+        // Wait for poll interval
+        await this.sleep(this.pollInterval)
+
+        // Skip if not idle
+        if (!this.isIdle()) {
+          continue
+        }
+
+        // Fetch tasks from backend
+        const tasks = await this.fetchTasks()
+        if (tasks.length === 0) {
+          continue
+        }
+
+        console.log(`[Boredom] Found ${tasks.length} available task(s)`)
+
+        // Execute highest priority task
+        const task = tasks[0]
+        if (!task) continue
+        await this.executeTask(task)
+
+      } catch (error) {
+        console.error("[Boredom] Error in loop:", error)
+        // Continue running despite errors
+      }
+    }
+  }
+
+  /**
+   * Fetch available boredom tasks from backend
+   */
+  private async fetchTasks(): Promise<BoredomTask[]> {
+    const mcp = getMCPClient()
+    if (!mcp) return []
+
+    try {
+      const response = await fetch(`${(mcp as any).endpoint}/boredom-tasks`, {
+        method: "GET",
+        headers: {
+          "Content-Type": "application/json",
+        },
+      })
+
+      if (!response.ok) {
+        if (response.status === 404) {
+          // Endpoint not implemented yet
+          return []
+        }
+        throw new Error(`Failed to fetch tasks: ${response.status}`)
+      }
+
+      const data = await response.json() as { tasks?: BoredomTask[] }
+      const tasks = data.tasks ?? []
+
+      // Sort by priority
+      const sorted = tasks.sort((a, b) => {
+        const priorityOrder = { critical: 0, high: 1, medium: 2, low: 3 }
+        return priorityOrder[a.priority] - priorityOrder[b.priority]
+      })
+
+      // Convert debug/optimization templates to goal-based tasks
+      return sorted.map(task => this.convertToGoalTaskIfApplicable(task))
+    } catch (error) {
+      console.error("[Boredom] Error fetching tasks:", error)
+      return []
+    }
+  }
+
+  /**
+   * Convert template-based tasks to goal-based tasks when appropriate
+   *
+   * This enables backwards compatibility: the backend can still emit
+   * template-based tasks, but we convert debug/optimization tasks to
+   * use the SearchFirstExecutor for better reuse and decomposition.
+   */
+  private convertToGoalTaskIfApplicable(task: BoredomTask): BoredomTask {
+    // If task already has a goal, use as-is
+    if (task.goal) {
+      return task
+    }
+
+    // Convert debug templates to goal-based tasks
+    if (task.templateId?.startsWith("debug-")) {
+      const vars = task.variables as {
+        failingTemplateId?: string
+        successRate?: number
+        totalExecutions?: number
+        recentFailures?: unknown[]
+      }
+
+      console.log(`[Boredom] Converting debug task to goal-based: ${task.id}`)
+
+      return {
+        ...task,
+        templateId: undefined,  // Remove template - use goal instead
+        goal: `Investigate why activity "${vars.failingTemplateId}" has ${vars.successRate ?? 0}% success rate after ${vars.totalExecutions ?? 0} executions. Identify the root cause and suggest fixes.`,
+      }
+    }
+
+    // Convert optimization templates to goal-based tasks
+    if (task.templateId?.startsWith("optimize-") || task.templateId?.startsWith("improve-")) {
+      console.log(`[Boredom] Converting optimization task to goal-based: ${task.id}`)
+
+      return {
+        ...task,
+        templateId: undefined,
+        goal: `Optimize activity "${(task.variables as { targetTemplateId?: string }).targetTemplateId}". Analyze performance metrics and suggest improvements.`,
+      }
+    }
+
+    // Keep other tasks as template-based
+    return task
+  }
+
+  /**
+   * Execute a boredom task
+   *
+   * Two execution modes:
+   * 1. Goal-based: Use SearchFirstExecutor for dynamic step decomposition
+   * 2. Template-based: Load and execute a specific template (legacy)
+   */
+  private async executeTask(task: BoredomTask): Promise<void> {
+    const result: BoredomTaskResult = {
+      taskId: task.id,
+      success: false,
+    }
+
+    const startTime = Date.now()
+
+    try {
+      // Mode 1: Goal-based execution (preferred)
+      if (task.goal) {
+        console.log(`[Boredom] Executing goal-based task: ${task.id}`)
+        console.log(`[Boredom] Goal: ${task.goal}`)
+
+        const goalResult = await this.searchFirstExecutor.execute(
+          task.goal,
+          {
+            ...task.variables,
+            taskId: task.id,
+            reason: task.reason,
+          }
+        )
+
+        result.success = goalResult.completed
+        result.duration = Date.now() - startTime
+
+        if (goalResult.completed) {
+          console.log(`[Boredom] ✓ Goal completed: ${task.id} in ${result.duration}ms`)
+          console.log(`[Boredom] Summary: ${goalResult.summary}`)
+        } else {
+          result.error = `Goal partially completed: ${goalResult.results.filter(r => r.status === "failed").map(r => r.error).join("; ")}`
+          console.log(`[Boredom] ⚠ Goal partially completed: ${task.id}`)
+        }
+      }
+      // Mode 2: Template-based execution (legacy)
+      else if (task.templateId) {
+        console.log(`[Boredom] Executing template-based task: ${task.id} (template: ${task.templateId})`)
+
+        const template = await loadTemplateFromMCPOrLocal(task.templateId)
+
+        const execution = await this.onExecuteTask(
+          template,
+          task.variables,
+          task.reason ?? `Boredom task: ${task.id}`
+        )
+
+        result.success = true
+        result.executionId = (execution as any).id
+        result.duration = Date.now() - startTime
+
+        console.log(`[Boredom] ✓ Task completed: ${task.id} in ${result.duration}ms`)
+      }
+      // No goal or template - invalid task
+      else {
+        throw new Error("Task must have either 'goal' or 'templateId'")
+      }
+
+    } catch (error) {
+      result.success = false
+      result.error = error instanceof Error ? error.message : String(error)
+      result.duration = Date.now() - startTime
+      console.error(`[Boredom] ✗ Task failed: ${task.id}`, error)
+    }
+
+    // Report result to backend
+    await this.reportResult(result)
+
+    // Mark activity to reset idle timer
+    this.markActivity()
+  }
+
+  /**
+   * Report task execution result to backend
+   */
+  private async reportResult(result: BoredomTaskResult): Promise<void> {
+    const mcp = getMCPClient()
+    if (!mcp) return
+
+    try {
+      const response = await fetch(`${(mcp as any).endpoint}/boredom-tasks/${result.taskId}/result`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify(result),
+      })
+
+      if (!response.ok) {
+        console.warn(`[Boredom] Failed to report result: ${response.status}`)
+      }
+    } catch (error) {
+      console.error("[Boredom] Error reporting result:", error)
+    }
+  }
+
+  /**
+   * Sleep helper
+   */
+  private sleep(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms))
+  }
+}
+
+// =============================================================================
+// SINGLETON BOREDOM EXECUTOR
+// =============================================================================
+
+let boredomExecutor: BoredomTaskExecutor | null = null
+
+/**
+ * Initialize boredom task executor
+ */
+export function initializeBoredom(config: BoredomExecutorConfig): BoredomTaskExecutor {
+  if (boredomExecutor) {
+    console.warn("[Boredom] Already initialized")
+    return boredomExecutor
+  }
+
+  boredomExecutor = new BoredomTaskExecutor(config)
+  return boredomExecutor
+}
+
+/**
+ * Get boredom executor instance
+ */
+export function getBoredomExecutor(): BoredomTaskExecutor | null {
+  return boredomExecutor
+}
+
+/**
+ * Start boredom task execution
+ * 
+ * @param clusterMode Whether cluster mode is enabled (required for boredom to start)
+ */
+export function startBoredom(clusterMode = false): void {
+  if (boredomExecutor) {
+    boredomExecutor.start(clusterMode)
+  }
+}
+
+/**
+ * Stop boredom task execution
+ */
+export function stopBoredom(): void {
+  if (boredomExecutor) {
+    boredomExecutor.stop()
+  }
+}
+
+/**
+ * Mark activity (called when handling user requests)
+ */
+export function markBoredomActivity(): void {
+  if (boredomExecutor) {
+    boredomExecutor.markActivity()
+  }
+}