@metabob/minibob 0.1.2

package/src/cli/goal.ts

@@ -0,0 +1,224 @@
+/**
+ * Goal Command
+ *
+ * Set a goal and achieve it using available vessels.
+ *
+ * Uses existing infrastructure:
+ * - GoalProcessor for goal-driven execution
+ * - SearchFirstExecutor for dynamic decomposition
+ * - MCP backend for Thompson Sampling recommendations
+ */
+
+import { parseArgs, formatHelp, exitWithError, printInfo } from './index'
+import { loadConfig } from '../config'
+import { ActivityExecutor, type ExecutorConfig } from '../activity'
+import { GoalProcessor, type GoalResult } from '../goal-processor'
+import { SearchFirstExecutor } from '../search-first-executor'
+import { initializeMCP, getMCPClient } from '../mcp'
+import { MCPActivityBridge } from '../mcp-activity-bridge'
+
+export interface GoalOptions {
+  searchFirst?: boolean
+  maxActivities?: number
+  maxCost?: number
+  context?: Record<string, unknown>
+  dryRun?: boolean
+}
+
+/**
+ * Run goal command
+ */
+export async function goal(args: string[]): Promise<void> {
+  const { flags, values, positional } = parseArgs(args)
+
+  // Show help
+  if (flags.help || flags.h) {
+    console.log(formatHelp('goal', 'Set a goal and achieve it', [
+      { flag: '--search-first', description: 'Use SearchFirstExecutor (dynamic decomposition)' },
+      { flag: '--max-activities <n>', description: 'Maximum activities to run', default: '5' },
+      { flag: '--max-cost <n>', description: 'Maximum cost in USD', default: '10.0' },
+      { flag: '--context <json>', description: 'Additional context as JSON' },
+      { flag: '--dry-run', description: 'Plan but do not execute' },
+      { flag: '--help, -h', description: 'Show this help message' },
+    ]))
+    return
+  }
+
+  // Get goal text from positional arguments
+  const goalText = positional.join(' ')
+  if (!goalText) {
+    exitWithError('Goal description required\nUsage: minibob goal "your goal here"')
+  }
+
+  // Parse options
+  const options: GoalOptions = {
+    searchFirst: flags['search-first'] || flags.s,
+    maxActivities: values['max-activities'] ? parseInt(values['max-activities']) : 5,
+    maxCost: values['max-cost'] ? parseFloat(values['max-cost']) : 10.0,
+    context: values.context ? JSON.parse(values.context) : undefined,
+    dryRun: flags['dry-run'],
+  }
+
+  // Load configuration
+  const config = await loadConfig()
+  printInfo(`Goal: ${goalText}`)
+  printInfo(`Working directory: ${config.workingDirectory}`)
+
+  // Initialize MCP if configured
+  if (config.vessels.metabob) {
+    const mcpEndpoint = config.vessels.metabob.endpoint
+    printInfo(`Connecting to backend: ${mcpEndpoint}`)
+    await initializeMCP({ endpoint: mcpEndpoint, apiKey: config.apiKey }, true)
+  }
+
+  // Execute goal
+  if (options.searchFirst) {
+    await executeSearchFirst(goalText, config, options)
+  } else {
+    await executeGoalProcessor(goalText, config, options)
+  }
+}
+
+/**
+ * Execute goal using GoalProcessor
+ */
+async function executeGoalProcessor(
+  goalText: string,
+  config: Awaited<ReturnType<typeof loadConfig>>,
+  options: GoalOptions
+): Promise<void> {
+  const executorConfig: ExecutorConfig = {
+    provider: config.provider,
+    apiKey: config.apiKey,
+    model: config.model,
+    workingDirectory: config.workingDirectory,
+    onSearchActivities: MCPActivityBridge.isAvailable() ? MCPActivityBridge.searchActivities : undefined,
+    onCreateActivity: MCPActivityBridge.isAvailable() ? MCPActivityBridge.createActivity : undefined,
+  }
+
+  const executor = new ActivityExecutor(executorConfig)
+  const goalProcessor = new GoalProcessor({
+    workingDirectory: config.workingDirectory,
+    executor,
+  })
+
+  // Check if MCP is available for recommendations
+  const mcp = getMCPClient()
+  if (!mcp) {
+    console.log('\n⚠ Backend unavailable - recommendations limited')
+    console.log('  Set MINIBOB_MCP_ENDPOINT for full goal-seeking capabilities\n')
+  }
+
+  if (options.dryRun) {
+    console.log('\n[Dry Run] Would execute goal with these settings:')
+    console.log(`  Goal: ${goalText}`)
+    console.log(`  Max activities: ${options.maxActivities}`)
+    console.log(`  Max cost: $${options.maxCost}`)
+    console.log(`  Context: ${JSON.stringify(options.context || {})}`)
+    return
+  }
+
+  console.log('\n🎯 Executing goal...\n')
+
+  const result = await goalProcessor.executeGoal(goalText, options.context, {
+    maxActivities: options.maxActivities,
+    maxCost: options.maxCost,
+  })
+
+  printGoalResult(result)
+}
+
+/**
+ * Execute goal using SearchFirstExecutor
+ */
+async function executeSearchFirst(
+  goalText: string,
+  config: Awaited<ReturnType<typeof loadConfig>>,
+  options: GoalOptions
+): Promise<void> {
+  const executor = new SearchFirstExecutor({
+    provider: config.provider,
+    apiKey: config.apiKey,
+    model: config.model,
+    workingDirectory: config.workingDirectory,
+    maxSteps: options.maxActivities || 5,
+    maxTokensPerStep: 4096,
+  })
+
+  if (options.dryRun) {
+    console.log('\n[Dry Run] Would execute with SearchFirstExecutor:')
+    console.log(`  Goal: ${goalText}`)
+    console.log(`  Max steps: ${options.maxActivities}`)
+    console.log(`  Context: ${JSON.stringify(options.context || {})}`)
+    return
+  }
+
+  console.log('\n🔍 Executing with SearchFirstExecutor...\n')
+  console.log('This mode decomposes goals step-by-step and reuses existing activities.\n')
+
+  const result = await executor.execute(goalText, options.context || {})
+
+  // Print result
+  console.log('\n' + '='.repeat(60))
+  console.log(`Goal: ${goalText}`)
+  console.log(`Status: ${result.completed ? '✅ Completed' : '❌ Incomplete'}`)
+  console.log(`Steps: ${result.steps.length}`)
+  console.log(`Tokens: ${result.metrics.totalTokens.input} in / ${result.metrics.totalTokens.output} out`)
+  console.log(`Cost: $${result.metrics.totalCost.toFixed(4)}`)
+  console.log(`Duration: ${result.metrics.totalDuration}ms`)
+  console.log('='.repeat(60))
+
+  if (result.steps.length > 0) {
+    console.log('\nExecution Steps:')
+    for (const step of result.steps) {
+      const icon = step.success ? '✓' : '✗'
+      console.log(`  ${icon} Step ${step.stepNumber}: ${step.action}`)
+      if (step.reasoning) {
+        console.log(`    Reasoning: ${step.reasoning.slice(0, 100)}...`)
+      }
+    }
+  }
+
+  console.log('')
+}
+
+/**
+ * Print goal result
+ */
+function printGoalResult(result: GoalResult): void {
+  console.log('\n' + '='.repeat(60))
+  console.log(`Goal: ${result.goal.message}`)
+  console.log(`Type: ${result.goal.type}`)
+  console.log(`Status: ${result.completed ? '✅ Completed' : '❌ Incomplete'}`)
+  console.log(`Reason: ${result.completionReason}`)
+  console.log('='.repeat(60))
+  console.log(`Activities executed: ${result.executions.length}`)
+  console.log(`Total duration: ${result.totalDuration}ms`)
+  console.log(`Total cost: $${result.totalCost.toFixed(4)}`)
+  console.log(`Total tokens: ${result.totalTokens.input} in / ${result.totalTokens.output} out`)
+  console.log('='.repeat(60))
+
+  if (result.executions.length > 0) {
+    console.log('\nExecution Details:')
+    for (const exec of result.executions) {
+      const icon = exec.status === 'completed' ? '✓' : '✗'
+      console.log(`  ${icon} ${exec.templateId}`)
+      console.log(`    Status: ${exec.status}`)
+      if (exec.metrics) {
+        console.log(`    Duration: ${exec.metrics.duration}ms`)
+        console.log(`    Cost: $${exec.metrics.cost.toFixed(4)}`)
+      }
+    }
+  }
+
+  console.log('')
+}
+
+// CLI entry point
+if (import.meta.main) {
+  const args = process.argv.slice(2)
+  goal(args).catch((error) => {
+    console.error('Goal failed:', error)
+    process.exit(1)
+  })
+}

