@automagik/genie 0.260202.530 → 0.260202.1833

package/src/term-commands/workers.ts

@@ -0,0 +1,264 @@
+/**
+ * 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 { detectState, stripAnsi } from '../lib/orchestrator/index.js';
+
+// ============================================================================
+// 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 {
+    const workers = await registry.list();
+
+    // 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 registry if state differs
+        const mappedState = mapDisplayStateToRegistry(currentState);
+        if (mappedState && mappedState !== worker.state) {
+          await registry.updateState(worker.id, mappedState);
+        }
+      } 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,11 @@ 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';
 
 const program = new Command();
 
@@ -22,8 +27,20 @@ program
   .name('term')
   .description(`AI-friendly terminal orchestration (tmux wrapper)
 
+Collaborative Usage:
+  AI runs:    term exec genie:shell '<command>'
+  Human watches: tmux attach -t genie
+  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`)
   .version(VERSION);
 
 // Session management
@@ -81,8 +98,13 @@ program
 program
   .command('exec <session> <command...>')
   .description('Execute command in a tmux session')
-  .action(async (session: string, command: string[]) => {
-    await execCmd.executeInSession(session, command.join(' '));
+  .option('-q, --quiet', 'Suppress stdout output')
+  .option('-t, --timeout <ms>', 'Timeout in milliseconds (default: 120000)')
+  .action(async (session: string, command: string[], options: { quiet?: boolean; timeout?: string }) => {
+    await execCmd.executeInSession(session, command.join(' '), {
+      quiet: options.quiet,
+      timeout: options.timeout ? parseInt(options.timeout, 10) : undefined,
+    });
   });
 
 program
@@ -190,4 +212,180 @@ 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,
+    });
+  });
+
+// 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();

package/src/types/genie-config.ts

@@ -1,112 +1,80 @@
 import { z } from 'zod';
 
 /**
- * Genie Configuration Schema
+ * Genie Configuration Schema v2
  *
  * Stored at ~/.genie/config.json
- * Manages hook presets and session configuration for the genie CLI.
+ * Manages session configuration, terminal defaults, and shortcuts for the genie CLI.
  */
 
