@metabob/minibob 0.1.2

package/src/cli/vessel.ts

@@ -0,0 +1,287 @@
+/**
+ * Vessel Command
+ *
+ * Manage the vessel registry - list, inspect, and manage burrowed codebases.
+ */
+
+import { parseArgs, formatHelp, printSuccess, printWarning, printInfo, exitWithError } from './index'
+import {
+  listVessels,
+  getVessel,
+  getVesselByPath,
+  deregisterVessel,
+  type Vessel,
+  type VesselIdentity,
+} from '../vessel-registry'
+import { resolve } from 'path'
+
+export interface VesselOptions {
+  json?: boolean
+  verbose?: boolean
+}
+
+/**
+ * Run vessel command
+ */
+export async function vessel(args: string[]): Promise<void> {
+  const { flags, positional } = parseArgs(args)
+
+  const subcommand = positional[0]
+  const options: VesselOptions = {
+    json: flags.json,
+    verbose: flags.verbose || flags.v,
+  }
+
+  // Show help
+  if (flags.help || flags.h || !subcommand) {
+    console.log(formatHelp('vessel', 'Manage the vessel registry', [
+      { flag: 'list', description: 'List all registered vessels' },
+      { flag: 'info [path]', description: 'Show vessel info (current dir if no path)' },
+      { flag: 'remove <id|path>', description: 'Remove a vessel from the registry' },
+      { flag: '--json', description: 'Output in JSON format' },
+      { flag: '--verbose, -v', description: 'Show detailed information' },
+      { flag: '--help, -h', description: 'Show this help message' },
+    ]))
+    return
+  }
+
+  switch (subcommand) {
+    case 'list':
+    case 'ls':
+      await listVesselsCommand(options)
+      break
+
+    case 'info':
+    case 'show':
+      const infoPath = positional[1] || '.'
+      await showVesselInfo(infoPath, options)
+      break
+
+    case 'remove':
+    case 'rm':
+    case 'deregister':
+      const removeTarget = positional[1]
+      if (!removeTarget) {
+        exitWithError('Please specify a vessel ID or path to remove')
+      }
+      await removeVessel(removeTarget, options)
+      break
+
+    default:
+      exitWithError(`Unknown subcommand: ${subcommand}`)
+  }
+}
+
+/**
+ * List all registered vessels
+ */
+async function listVesselsCommand(options: VesselOptions): Promise<void> {
+  const vessels = listVessels()
+
+  if (vessels.length === 0) {
+    if (options.json) {
+      console.log(JSON.stringify({ vessels: [] }, null, 2))
+    } else {
+      printInfo('No vessels registered. Use "minibob burrow <path>" to register a codebase.')
+    }
+    return
+  }
+
+  if (options.json) {
+    console.log(JSON.stringify({ vessels }, null, 2))
+    return
+  }
+
+  console.log('\n=== Registered Vessels ===\n')
+
+  for (const v of vessels) {
+    const lastActive = new Date(v.lastActiveAt).toLocaleDateString()
+    console.log(`  ${v.name}`)
+    console.log(`    ID: ${v.id}`)
+    console.log(`    Path: ${v.path}`)
+    console.log(`    Last Active: ${lastActive}`)
+    if (v.description) {
+      console.log(`    Description: ${v.description}`)
+    }
+    console.log('')
+  }
+
+  console.log(`Total: ${vessels.length} vessel(s)\n`)
+}
+
+/**
+ * Show detailed vessel information
+ */
+async function showVesselInfo(pathOrId: string, options: VesselOptions): Promise<void> {
+  // Try to find by path first
+  let vesselData: Vessel | null = null
+
+  // Check if it looks like an ID
+  if (pathOrId.startsWith('vessel_')) {
+    vesselData = getVessel(pathOrId)
+  }
+
+  // Try by path
+  if (!vesselData) {
+    const absPath = resolve(pathOrId)
+    vesselData = getVesselByPath(absPath)
+  }
+
+  if (!vesselData) {
+    if (options.json) {
+      console.log(JSON.stringify({ error: 'Vessel not found' }, null, 2))
+    } else {
+      exitWithError(`Vessel not found at: ${pathOrId}\nRun "minibob burrow ${pathOrId}" to register it.`)
+    }
+    return
+  }
+
+  if (options.json) {
+    // Serialize Maps to objects for JSON output
+    const jsonSafe = {
+      ...vesselData,
+      mapping: {
+        functionMap: Object.fromEntries(vesselData.mapping.functionMap),
+        intentMap: Object.fromEntries(vesselData.mapping.intentMap),
+        patternMap: Object.fromEntries(vesselData.mapping.patternMap),
+      },
+    }
+    console.log(JSON.stringify(jsonSafe, null, 2))
+    return
+  }
+
+  console.log('\n=== Vessel Information ===\n')
+  console.log(`Name: ${vesselData.name}`)
+  console.log(`ID: ${vesselData.id}`)
+  console.log(`Path: ${vesselData.path}`)
+  if (vesselData.version) {
+    console.log(`Version: ${vesselData.version}`)
+  }
+  if (vesselData.description) {
+    console.log(`Description: ${vesselData.description}`)
+  }
+  console.log(`Created: ${new Date(vesselData.createdAt).toLocaleString()}`)
+  console.log(`Last Active: ${new Date(vesselData.lastActiveAt).toLocaleString()}`)
+
+  // Activities
+  console.log('\n--- Activities ---')
+  if (vesselData.activities.length === 0) {
+    console.log('  No activities defined')
+  } else {
+    for (const activity of vesselData.activities) {
+      const successPct = activity.successRate > 0 ? `${(activity.successRate * 100).toFixed(0)}%` : 'N/A'
+      console.log(`  ${activity.name} (${activity.id})`)
+      console.log(`    Origin: ${activity.origin}, Executions: ${activity.executions}, Success: ${successPct}`)
+    }
+  }
+
+  // Impulses
+  if (vesselData.impulses.length > 0) {
+    console.log('\n--- Impulses ---')
+    for (const impulse of vesselData.impulses) {
+      console.log(`  ${impulse.id} (${impulse.type})`)
+      if (impulse.description) {
+        console.log(`    ${impulse.description}`)
+      }
+    }
+  }
+
+  // Hooks
+  if (vesselData.hooks.length > 0) {
+    console.log('\n--- Hooks ---')
+    for (const hook of vesselData.hooks) {
+      const status = hook.enabled ? 'enabled' : 'disabled'
+      console.log(`  ${hook.id} (${hook.type}) - ${status}`)
+      console.log(`    Handler: ${hook.handler}`)
+    }
+  }
+
+  // Tools
+  if (vesselData.tools.length > 0) {
+    console.log('\n--- Tools ---')
+    for (const tool of vesselData.tools) {
+      console.log(`  ${tool.name}: ${tool.description}`)
+    }
+  }
+
+  // Runtime Mappings (verbose only)
+  if (options.verbose) {
+    console.log('\n--- Runtime Mappings ---')
+    const functionCount = vesselData.mapping.functionMap.size
+    const intentCount = vesselData.mapping.intentMap.size
+    const patternCount = vesselData.mapping.patternMap.size
+    console.log(`  Functions mapped: ${functionCount}`)
+    console.log(`  Intents inferred: ${intentCount}`)
+    console.log(`  Patterns recorded: ${patternCount}`)
+
+    if (functionCount > 0 && functionCount <= 10) {
+      console.log('\n  Function Mappings:')
+      for (const [name, loc] of vesselData.mapping.functionMap) {
+        console.log(`    ${name} -> ${loc.file}:${loc.line}`)
+      }
+    }
+
+    if (intentCount > 0 && intentCount <= 10) {
+      console.log('\n  Intent Mappings:')
+      for (const [name, intent] of vesselData.mapping.intentMap) {
+        console.log(`    ${name}: ${intent.purpose} (${(intent.confidence * 100).toFixed(0)}%)`)
+      }
+    }
+  }
+
+  // Composition
+  if (vesselData.composition.compositions.length > 0) {
+    console.log('\n--- Activity Composition ---')
+    for (const comp of vesselData.composition.compositions.slice(0, 10)) {
+      console.log(`  ${comp.parent} -> ${comp.child} (${comp.count} times, ${comp.successRate.toFixed(0)}% success)`)
+    }
+  }
+
+  console.log('')
+}
+
+/**
+ * Remove a vessel from the registry
+ */
+async function removeVessel(target: string, options: VesselOptions): Promise<void> {
+  // Find the vessel
+  let vesselId: string | null = null
+
+  if (target.startsWith('vessel_')) {
+    vesselId = target
+  } else {
+    const absPath = resolve(target)
+    const v = getVesselByPath(absPath)
+    if (v) {
+      vesselId = v.id
+    }
+  }
+
+  if (!vesselId) {
+    if (options.json) {
+      console.log(JSON.stringify({ error: 'Vessel not found', target }, null, 2))
+    } else {
+      exitWithError(`Vessel not found: ${target}`)
+    }
+    return
+  }
+
+  const removed = deregisterVessel(vesselId)
+
+  if (options.json) {
+    console.log(JSON.stringify({ success: removed, vesselId }, null, 2))
+  } else if (removed) {
+    printSuccess(`Removed vessel: ${vesselId}`)
+  } else {
+    printWarning(`Failed to remove vessel: ${vesselId}`)
+  }
+}
+
+// CLI entry point
+if (import.meta.main) {
+  const args = process.argv.slice(2)
+  vessel(args).catch((error) => {
+    console.error('Vessel command failed:', error)
+    process.exit(1)
+  })
+}