package/src/cli/index.ts

@@ -0,0 +1,147 @@
+/**
+ * CLI Utilities and Router
+ *
+ * Common utilities for all CLI commands
+ */
+
+export interface ParsedOptions {
+  flags: Record<string, boolean>
+  values: Record<string, string>
+  positional: string[]
+}
+
+// Flags that take values (not boolean flags)
+const VALUE_FLAGS = new Set([
+  'target',
+  'codebase',
+  'entry',
+  'check',
+  'mode',
+  'port',
+  'tools',
+  'deny-tools',
+  'system',
+  'max-activities',
+  'max-cost',
+  'context',
+  'interval',
+])
+
+/**
+ * Parse command line arguments into structured options
+ */
+export function parseArgs(args: string[]): ParsedOptions {
+  const result: ParsedOptions = {
+    flags: {},
+    values: {},
+    positional: [],
+  }
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i]
+
+    if (arg?.startsWith('--')) {
+      const key = arg.slice(2)
+
+      // Check if this flag is known to take a value
+      if (VALUE_FLAGS.has(key)) {
+        const nextArg = args[i + 1]
+        if (nextArg && !nextArg.startsWith('--') && !nextArg.startsWith('-')) {
+          result.values[key] = nextArg
+          i++ // Skip the next arg
+        }
+      } else {
+        // It's a boolean flag
+        result.flags[key] = true
+      }
+    } else if (arg?.startsWith('-') && arg.length === 2) {
+      // Short flag like -v, -h
+      const key = arg.slice(1)
+      result.flags[key] = true
+    } else if (arg) {
+      result.positional.push(arg)
+    }
+  }
+
+  return result
+}
+
+/**
+ * Format help text with consistent styling
+ */
+export function formatHelp(command: string, description: string, options: Array<{
+  flag: string
+  description: string
+  default?: string
+}>): string {
+  const lines: string[] = [
+    `minibob ${command} - ${description}`,
+    '',
+    'USAGE:',
+    `  minibob ${command} [options]`,
+    '',
+    'OPTIONS:',
+  ]
+
+  for (const opt of options) {
+    const defaultStr = opt.default ? ` (default: ${opt.default})` : ''
+    lines.push(`  ${opt.flag.padEnd(20)} ${opt.description}${defaultStr}`)
+  }
+
+  return lines.join('\n')
+}
+
+/**
+ * Print error and exit
+ */
+export function exitWithError(message: string, exitCode = 1): never {
+  console.error(`Error: ${message}`)
+  process.exit(exitCode)
+}
+
+/**
+ * Print success message
+ */
+export function printSuccess(message: string): void {
+  console.log(`✓ ${message}`)
+}
+
+/**
+ * Print warning message
+ */
+export function printWarning(message: string): void {
+  console.warn(`⚠ ${message}`)
+}
+
+/**
+ * Print info message
+ */
+export function printInfo(message: string): void {
+  console.log(`ℹ ${message}`)
+}
+
+/**
+ * Get home directory path for minibob data
+ */
+export function getMinibobHome(): string {
+  const home = process.env.HOME || process.env.USERPROFILE || '~'
+  return `${home}/.minibob`
+}
+
+/**
+ * Ensure minibob home directory exists
+ */
+export async function ensureMinibobHome(): Promise<string> {
+  const home = getMinibobHome()
+  const fs = await import('fs/promises')
+
+  try {
+    await fs.mkdir(home, { recursive: true })
+    await fs.mkdir(`${home}/instances`, { recursive: true })
+    await fs.mkdir(`${home}/cache`, { recursive: true })
+  } catch (error) {
+    // Directory already exists or other error
+  }
+
+  return home
+}

