@automagik/genie 0.260202.1607 → 0.260202.1901

package/src/term-commands/workers.ts

@@ -0,0 +1,298 @@
+/**
+ * Workers command - Show worker status
+ *
+ * Usage:
+ *   term workers           - List all workers and their states
+ *   term workers --json    - Output as JSON
+ *   term workers --watch   - Live updates (TODO: Phase 1.5)
+ */
+
+import { $ } from 'bun';
+import * as tmux from '../lib/tmux.js';
+import * as registry from '../lib/worker-registry.js';
+import * as beadsRegistry from '../lib/beads-registry.js';
+import { detectState, stripAnsi } from '../lib/orchestrator/index.js';
+
+// Use beads registry when enabled
+const useBeads = beadsRegistry.isBeadsRegistryEnabled();
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export interface WorkersOptions {
+  json?: boolean;
+  watch?: boolean;
+}
+
+interface WorkerDisplay {
+  name: string;
+  pane: string;
+  task: string;
+  state: string;
+  time: string;
+  alive: boolean;
+}
+
+// ============================================================================
+// Helper Functions
+// ============================================================================
+
+/**
+ * Check if a pane still exists
+ */
+async function isPaneAlive(paneId: string): Promise<boolean> {
+  try {
+    await tmux.capturePaneContent(paneId, 1);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get current state from pane output
+ */
+async function getCurrentState(paneId: string): Promise<string> {
+  try {
+    const output = await tmux.capturePaneContent(paneId, 30);
+    const state = detectState(output);
+
+    // Map to display format
+    switch (state.type) {
+      case 'working':
+      case 'tool_use':
+        return 'working';
+      case 'idle':
+        return 'idle';
+      case 'permission':
+        return '⚠️ perm';
+      case 'question':
+        return '⚠️ question';
+      case 'error':
+        return '❌ error';
+      case 'complete':
+        return '✅ done';
+      default:
+        return state.type;
+    }
+  } catch {
+    return 'unknown';
+  }
+}
+
+/**
+ * Get beads queue status
+ */
+async function getQueueStatus(): Promise<{ ready: string[]; blocked: string[] }> {
+  const ready: string[] = [];
+  const blocked: string[] = [];
+
+  try {
+    // Get ready issues
+    const readyResult = await $`bd ready --json`.quiet();
+    const readyOutput = readyResult.stdout.toString().trim();
+    if (readyOutput) {
+      try {
+        const issues = JSON.parse(readyOutput);
+        for (const issue of issues) {
+          ready.push(`${issue.id}`);
+        }
+      } catch {
+        // Parse line-based format
+        const lines = readyOutput.split('\n').filter(l => l.trim());
+        for (const line of lines) {
+          const match = line.match(/^(bd-\d+)/);
+          if (match) ready.push(match[1]);
+        }
+      }
+    }
+  } catch {
+    // Ignore bd errors
+  }
+
+  try {
+    // Get blocked issues
+    const listResult = await $`bd list --json`.quiet();
+    const listOutput = listResult.stdout.toString().trim();
+    if (listOutput) {
+      try {
+        const issues = JSON.parse(listOutput);
+        for (const issue of issues) {
+          if (issue.blockedBy && issue.blockedBy.length > 0) {
+            blocked.push(`${issue.id} (blocked by ${issue.blockedBy.join(', ')})`);
+          }
+        }
+      } catch {
+        // Ignore parse errors
+      }
+    }
+  } catch {
+    // Ignore bd errors
+  }
+
+  return { ready, blocked };
+}
+
+/**
+ * Format time elapsed
+ */
+function formatElapsed(startedAt: string): string {
+  const startTime = new Date(startedAt).getTime();
+  const ms = Date.now() - startTime;
+  const minutes = Math.floor(ms / 60000);
+  const hours = Math.floor(minutes / 60);
+
+  if (hours > 0) {
+    return `${hours}h ${minutes % 60}m`;
+  } else if (minutes > 0) {
+    return `${minutes}m`;
+  }
+  return '<1m';
+}
+
+// ============================================================================
+// Main Command
+// ============================================================================
+
+export async function workersCommand(options: WorkersOptions = {}): Promise<void> {
+  try {
+    // Get workers from beads or JSON registry
+    // During transition, merge results from both
+    let workers: registry.Worker[] = [];
+
+    if (useBeads) {
+      try {
+        const beadsWorkers = await beadsRegistry.listWorkers();
+        workers = beadsWorkers;
+      } catch {
+        // Fallback to JSON registry
+        workers = await registry.list();
+      }
+    } else {
+      workers = await registry.list();
+    }
+
+    // Also check JSON registry for any workers not in beads
+    const jsonWorkers = await registry.list();
+    const beadsIds = new Set(workers.map(w => w.id));
+    for (const jw of jsonWorkers) {
+      if (!beadsIds.has(jw.id)) {
+        workers.push(jw);
+      }
+    }
+
+    // Gather display data for each worker
+    const displayData: WorkerDisplay[] = [];
+
+    for (const worker of workers) {
+      const alive = await isPaneAlive(worker.paneId);
+      let currentState = worker.state;
+
+      if (alive) {
+        // Get live state from pane
+        currentState = await getCurrentState(worker.paneId);
+
+        // Update both registries if state differs
+        const mappedState = mapDisplayStateToRegistry(currentState);
+        if (mappedState && mappedState !== worker.state) {
+          if (useBeads) {
+            // Update beads and send heartbeat
+            await beadsRegistry.updateState(worker.id, mappedState).catch(() => {});
+          }
+          await registry.updateState(worker.id, mappedState);
+        } else if (useBeads) {
+          // Just send heartbeat even if state unchanged
+          await beadsRegistry.heartbeat(worker.id).catch(() => {});
+        }
+      } else {
+        currentState = '💀 dead';
+      }
+
+      displayData.push({
+        name: worker.id,
+        pane: worker.paneId,
+        task: worker.taskTitle
+          ? `"${worker.taskTitle.substring(0, 25)}${worker.taskTitle.length > 25 ? '...' : ''}"`
+          : worker.taskId,
+        state: currentState,
+        time: formatElapsed(worker.startedAt),
+        alive,
+      });
+    }
+
+    // Get queue status
+    const queue = await getQueueStatus();
+
+    // Filter out dead workers from ready count
+    const activeTaskIds = workers.filter(w => displayData.find(d => d.name === w.id && d.alive)).map(w => w.taskId);
+    const actuallyReady = queue.ready.filter(id => !activeTaskIds.includes(id));
+
+    if (options.json) {
+      console.log(JSON.stringify({
+        workers: displayData,
+        queue: {
+          ready: actuallyReady,
+          blocked: queue.blocked,
+        },
+      }, null, 2));
+      return;
+    }
+
+    // Display workers table
+    console.log('┌─────────────────────────────────────────────────────────────────┐');
+    console.log('│ WORKERS                                                         │');
+    console.log('├──────────┬──────────┬───────────────────────────┬──────────┬────┤');
+    console.log('│ Name     │ Pane     │ Task                      │ State    │Time│');
+    console.log('├──────────┼──────────┼───────────────────────────┼──────────┼────┤');
+
+    if (displayData.length === 0) {
+      console.log('│ (no workers)                                                    │');
+    } else {
+      for (const w of displayData) {
+        const name = w.name.padEnd(8).substring(0, 8);
+        const pane = w.pane.padEnd(8).substring(0, 8);
+        const task = w.task.padEnd(25).substring(0, 25);
+        const state = w.state.padEnd(8).substring(0, 8);
+        const time = w.time.padStart(4).substring(0, 4);
+        console.log(`│ ${name} │ ${pane} │ ${task} │ ${state} │${time}│`);
+      }
+    }
+
+    console.log('└──────────┴──────────┴───────────────────────────┴──────────┴────┘');
+
+    // Display queue
+    if (queue.blocked.length > 0) {
+      console.log(`\nBlocked: ${queue.blocked.slice(0, 5).join(', ')}${queue.blocked.length > 5 ? '...' : ''}`);
+    }
+
+    if (actuallyReady.length > 0) {
+      console.log(`Ready: ${actuallyReady.slice(0, 5).join(', ')}${actuallyReady.length > 5 ? '...' : ''}`);
+    } else if (displayData.length > 0) {
+      console.log(`\nReady: (none - all assigned or blocked)`);
+    }
+
+    // Cleanup dead workers (optional - could prompt)
+    const deadWorkers = displayData.filter(w => !w.alive);
+    if (deadWorkers.length > 0) {
+      console.log(`\n⚠️  ${deadWorkers.length} dead worker(s) detected. Run \`term kill <name>\` to clean up.`);
+    }
+
+  } catch (error: any) {
+    console.error(`❌ Error: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+/**
+ * Map display state to registry state
+ */
+function mapDisplayStateToRegistry(displayState: string): registry.WorkerState | null {
+  if (displayState === 'working') return 'working';
+  if (displayState === 'idle') return 'idle';
+  if (displayState === '⚠️ perm') return 'permission';
+  if (displayState === '⚠️ question') return 'question';
+  if (displayState === '❌ error') return 'error';
+  if (displayState === '✅ done') return 'done';
+  return null;
+}

package/src/term.ts

@@ -15,6 +15,12 @@ import * as windowCmd from './term-commands/window.js';
 import * as paneCmd from './term-commands/pane.js';
 import * as statusCmd from './term-commands/status.js';
 import * as shortcutsCmd from './term-commands/shortcuts.js';
+import * as orchestrateCmd from './term-commands/orchestrate.js';
+import * as workCmd from './term-commands/work.js';
+import * as workersCmd from './term-commands/workers.js';
+import * as closeCmd from './term-commands/close.js';
+import * as killCmd from './term-commands/kill.js';
+import * as daemonCmd from './term-commands/daemon.js';
 
 const program = new Command();
 
@@ -28,7 +34,15 @@ Collaborative Usage:
   AI reads:   term read genie
 
 Workflow: new → exec → read → rm
-Full control: window new/ls/rm, pane ls/rm, split, status`)
+Full control: window new/ls/rm, pane ls/rm, split, status
+
+Worker Orchestration:
+  term work <bd-id>   - Spawn worker bound to beads issue
+  term work next      - Work on next ready issue
+  term workers        - List all workers and states
+  term close <bd-id>  - Close issue, cleanup worker
+  term kill <worker>  - Force kill a stuck worker
+  term daemon start   - Start beads daemon for auto-sync`)
   .version(VERSION);
 
 // Session management
@@ -200,4 +214,216 @@ program
     await shortcutsCmd.handleShortcuts(options);
   });
 
+// Worker management commands (beads + Claude orchestration)
+program
+  .command('work <target>')
+  .description('Spawn worker bound to beads issue (target: bd-id, "next", or "wish")')
+  .option('--no-worktree', 'Use shared repo instead of worktree')
+  .option('-s, --session <name>', 'Target tmux session')
+  .option('--no-focus', 'Don\'t focus the worker pane')
+  .option('-p, --prompt <message>', 'Custom initial prompt')
+  .action(async (target: string, options: workCmd.WorkOptions) => {
+    await workCmd.workCommand(target, options);
+  });
+
+program
+  .command('workers')
+  .description('List all workers and their states')
+  .option('--json', 'Output as JSON')
+  .option('-w, --watch', 'Live updates (coming soon)')
+  .action(async (options: workersCmd.WorkersOptions) => {
+    if (options.watch) {
+      console.log('ℹ️  --watch mode coming in Phase 1.5');
+    }
+    await workersCmd.workersCommand(options);
+  });
+
+program
+  .command('close <task-id>')
+  .description('Close beads issue and cleanup worker')
+  .option('--no-sync', 'Skip bd sync')
+  .option('--keep-worktree', 'Don\'t remove the worktree')
+  .option('--merge', 'Merge worktree changes to main branch')
+  .option('-y, --yes', 'Skip confirmation')
+  .action(async (taskId: string, options: closeCmd.CloseOptions) => {
+    await closeCmd.closeCommand(taskId, options);
+  });
+
+program
+  .command('kill <worker>')
+  .description('Force kill a worker')
+  .option('-y, --yes', 'Skip confirmation')
+  .option('--keep-worktree', 'Don\'t remove the worktree')
+  .action(async (worker: string, options: killCmd.KillOptions) => {
+    await killCmd.killCommand(worker, options);
+  });
+
+// Approve command (shortcut to orc approve for worker use)
+program
+  .command('approve <worker>')
+  .description('Approve pending permission request for a worker')
+  .option('--deny', 'Deny instead of approve')
+  .action(async (worker: string, options: { deny?: boolean }) => {
+    // Find worker to get pane
+    const registry = await import('./lib/worker-registry.js');
+    let workerInfo = await registry.get(worker);
+    if (!workerInfo) {
+      workerInfo = await registry.findByTask(worker);
+    }
+    if (!workerInfo) {
+      console.error(`❌ Worker "${worker}" not found. Run \`term workers\` to see workers.`);
+      process.exit(1);
+    }
+    await orchestrateCmd.approvePermission(workerInfo.session, {
+      pane: workerInfo.paneId,
+      deny: options.deny,
+    });
+  });
+
+// Answer command (shortcut to orc answer for worker use)
+program
+  .command('answer <worker> <choice>')
+  .description('Answer a question for a worker (use "text:..." for text input)')
+  .action(async (worker: string, choice: string) => {
+    const registry = await import('./lib/worker-registry.js');
+    let workerInfo = await registry.get(worker);
+    if (!workerInfo) {
+      workerInfo = await registry.findByTask(worker);
+    }
+    if (!workerInfo) {
+      console.error(`❌ Worker "${worker}" not found. Run \`term workers\` to see workers.`);
+      process.exit(1);
+    }
+    await orchestrateCmd.answerQuestion(workerInfo.session, choice, {
+      pane: workerInfo.paneId,
+    });
+  });
+
+// Daemon management (beads auto-sync)
+const daemonProgram = program.command('daemon').description('Manage beads daemon for auto-sync');
+
+daemonProgram
+  .command('start')
+  .description('Start beads daemon (auto-commit, auto-sync)')
+  .option('--no-auto-commit', 'Disable auto-commit')
+  .option('--auto-push', 'Enable auto-push to remote')
+  .action(async (options: daemonCmd.DaemonStartOptions) => {
+    await daemonCmd.startCommand(options);
+  });
+
+daemonProgram
+  .command('stop')
+  .description('Stop beads daemon')
+  .action(async () => {
+    await daemonCmd.stopCommand();
+  });
+
+daemonProgram
+  .command('status')
+  .description('Show daemon status')
+  .option('--json', 'Output as JSON')
+  .action(async (options: daemonCmd.DaemonStatusOptions) => {
+    await daemonCmd.statusCommand(options);
+  });
+
+daemonProgram
+  .command('restart')
+  .description('Restart beads daemon')
+  .option('--no-auto-commit', 'Disable auto-commit')
+  .option('--auto-push', 'Enable auto-push to remote')
+  .action(async (options: daemonCmd.DaemonStartOptions) => {
+    await daemonCmd.restartCommand(options);
+  });
+
+// Orchestration commands (Claude Code automation)
+const orcProgram = program.command('orc').description('Orchestrate Claude Code sessions');
+
+orcProgram
+  .command('start <session>')
+  .description('Start Claude Code in a session with optional monitoring')
+  .option('-p, --pane <id>', 'Target specific pane ID (e.g., %16)')
+  .option('-m, --monitor', 'Enable real-time event monitoring')
+  .option('-c, --command <cmd>', 'Command to run instead of claude')
+  .option('--json', 'Output events as JSON')
+  .action(async (session: string, options: orchestrateCmd.StartOptions) => {
+    await orchestrateCmd.startSession(session, options);
+  });
+
+orcProgram
+  .command('send <session> <message>')
+  .description('Send message to Claude and track completion')
+  .option('--pane <id>', 'Target specific pane ID (e.g., %16)')
+  .option('--method <name>', 'Completion detection method')
+  .option('-t, --timeout <ms>', 'Timeout in milliseconds')
+  .option('--no-wait', 'Send without waiting for completion')
+  .option('--json', 'Output as JSON')
+  .action(async (session: string, message: string, options: orchestrateCmd.SendOptions) => {
+    await orchestrateCmd.sendMessage(session, message, options);
+  });
+
+orcProgram
+  .command('status <session>')
+  .description('Show current Claude state and details')
+  .option('--pane <id>', 'Target specific pane ID (e.g., %16)')
+  .option('--json', 'Output as JSON')
+  .action(async (session: string, options: orchestrateCmd.StatusOptions) => {
+    await orchestrateCmd.showStatus(session, options);
+  });
+
+orcProgram
+  .command('watch <session>')
+  .description('Watch session events in real-time')
+  .option('--pane <id>', 'Target specific pane ID (e.g., %16)')
+  .option('--json', 'Output events as JSON')
+  .option('-p, --poll <ms>', 'Poll interval in milliseconds')
+  .action(async (session: string, options: orchestrateCmd.WatchOptions) => {
+    await orchestrateCmd.watchSession(session, options);
+  });
+
+orcProgram
+  .command('approve <session>')
+  .description('Approve pending permission request')
+  .option('-p, --pane <id>', 'Specific pane ID to target')
+  .option('--auto', 'Auto-approve all future permissions (dangerous!)')
+  .option('--deny', 'Deny instead of approve')
+  .action(async (session: string, options: orchestrateCmd.ApproveOptions) => {
+    await orchestrateCmd.approvePermission(session, options);
+  });
+
+orcProgram
+  .command('answer <session> <choice>')
+  .description('Answer a question with the given choice (use "text:..." to send feedback)')
+  .option('-p, --pane <id>', 'Specific pane ID to target')
+  .action(async (session: string, choice: string, options: { pane?: string }) => {
+    await orchestrateCmd.answerQuestion(session, choice, options);
+  });
+
+orcProgram
+  .command('experiment <method>')
+  .description('Test a completion detection method')
+  .option('-n, --runs <number>', 'Number of test runs')
+  .option('--task <command>', 'Test command to run')
+  .option('--json', 'Output as JSON')
+  .action(async (method: string, options: orchestrateCmd.ExperimentOptions) => {
+    await orchestrateCmd.runExperiment(method, options);
+  });
+
+orcProgram
+  .command('methods')
+  .description('List available completion detection methods')
+  .action(async () => {
+    await orchestrateCmd.listMethods();
+  });
+
+orcProgram
+  .command('run <session> <message>')
+  .description('Send task and auto-approve until idle (fire-and-forget)')
+  .option('-p, --pane <id>', 'Target specific pane ID (e.g., %16)')
+  .option('-a, --auto-approve', 'Auto-approve permissions and plans')
+  .option('-t, --timeout <ms>', 'Timeout in milliseconds (default: 300000)')
+  .option('--json', 'Output final state as JSON')
+  .action(async (session: string, message: string, options: orchestrateCmd.RunOptions) => {
+    await orchestrateCmd.runTask(session, message, options);
+  });
+
 program.parse();