package/src/components/SystemOverview.tsx

@@ -0,0 +1,331 @@
+/**
+ * System Overview Component
+ * 
+ * Shows:
+ * - MiniBob instance status (from K8s API or metrics endpoint)
+ * - API health and connectivity
+ * - Overall system metrics (total executions, success rate, error rate, costs)
+ * - Recent activity feed
+ */
+
+import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card";
+import { Badge } from "@/components/ui/badge";
+import { Progress } from "@/components/ui/progress";
+import { Activity, Server, Database, Cpu, TrendingUp, TrendingDown, Clock, DollarSign, Wifi, WifiOff } from "lucide-react";
+import { useHealth } from "@/hooks/useHealth";
+import { useTemplates } from "@/hooks/useTemplates";
+import { useWebSocket } from "@/hooks/useWebSocket";
+import { useMemo, useCallback } from "react";
+import type { ActivityTemplate, WebSocketMessage } from "@/lib/types";
+
+interface SystemMetrics {
+  totalExecutions: number;
+  successRate: number;
+  totalCost: number;
+  avgDuration: number;
+  activeTemplates: number;
+}
+
+export function SystemOverview() {
+  const { health, loading: healthLoading } = useHealth();
+  const { templates, total, loading: templatesLoading, refresh: refreshTemplates } = useTemplates();
+  
+  // WebSocket for real-time updates
+  const handleWebSocketMessage = useCallback((message: WebSocketMessage) => {
+    console.log('[SystemOverview] Received WebSocket message:', message.type);
+    
+    // Refresh templates when metrics are updated
+    if (message.type === 'execution_completed' || message.type === 'template_updated') {
+      refreshTemplates();
+    }
+  }, [refreshTemplates]);
+  
+  const { connected: wsConnected } = useWebSocket({
+    enabled: true,
+    onMessage: handleWebSocketMessage,
+  });
+
+  // Calculate aggregate metrics
+  const metrics: SystemMetrics = useMemo(() => {
+    if (!templates || templates.length === 0) {
+      return {
+        totalExecutions: 0,
+        successRate: 0,
+        totalCost: 0,
+        avgDuration: 0,
+        activeTemplates: 0,
+      };
+    }
+
+    const allTemplates: ActivityTemplate[] = templates;
+    const totalExec = allTemplates.reduce((sum: number, t: ActivityTemplate) => 
+      sum + (t.metrics?.total_executions || 0), 0
+    );
+    const successfulExec = allTemplates.reduce((sum: number, t: ActivityTemplate) => 
+      sum + (t.metrics?.successful_executions || 0), 0
+    );
+    const totalCost = allTemplates.reduce((sum: number, t: ActivityTemplate) => 
+      sum + ((t.metrics?.avg_cost_usd || 0) * (t.metrics?.total_executions || 0)), 0
+    );
+    const totalDuration = allTemplates.reduce((sum: number, t: ActivityTemplate) => 
+      sum + ((t.metrics?.avg_duration_ms || 0) * (t.metrics?.total_executions || 0)), 0
+    );
+
+    return {
+      totalExecutions: totalExec,
+      successRate: totalExec > 0 ? (successfulExec / totalExec) * 100 : 0,
+      totalCost,
+      avgDuration: totalExec > 0 ? totalDuration / totalExec : 0,
+      activeTemplates: allTemplates.filter((t: ActivityTemplate) => 
+        (t.metrics?.total_executions || 0) > 0
+      ).length,
+    };
+  }, [templates]);
+
+  // Health status badge
+  const healthStatus = health?.status || 'unknown';
+  const healthColor = healthStatus === 'healthy' || healthStatus === 'ok' ? 'default' : 
+                     healthStatus === 'degraded' ? 'secondary' : 'destructive';
+
+  return (
+    <div className="space-y-6">
+      {/* Header */}
+      <div className="flex items-start justify-between">
+        <div>
+          <h2 className="text-3xl font-bold tracking-tight">System Overview</h2>
+          <p className="text-muted-foreground">
+            Real-time monitoring of MiniBob instances and activity execution
+          </p>
+        </div>
+        {/* WebSocket Status Indicator */}
+        <div className="flex items-center gap-2 text-sm">
+          {wsConnected ? (
+            <>
+              <Wifi className="h-4 w-4 text-green-600" />
+              <span className="text-green-600">Live</span>
+            </>
+          ) : (
+            <>
+              <WifiOff className="h-4 w-4 text-muted-foreground" />
+              <span className="text-muted-foreground">Reconnecting...</span>
+            </>
+          )}
+        </div>
+      </div>
+
+      {/* Top-level Status Cards */}
+      <div className="grid gap-4 md:grid-cols-2 lg:grid-cols-5">
+        {/* API Health */}
+        <Card>
+          <CardHeader className="flex flex-row items-center justify-between space-y-0 pb-2">
+            <CardTitle className="text-sm font-medium">API Health</CardTitle>
+            <Server className="h-4 w-4 text-muted-foreground" />
+          </CardHeader>
+          <CardContent>
+            {healthLoading ? (
+              <div className="text-2xl font-bold">Loading...</div>
+            ) : (
+              <>
+                <div className="flex items-center gap-2">
+                  <Badge variant={healthColor}>{healthStatus}</Badge>
+                  {health?.service && (
+                    <span className="text-xs text-muted-foreground">{health.service}</span>
+                  )}
+                </div>
+                {health?.checks && (
+                  <div className="mt-2 space-y-1 text-xs text-muted-foreground">
+                    <div className="flex justify-between">
+                      <span>Redis:</span>
+                      <span className={health.checks.redis?.status === 'healthy' ? 'text-green-600' : 'text-red-600'}>
+                        {health.checks.redis?.status} ({health.checks.redis?.latency_ms}ms)
+                      </span>
+                    </div>
+                    <div className="flex justify-between">
+                      <span>SurrealDB:</span>
+                      <span className={health.checks.surrealdb?.status === 'healthy' ? 'text-green-600' : 'text-red-600'}>
+                        {health.checks.surrealdb?.status} ({health.checks.surrealdb?.latency_ms}ms)
+                      </span>
+                    </div>
+                  </div>
+                )}
+              </>
+            )}
+          </CardContent>
+        </Card>
+
+        {/* Total Executions */}
+        <Card>
+          <CardHeader className="flex flex-row items-center justify-between space-y-0 pb-2">
+            <CardTitle className="text-sm font-medium">Total Executions</CardTitle>
+            <Activity className="h-4 w-4 text-muted-foreground" />
+          </CardHeader>
+          <CardContent>
+            <div className="text-2xl font-bold">
+              {templatesLoading ? '...' : metrics.totalExecutions.toLocaleString()}
+            </div>
+            <p className="text-xs text-muted-foreground">
+              {metrics.activeTemplates} active templates
+            </p>
+          </CardContent>
+        </Card>
+
+        {/* Success Rate */}
+        <Card>
+          <CardHeader className="flex flex-row items-center justify-between space-y-0 pb-2">
+            <CardTitle className="text-sm font-medium">Success Rate</CardTitle>
+            <TrendingUp className="h-4 w-4 text-green-500" />
+          </CardHeader>
+          <CardContent>
+            <div className="text-2xl font-bold text-green-600">
+              {templatesLoading ? '...' : `${metrics.successRate.toFixed(1)}%`}
+            </div>
+            <p className="text-xs text-muted-foreground">
+              {Math.round(metrics.totalExecutions * metrics.successRate / 100)} successful executions
+            </p>
+            <Progress 
+              value={metrics.successRate} 
+              className="mt-2" 
+            />
+          </CardContent>
+        </Card>
+
+        {/* Error Rate */}
+        <Card>
+          <CardHeader className="flex flex-row items-center justify-between space-y-0 pb-2">
+            <CardTitle className="text-sm font-medium">Error Rate</CardTitle>
+            <TrendingDown className="h-4 w-4 text-red-500" />
+          </CardHeader>
+          <CardContent>
+            <div className="text-2xl font-bold text-red-600">
+              {templatesLoading ? '...' : `${(100 - metrics.successRate).toFixed(1)}%`}
+            </div>
+            <p className="text-xs text-muted-foreground">
+              {Math.round(metrics.totalExecutions * (100 - metrics.successRate) / 100)} failed executions
+            </p>
+            <Progress 
+              value={100 - metrics.successRate} 
+              className="mt-2"
+            />
+          </CardContent>
+        </Card>
+
+        {/* Average Duration */}
+        <Card>
+          <CardHeader className="flex flex-row items-center justify-between space-y-0 pb-2">
+            <CardTitle className="text-sm font-medium">Avg Duration</CardTitle>
+            <Clock className="h-4 w-4 text-muted-foreground" />
+          </CardHeader>
+          <CardContent>
+            <div className="text-2xl font-bold">
+              {templatesLoading ? '...' : (metrics.avgDuration / 1000).toFixed(1)}s
+            </div>
+            <p className="text-xs text-muted-foreground">
+              Per activity execution
+            </p>
+          </CardContent>
+        </Card>
+      </div>
+
+      {/* Second Row - Total Cost moved here */}
+      <div className="grid gap-4 md:grid-cols-2 lg:grid-cols-4">
+        {/* Total Cost */}
+        <Card>
+          <CardHeader className="flex flex-row items-center justify-between space-y-0 pb-2">
+            <CardTitle className="text-sm font-medium">Total Cost</CardTitle>
+            <DollarSign className="h-4 w-4 text-muted-foreground" />
+          </CardHeader>
+          <CardContent>
+            <div className="text-2xl font-bold">
+              ${templatesLoading ? '...' : metrics.totalCost.toFixed(2)}
+            </div>
+            <p className="text-xs text-muted-foreground">
+              ${metrics.totalExecutions > 0 ? (metrics.totalCost / metrics.totalExecutions).toFixed(3) : '0.000'} per execution
+            </p>
+          </CardContent>
+        </Card>
+      </div>
+
+      {/* MiniBob Instances */}
+      <Card>
+        <CardHeader>
+          <CardTitle className="flex items-center gap-2">
+            <Cpu className="h-5 w-5" />
+            MiniBob Instances
+          </CardTitle>
+          <CardDescription>
+            Connected execution vessels (future: live K8s pod monitoring)
+          </CardDescription>
+        </CardHeader>
+        <CardContent>
+          <div className="space-y-3">
+            {/* Placeholder for MiniBob pods - will be populated via K8s API or metrics */}
+            <div className="flex items-center justify-between p-3 border rounded-lg">
+              <div className="flex items-center gap-3">
+                <div className="h-2 w-2 rounded-full bg-green-500 animate-pulse" />
+                <div>
+                  <div className="font-medium">minibob-cluster-0</div>
+                  <div className="text-xs text-muted-foreground">Namespace: activity-system</div>
+                </div>
+              </div>
+              <Badge variant="outline">Idle</Badge>
+            </div>
+
+            <div className="text-center p-6 border-2 border-dashed rounded-lg">
+              <Database className="h-8 w-8 mx-auto mb-2 text-muted-foreground" />
+              <p className="text-sm text-muted-foreground">
+                Additional MiniBob instances will appear here
+              </p>
+              <p className="text-xs text-muted-foreground mt-1">
+                Deploy more vessels to scale execution capacity
+              </p>
+            </div>
+          </div>
+        </CardContent>
+      </Card>
+
+      {/* Learning System Health */}
+      <Card>
+        <CardHeader>
+          <CardTitle className="flex items-center gap-2">
+            <TrendingUp className="h-5 w-5" />
+            Learning System Status
+          </CardTitle>
+          <CardDescription>
+            Thompson sampling and adaptive template selection
+          </CardDescription>
+        </CardHeader>
+        <CardContent>
+          <div className="space-y-4">
+            <div className="grid grid-cols-3 gap-4 text-center">
+              <div>
+                <div className="text-2xl font-bold">{total || 0}</div>
+                <div className="text-xs text-muted-foreground">Templates</div>
+              </div>
+              <div>
+                <div className="text-2xl font-bold">
+                  {templatesLoading ? '...' : metrics.activeTemplates}
+                </div>
+                <div className="text-xs text-muted-foreground">Active (0+ exec)</div>
+              </div>
+              <div>
+                <div className="text-2xl font-bold">
+                  {metrics.successRate > 0 ? metrics.successRate.toFixed(0) : '0'}%
+                </div>
+                <div className="text-xs text-muted-foreground">Avg Success</div>
+              </div>
+            </div>
+
+            <div className="pt-4 border-t">
+              <div className="text-sm font-medium mb-2">Thompson Sampling Status</div>
+              <div className="text-xs text-muted-foreground space-y-1">
+                <div>✓ Bayesian optimization enabled</div>
+                <div>✓ Exploration/exploitation balanced</div>
+                <div>✓ Real-time metric updates via API</div>
+              </div>
+            </div>
+          </div>
+        </CardContent>
+      </Card>
+    </div>
+  );
+}