@metabob/minibob 0.1.2

package/src/session.ts

@@ -0,0 +1,141 @@
+/**
+ * minibob Session Tracker
+ * 
+ * Tracks execution sequences across multiple activity executions in a session.
+ * Enables learning of successful activity sequences for goals.
+ */
+
+import type { ActivityExecution } from "./types"
+import { getMCPClient, isMCPEnabled } from "./mcp"
+
+export interface SessionExecutionItem {
+  activityId: string
+  executionId: string
+  order: number
+  triggerType: 'goal' | 'nested' | 'boredom' | 'manual'
+  parentExecutionId?: string
+  success: boolean
+  durationMs: number
+  costUsd: number
+}
+
+export interface SessionTracker {
+  sessionId: string
+  goalContext?: string
+  executions: SessionExecutionItem[]
+  startedAt: number
+}
+
+// Global session registry
+const activeSessions = new Map<string, SessionTracker>()
+
+/**
+ * Create a new session for tracking execution sequences
+ */
+export function createSession(goalContext?: string): SessionTracker {
+  const sessionId = `session_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`
+  
+  const session: SessionTracker = {
+    sessionId,
+    goalContext,
+    executions: [],
+    startedAt: Date.now(),
+  }
+  
+  activeSessions.set(sessionId, session)
+  console.log(`[Session] Created: ${sessionId}${goalContext ? ` (${goalContext})` : ''}`)
+  
+  return session
+}
+
+/**
+ * Get existing session by ID
+ */
+export function getSession(sessionId: string): SessionTracker | undefined {
+  return activeSessions.get(sessionId)
+}
+
+/**
+ * Record an execution in the session
+ */
+export function recordExecution(
+  sessionId: string,
+  execution: ActivityExecution,
+  triggerType: 'goal' | 'nested' | 'boredom' | 'manual' = 'manual',
+  parentExecutionId?: string
+): void {
+  const session = activeSessions.get(sessionId)
+  if (!session) {
+    console.warn(`[Session] Session not found: ${sessionId}`)
+    return
+  }
+  
+  const item: SessionExecutionItem = {
+    activityId: execution.templateId,
+    executionId: execution.id,
+    order: session.executions.length,
+    triggerType,
+    parentExecutionId,
+    success: execution.status === 'completed',
+    durationMs: execution.metrics?.duration || 0,
+    costUsd: execution.metrics?.cost || 0,
+  }
+  
+  session.executions.push(item)
+  
+  console.log(`[Session] Recorded execution ${item.order + 1}: ${execution.templateId} (${execution.status})`)
+}
+
+/**
+ * Complete session and report to backend
+ */
+export async function completeSession(
+  sessionId: string,
+  outcome: 'success' | 'partial' | 'failure' = 'success'
+): Promise<boolean> {
+  const session = activeSessions.get(sessionId)
+  if (!session) {
+    console.warn(`[Session] Session not found: ${sessionId}`)
+    return false
+  }
+  
+  // Report to MCP backend if enabled
+  if (isMCPEnabled() && session.executions.length > 0) {
+    const mcp = getMCPClient()
+    if (mcp) {
+      console.log(`[Session] Reporting ${session.executions.length} executions to backend...`)
+      const reported = await mcp.recordExecutionSequence({
+        sessionId: session.sessionId,
+        goalContext: session.goalContext,
+        sequence: session.executions,
+        outcome,
+      })
+      
+      if (reported) {
+        console.log(`[Session] ✓ Sequence reported to backend`)
+      } else {
+        console.warn(`[Session] ⚠ Failed to report sequence to backend`)
+      }
+    }
+  }
+  
+  // Clean up session
+  activeSessions.delete(sessionId)
+  console.log(`[Session] Completed: ${sessionId} (${outcome})`)
+  
+  return true
+}
+
+/**
+ * Get all active sessions
+ */
+export function getActiveSessions(): SessionTracker[] {
+  return Array.from(activeSessions.values())
+}
+
+/**
+ * Clear all sessions (for testing)
+ */
+export function clearSessions(): void {
+  activeSessions.clear()
+}

package/src/template-extractor.ts