-// Sandboxed preset configuration
-export const SandboxedConfigSchema = z.object({
-  allowedPaths: z.array(z.string()).default(['~/projects', '/tmp']),
-});
-
-// Audited preset configuration
-export const AuditedConfigSchema = z.object({
-  logPath: z.string().default('~/.genie/audit.log'),
-});
-
-// Supervised preset configuration
-export const SupervisedConfigSchema = z.object({
-  alwaysAsk: z.array(z.string()).default(['Write', 'Edit']),
+// Session configuration
+export const SessionConfigSchema = z.object({
+  name: z.string().default('genie'),
+  defaultWindow: z.string().default('shell'),
+  autoCreate: z.boolean().default(true),
 });
 
-// Collaborative preset configuration
-export const CollaborativeConfigSchema = z.object({
-  sessionName: z.string().default('genie'),
-  windowName: z.string().default('shell'),
+// Terminal configuration
+export const TerminalConfigSchema = z.object({
+  execTimeout: z.number().default(120000),
+  readLines: z.number().default(100),
+  worktreeBase: z.string().default('.worktrees'),
 });
 
 // Logging configuration
 export const LoggingConfigSchema = z.object({
   tmuxDebug: z.boolean().default(false),
+  verbose: z.boolean().default(false),
 });
 
-// Hook presets configuration
-export const HooksConfigSchema = z.object({
-  enabled: z.array(z.enum(['collaborative', 'supervised', 'sandboxed', 'audited'])).default([]),
-  collaborative: CollaborativeConfigSchema.optional(),
-  supervised: SupervisedConfigSchema.optional(),
-  sandboxed: SandboxedConfigSchema.optional(),
-  audited: AuditedConfigSchema.optional(),
+// Shell configuration
+export const ShellConfigSchema = z.object({
+  preference: z.enum(['auto', 'zsh', 'bash', 'fish']).default('auto'),
 });
 
-// Session configuration
-export const SessionConfigSchema = z.object({
-  name: z.string().default('genie'),
-  defaultWindow: z.string().default('shell'),
+// Shortcuts configuration
+export const ShortcutsConfigSchema = z.object({
+  tmuxInstalled: z.boolean().default(false),
+  shellInstalled: z.boolean().default(false),
+});
+
+// Claudio integration configuration
+export const ClaudioConfigSchema = z.object({
+  enabled: z.boolean().default(false),
 });
 
 // Full genie configuration
 export const GenieConfigSchema = z.object({
-  hooks: HooksConfigSchema.default({}),
+  version: z.number().default(2),
   session: SessionConfigSchema.default({}),
+  terminal: TerminalConfigSchema.default({}),
   logging: LoggingConfigSchema.default({}),
+  shell: ShellConfigSchema.default({}),
+  shortcuts: ShortcutsConfigSchema.default({}),
+  claudio: ClaudioConfigSchema.optional(),
+  installMethod: z.enum(['source', 'npm', 'bun']).optional(),
+  setupComplete: z.boolean().default(false),
+  lastSetupAt: z.string().optional(),
+});
+
+// Legacy v1 config schema (for migration)
+export const GenieConfigV1Schema = z.object({
+  session: z.object({
+    name: z.string().default('genie'),
+    defaultWindow: z.string().default('shell'),
+  }).default({}),
+  logging: z.object({
+    tmuxDebug: z.boolean().default(false),
+  }).default({}),
   installMethod: z.enum(['source', 'npm', 'bun']).optional(),
 });
 
 // Inferred types
-export type SandboxedConfig = z.infer<typeof SandboxedConfigSchema>;
-export type AuditedConfig = z.infer<typeof AuditedConfigSchema>;
-export type SupervisedConfig = z.infer<typeof SupervisedConfigSchema>;
-export type CollaborativeConfig = z.infer<typeof CollaborativeConfigSchema>;
-export type HooksConfig = z.infer<typeof HooksConfigSchema>;
 export type SessionConfig = z.infer<typeof SessionConfigSchema>;
+export type TerminalConfig = z.infer<typeof TerminalConfigSchema>;
 export type LoggingConfig = z.infer<typeof LoggingConfigSchema>;
+export type ShellConfig = z.infer<typeof ShellConfigSchema>;
+export type ShortcutsConfig = z.infer<typeof ShortcutsConfigSchema>;
+export type ClaudioConfig = z.infer<typeof ClaudioConfigSchema>;
 export type GenieConfig = z.infer<typeof GenieConfigSchema>;
-
-// Preset names type
-export type PresetName = 'collaborative' | 'supervised' | 'sandboxed' | 'audited';
-
-// Preset description for UI
-export interface PresetDescription {
-  name: PresetName;
-  title: string;
-  what: string;
-  why: string;
-  how: string;
-  recommended?: boolean;
-}
-
-export const PRESET_DESCRIPTIONS: PresetDescription[] = [
-  {
-    name: 'collaborative',
-    title: 'Collaborative',
-    what: 'All terminal commands run through tmux',
-    why: 'You can watch AI work in real-time',
-    how: 'Bash commands → term exec genie:shell',
-    recommended: true,
-  },
-  {
-    name: 'supervised',
-    title: 'Supervised',
-    what: 'File changes require your approval',
-    why: 'Prevents accidental overwrites',
-    how: 'Write/Edit tools always ask permission',
-  },
-  {
-    name: 'sandboxed',
-    title: 'Sandboxed',
-    what: 'Restrict file access to specific directories',
-    why: 'Protects sensitive areas of your system',
-    how: 'Operations outside sandbox are blocked',
-  },
-  {
-    name: 'audited',
-    title: 'Audited',
-    what: 'Log all AI tool usage to a file',
-    why: 'Review what the AI did after a session',
-    how: 'Every tool call → ~/.genie/audit.log',
-  },
-];
+export type GenieConfigV1 = z.infer<typeof GenieConfigV1Schema>;