package/src/cli/instance-registry.ts

@@ -0,0 +1,271 @@
+/**
+ * Instance Registry
+ *
+ * Tracks running minibob instances for the observe command.
+ * Instances register on startup and deregister on shutdown.
+ *
+ * Storage: ~/.minibob/instances.json
+ */
+
+import { ensureMinibobHome, getMinibobHome } from './index'
+
+export interface MinibobInstance {
+  id: string
+  pid?: number
+  port: number
+  host: string
+  startTime: number
+  workingDirectory: string
+  status: 'running' | 'idle' | 'busy' | 'unknown'
+  lastActivity?: string
+  lastActivityTime?: number
+  vesselType?: string
+  capabilities?: string[]
+}
+
+export interface InstanceStatus {
+  id: string
+  status: 'idle' | 'executing' | 'boredom'
+  currentActivity?: {
+    id: string
+    name?: string
+    task?: string
+    progress?: number
+  }
+  metrics: {
+    activitiesExecuted: number
+    uptime: number
+    totalCost?: number
+  }
+  config: {
+    workingDirectory: string
+    model: string
+    port: number
+  }
+}
+
+const REGISTRY_FILE = 'instances.json'
+
+/**
+ * Load instance registry from disk
+ */
+async function loadRegistry(): Promise<Record<string, MinibobInstance>> {
+  const home = await ensureMinibobHome()
+  const registryPath = `${home}/${REGISTRY_FILE}`
+
+  try {
+    const file = Bun.file(registryPath)
+    if (await file.exists()) {
+      return await file.json()
+    }
+  } catch {
+    // Registry doesn't exist or is corrupted
+  }
+
+  return {}
+}
+
+/**
+ * Save instance registry to disk
+ */
+async function saveRegistry(registry: Record<string, MinibobInstance>): Promise<void> {
+  const home = await ensureMinibobHome()
+  const registryPath = `${home}/${REGISTRY_FILE}`
+
+  await Bun.write(registryPath, JSON.stringify(registry, null, 2))
+}
+
+/**
+ * Register a minibob instance
+ */
+export async function registerInstance(instance: MinibobInstance): Promise<void> {
+  const registry = await loadRegistry()
+  registry[instance.id] = instance
+  await saveRegistry(registry)
+}
+
+/**
+ * Deregister a minibob instance
+ */
+export async function deregisterInstance(instanceId: string): Promise<void> {
+  const registry = await loadRegistry()
+  delete registry[instanceId]
+  await saveRegistry(registry)
+}
+
+/**
+ * Update instance status
+ */
+export async function updateInstanceStatus(
+  instanceId: string,
+  update: Partial<MinibobInstance>
+): Promise<void> {
+  const registry = await loadRegistry()
+  const instance = registry[instanceId]
+
+  if (instance) {
+    registry[instanceId] = { ...instance, ...update }
+    await saveRegistry(registry)
+  }
+}
+
+/**
+ * Get all registered instances
+ */
+export async function listInstances(): Promise<MinibobInstance[]> {
+  const registry = await loadRegistry()
+  return Object.values(registry)
+}
+
+/**
+ * Get instance by ID
+ */
+export async function getInstance(instanceId: string): Promise<MinibobInstance | null> {
+  const registry = await loadRegistry()
+  return registry[instanceId] || null
+}
+
+/**
+ * Clean up stale instances (processes that no longer exist)
+ */
+export async function cleanupStaleInstances(): Promise<number> {
+  const registry = await loadRegistry()
+  let removed = 0
+
+  for (const [id, instance] of Object.entries(registry)) {
+    if (instance.pid) {
+      try {
+        // Check if process exists by sending signal 0
+        process.kill(instance.pid, 0)
+      } catch {
+        // Process doesn't exist, remove from registry
+        delete registry[id]
+        removed++
+      }
+    } else {
+      // No PID, try to reach the instance via HTTP
+      try {
+        const url = `http://${instance.host}:${instance.port}/health`
+        const response = await fetch(url, { signal: AbortSignal.timeout(2000) })
+        if (!response.ok) {
+          delete registry[id]
+          removed++
+        }
+      } catch {
+        // Instance unreachable, remove
+        delete registry[id]
+        removed++
+      }
+    }
+  }
+
+  if (removed > 0) {
+    await saveRegistry(registry)
+  }
+
+  return removed
+}
+
+/**
+ * Fetch status from a running instance
+ */
+export async function fetchInstanceStatus(instance: MinibobInstance): Promise<InstanceStatus | null> {
+  try {
+    const url = `http://${instance.host}:${instance.port}/status`
+    const response = await fetch(url, { signal: AbortSignal.timeout(5000) })
+
+    if (response.ok) {
+      return await response.json()
+    }
+
+    // Fall back to /config endpoint
+    const configUrl = `http://${instance.host}:${instance.port}/config`
+    const configResponse = await fetch(configUrl, { signal: AbortSignal.timeout(5000) })
+
+    if (configResponse.ok) {
+      const config = await configResponse.json()
+      // Construct minimal status from config
+      return {
+        id: config.id || instance.id,
+        status: 'idle',
+        metrics: {
+          activitiesExecuted: 0,
+          uptime: Date.now() - instance.startTime,
+        },
+        config: {
+          workingDirectory: instance.workingDirectory,
+          model: config.model || 'unknown',
+          port: instance.port,
+        },
+      }
+    }
+  } catch {
+    // Instance unreachable
+  }
+
+  return null
+}
+
+/**
+ * Scan localhost ports for minibob instances
+ */
+export async function scanForInstances(
+  startPort: number = 8080,
+  endPort: number = 8090
+): Promise<MinibobInstance[]> {
+  const found: MinibobInstance[] = []
+
+  const scanPromises = []
+  for (let port = startPort; port <= endPort; port++) {
+    scanPromises.push(
+      (async () => {
+        try {
+          const url = `http://localhost:${port}/health`
+          const response = await fetch(url, { signal: AbortSignal.timeout(1000) })
+
+          if (response.ok) {
+            const health = (await response.json()) as { vessel?: string }
+            if (health.vessel === 'minibob') {
+              // Get full config
+              const configResponse = await fetch(`http://localhost:${port}/config`, {
+                signal: AbortSignal.timeout(1000),
+              })
+
+              if (configResponse.ok) {
+                const config = (await configResponse.json()) as {
+                  id?: string
+                  capabilities?: string[]
+                  metadata?: {
+                    workingDirectory?: string
+                  }
+                }
+
+                found.push({
+                  id: config.id || `minibob-${port}`,
+                  port,
+                  host: 'localhost',
+                  startTime: Date.now(),
+                  workingDirectory: config.metadata?.workingDirectory || process.cwd(),
+                  status: 'running',
+                  capabilities: config.capabilities,
+                })
+              }
+            }
+          }
+        } catch {
+          // Port not responding or not minibob
+        }
+      })()
+    )
+  }
+
+  await Promise.all(scanPromises)
+  return found
+}
+
+/**
+ * Generate unique instance ID
+ */
+export function generateInstanceId(): string {
+  return `minibob-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`
+}