@@ -0,0 +1,256 @@
+/**
+ * Template Extractor - Extract activity templates from improvisation traces
+ *
+ * The ribosome pattern: successful improvisation → reusable template
+ */
+
+import type { ImprovisationTrace, ImprovisationStep } from './improviser'
+import type { ActivityTemplate, ActivityTask } from './types'
+
+export async function extractTemplateFromImprovisation(
+  trace: ImprovisationTrace
+): Promise<ActivityTemplate> {
+
+  console.log(`[TemplateExtractor] Extracting template from ${trace.execution_id} (${trace.steps.length} steps)`)
+
+  // 1. Identify task boundaries (logical groupings)
+  const taskGroups = identifyTaskBoundaries(trace.steps)
+
+  // 2. Convert each group into a task
+  const tasks: ActivityTask[] = taskGroups.map((group, index) => {
+    const taskId = `task-${index + 1}`
+
+    return {
+      id: taskId,
+      description: summarizeTaskGroup(group),
+      prompt: {
+        template: extractPromptPattern(group),
+        variables: identifyVariables(group)
+      },
+      validation: extractValidation(group),
+      dependencies: index > 0 ? [`task-${index}`] : []
+    }
+  })
+
+  // 3. Create template
+  const template: ActivityTemplate = {
+    id: `tpl_${Date.now()}_${randomId()}`,
+    name: capitalizeGoal(trace.goal),
+    category: inferCategory(trace.goal, trace.outcome),
+    description: trace.goal,
+    tasks,
+    variables: [],  // Extracted from task prompts
+    metadata: {
+      extractedFrom: trace.execution_id,
+      extractionMethod: 'improvisation',
+      firstSuccessMetrics: {
+        duration: trace.outcome.total_duration_ms,
+        cost: trace.outcome.total_cost,
+        steps: trace.steps.length
+      },
+      createdAt: Date.now(),
+      author: 'ribosome'
+    }
+  }
+
+  console.log(`[TemplateExtractor] Template extracted: ${template.id} (${template.tasks.length} tasks)`)
+
+  return template
+}
+
+// ==========================================================================
+// HELPER FUNCTIONS
+// ==========================================================================
+
+function identifyTaskBoundaries(steps: ImprovisationStep[]): ImprovisationStep[][] {
+  // Group steps into logical tasks based on:
+  // 1. Clusters of similar actions
+  // 2. Natural breakpoints (read → analyze → modify pattern)
+  // 3. File boundaries (all operations on same file)
+
+  const groups: ImprovisationStep[][] = []
+  let currentGroup: ImprovisationStep[] = []
+
+  for (let i = 0; i < steps.length; i++) {
+    const step = steps[i]
+    const prevStep = i > 0 ? steps[i - 1] : null
+
+    currentGroup.push(step)
+
+    // Break into new group if:
+    // - Action changes significantly (read → write)
+    // - Working on different file
+    // - Group size >= 5 steps
+    const shouldBreak =
+      currentGroup.length >= 5 ||
+      (prevStep && isSignificantActionChange(prevStep.action, step.action)) ||
+      (prevStep && isDifferentFile(prevStep, step))
+
+    if (shouldBreak && i < steps.length - 1) {
+      groups.push([...currentGroup])
+      currentGroup = []
+    }
+  }
+
+  if (currentGroup.length > 0) {
+    groups.push(currentGroup)
+  }
+
+  return groups
+}
+
+function summarizeTaskGroup(group: ImprovisationStep[]): string {
+  // Use the first step's thought as basis, generalized
+  const firstThought = group[0].thought
+  const actions = group.map(s => s.action)
+
+  // Create descriptive summary
+  if (actions.every(a => a === 'read')) {
+    return 'Analyze and understand current state'
+  } else if (actions.includes('write')) {
+    return 'Create new files and components'
+  } else if (actions.includes('edit')) {
+    return 'Modify existing files'
+  } else if (actions.includes('bash') && actions.some(a => a.includes('grep'))) {
+    return 'Search and verify configuration'
+  } else {
+    return firstThought.substring(0, 80)  // Use LLM's reasoning
+  }
+}
+
+function extractPromptPattern(group: ImprovisationStep[]): string {
+  // Convert the improvised steps into a reusable prompt template
+  const thoughtsAndActions = group.map(s =>
+    `Thought: ${s.thought}\nAction: ${s.action} with ${JSON.stringify(s.params)}`
+  ).join('\n\n')
+
+  return `Based on the goal and following the pattern from successful execution:
+
+${thoughtsAndActions}
+
+Adapt these actions as needed for the specific context, maintaining the same logical flow.`
+}
+
+function identifyVariables(group: ImprovisationStep[]): Array<{name: string, source: string, type: string}> {
+  // Extract variable values that should be parameterized
+  const varsMap = new Map<string, {name: string, source: string, type: string}>()
+
+  group.forEach(step => {
+    // Look for file paths, names, etc that should be variables
+    if (step.params.file_path) {
+      varsMap.set('target_file', {
+        name: 'target_file',
+        source: 'variable',
+        type: 'string'
+      })
+    }
+    if (step.params.directory) {
+      varsMap.set('target_directory', {
+        name: 'target_directory',
+        source: 'variable',
+        type: 'string'
+      })
+    }
+    if (step.params.content && typeof step.params.content === 'string') {
+      // Check if content looks like it contains variables
+      const contentStr = step.params.content as string
+      if (contentStr.includes('{{') || contentStr.includes('${')) {
+        varsMap.set('content_template', {
+          name: 'content_template',
+          source: 'variable',
+          type: 'string'
+        })
+      }
+    }
+  })
+
+  return Array.from(varsMap.values())
+}
+
+function extractValidation(group: ImprovisationStep[]): any {
+  // Extract validation based on what the improvisation checked
+  const validation: any = {}
+
+  const filesCreated = group
+    .filter(s => s.action === 'write')
+    .map(s => s.params.file_path)
+    .filter(Boolean) as string[]
+
+  if (filesCreated.length > 0) {
+    validation.requiredFiles = filesCreated
+  }
+
+  const filesModified = group
+    .filter(s => s.action === 'edit')
+    .map(s => s.params.file_path)
+    .filter(Boolean) as string[]
+
+  if (filesModified.length > 0) {
+    validation.modifiedFiles = filesModified
+  }
+
+  // Check if any bash commands verified success
+  const verificationCommands = group
+    .filter(s => s.action === 'bash' && s.result.success)
+    .map(s => s.params.command)
+    .filter(Boolean) as string[]
+
+  if (verificationCommands.length > 0) {
+    validation.verificationCommands = verificationCommands
+  }
+
+  return Object.keys(validation).length > 0 ? validation : undefined
+}
+
+function capitalizeGoal(goal: string): string {
+  // Convert goal into title case template name
+  return goal
+    .split(' ')
+    .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+    .join(' ')
+}
+
+function inferCategory(goal: string, outcome: any): 'feature' | 'bugfix' | 'refactor' | 'tool' | 'infrastructure' {
+  const goalLower = goal.toLowerCase()
+
+  if (goalLower.includes('fix') || goalLower.includes('bug') || goalLower.includes('error')) {
+    return 'bugfix'
+  } else if (goalLower.includes('refactor') || goalLower.includes('clean') || goalLower.includes('improve')) {
+    return 'refactor'
+  } else if (goalLower.includes('tool') || goalLower.includes('script') || goalLower.includes('automation')) {
+    return 'tool'
+  } else if (goalLower.includes('deploy') || goalLower.includes('infrastructure') || goalLower.includes('setup')) {
+    return 'infrastructure'
+  } else {
+    return 'feature'
+  }
+}
+
+function isSignificantActionChange(prevAction: string, currentAction: string): boolean {
+  // Define significant transitions that indicate task boundaries
+  const transitions = [
+    ['read', 'write'],
+    ['read', 'edit'],
+    ['bash', 'write'],
+    ['bash', 'edit'],
+    ['write', 'bash'],
+    ['edit', 'bash']
+  ]
+
+  return transitions.some(([from, to]) =>
+    prevAction === from && currentAction === to
+  )
+}
+
+function isDifferentFile(prevStep: ImprovisationStep, currentStep: ImprovisationStep): boolean {
+  const prevFile = prevStep.params.file_path as string | undefined
+  const currentFile = currentStep.params.file_path as string | undefined
+
+  if (!prevFile || !currentFile) return false
+
+  return prevFile !== currentFile
+}
+
+function randomId(): string {
+  return Math.random().toString(36).substring(7)
+}

package/src/template-generator.ts

@@ -0,0 +1,130 @@
+/**
+ * Template Generator - Create activity templates from execution traces
+ * 
+ * This module enables self-development: successful goal executions
+ * are automatically converted into reusable activity templates.
+ */
+
+import type { ActivityExecution, ActivityTemplate, ActivityTask, ExecutedTask, TaskValidation } from "./types"
+
+/**
+ * Generate activity template from successful execution
+ */
+export function assembleTemplateFromExecution(
+  execution: ActivityExecution,
+  templateName: string,
+  category: "feature" | "bugfix" | "refactor" | "tool" | "infrastructure"
+): ActivityTemplate {
+  if (!execution.executionTrace) {
+    throw new Error("Execution trace not available. Enable recordExecutionTrace in ExecutorConfig.")
+  }
+
+  const trace = execution.executionTrace
+
+  // Extract tasks from execution trace
+  const tasks: ActivityTask[] = trace.tasks.map((executedTask, index) => {
+    // Find corresponding TaskResult to get token information
+    const taskResult = execution.taskResults.find(tr => tr.taskId === executedTask.id)
+    const outputTokens = taskResult?.tokens?.output || 16000
+
+    return {
+      id: `task-${index + 1}`,
+      subagent: "general",
+      description: executedTask.description || inferTaskDescription(executedTask),
+      dependencies: index > 0 ? [`task-${index}`] : [],
+      prompt: {
+        template: executedTask.actualPrompt,
+        variables: [],  // No variables in generated template (prompt is already substituted)
+        // Use output tokens from execution, capped at model limit (64000 for Claude Sonnet 4)
+        // Fallback to 16000 if no token data available
+        maxTokens: Math.min(outputTokens, 64000),
+        compressionStrategy: "filter" as const,
+      },
+      validation: extractValidation(executedTask),
+      retry: {
+        maxAttempts: 2,
+        strategy: "simple" as const,
+      },
+    }
+  })
+
+  return {
+    id: `tpl_${Date.now()}_${Math.random().toString(36).substring(7)}`,
+    name: templateName,
+    description: trace.goalContext?.goal || "Activity generated from successful execution",
+    category,
+    tasks,
+    variables: [],  // No template-level variables (prompts already substituted)
+    metadata: {
+      generatedFrom: "execution",
+      sourceExecutionId: execution.id,
+      firstExecutionMetrics: {
+        duration: execution.metrics?.duration || 0,
+        cost: execution.metrics?.cost || 0,
+        tokens: execution.metrics?.totalTokens || { input: 0, output: 0 },
+        status: execution.status,
+      },
+      createdAt: Date.now(),
+      author: "ribosome",
+    },
+  }
+}
+
+/**
+ * Extract validation from executed task
+ * 
+ * Maps executedTask.validationResults to TaskValidation structure.
+ * Returns undefined if no validation was performed.
+ */
+function extractValidation(executedTask: ExecutedTask): TaskValidation | undefined {
+  if (!executedTask.validationResults) {
+    return undefined
+  }
+
+  const validation: TaskValidation = {}
+
+  // Extract required files (only include files that existed)
+  if (executedTask.validationResults.requiredFiles) {
+    const existingFiles = executedTask.validationResults.requiredFiles
+      .filter(f => f.exists)
+      .map(f => f.path)
+    
+    if (existingFiles.length > 0) {
+      validation.requiredFiles = existingFiles
+    }
+  }
+
+  // Extract required patterns (need to guess file from pattern context)
+  // Since executedTask.validationResults doesn't have file info, we skip patterns
+  // This is a known limitation - validation patterns in traces don't include file paths
+  
+  // Extract forbidden patterns (same limitation)
+  
+  // No command extraction from validationResults
+  // Commands would need to be in the original task definition
+
+  return Object.keys(validation).length > 0 ? validation : undefined
+}
+
+/**
+ * Infer task description from execution
+ */
+function inferTaskDescription(executedTask: ExecutedTask): string {
+  // Try to extract from prompt
+  const prompt = executedTask.actualPrompt
+  const lines = prompt.split("\n")
+  
+  // Look for task markers
+  const taskLine = lines.find(l => l.match(/your task|objective|goal|\*\*your task\*\*/i))
+  if (taskLine) {
+    return taskLine.replace(/.*:\s*/i, "").replace(/\*/g, "").trim().substring(0, 100)
+  }
+
+  // Fallback: summarize tool calls
+  const tools = executedTask.toolCalls.map(tc => tc.name).filter((t, i, arr) => arr.indexOf(t) === i)
+  if (tools.length > 0) {
+    return `Execute task using: ${tools.join(", ")}`
+  }
+
+  return "Execute task"
+}