@automagik/genie 0.260202.530 → 0.260202.1833

package/src/term-commands/read.ts

@@ -1,4 +1,5 @@
 import * as logReader from '../lib/log-reader.js';
+import { getTerminalConfig } from '../lib/genie-config.js';
 
 export interface ReadOptions {
   lines?: string;
@@ -15,9 +16,13 @@ export interface ReadOptions {
 
 export async function readSessionLogs(sessionName: string, options: ReadOptions): Promise<void> {
   try {
+    // Use config default if no lines specified
+    const termConfig = getTerminalConfig();
+    const defaultLines = termConfig.readLines;
+
     // Parse options
     const readOptions: logReader.ReadOptions = {
-      lines: options.lines ? parseInt(options.lines, 10) : 100,
+      lines: options.lines ? parseInt(options.lines, 10) : defaultLines,
       from: options.from ? parseInt(options.from, 10) : undefined,
       to: options.to ? parseInt(options.to, 10) : undefined,
       range: options.range,

package/src/term-commands/shortcuts.ts

@@ -15,13 +15,13 @@ export function generateTmuxConfig(): string {
 # To use: add to ~/.tmux.conf or source this file
 
 # Ctrl+T: New window (tab) in current session
-bind-key -n C-t new-window
+bind-key -n C-t new-window -c "#{pane_current_path}"
 
 # Ctrl+S: Vertical split (requires stty -ixon in shell rc)
-bind-key -n C-s split-window -v
+bind-key -n C-s split-window -v -c "#{pane_current_path}"
 
-# Ctrl+H: Horizontal split
-bind-key -n C-h split-window -h
+# Ctrl+Shift+S: Horizontal split
+bind-key -n C-S split-window -h -c "#{pane_current_path}"
 `;
 }
 
@@ -49,7 +49,7 @@ genie-new-tab() {
   local session
   session=$(tmux display-message -p '#S' 2>/dev/null)
   if [ -n "$session" ]; then
-    tmux new-window
+    tmux new-window -c "#{pane_current_path}"
   else
     echo "Not in a tmux session"
   fi
@@ -57,7 +57,7 @@ genie-new-tab() {
 
 genie-vsplit() {
   if tmux display-message -p '#S' >/dev/null 2>&1; then
-    tmux split-window -v
+    tmux split-window -v -c "#{pane_current_path}"
   else
     echo "Not in a tmux session"
   fi
@@ -65,7 +65,7 @@ genie-vsplit() {
 
 genie-hsplit() {
   if tmux display-message -p '#S' >/dev/null 2>&1; then
-    tmux split-window -h
+    tmux split-window -h -c "#{pane_current_path}"
   else
     echo "Not in a tmux session"
   fi
@@ -83,13 +83,13 @@ export function displayShortcuts(): void {
   console.log(`
 Warp-like Terminal Shortcuts for tmux + Termux
 
-┌────────────┬────────────────────────────────────────┐
-│ Shortcut   │ Action                                 │
-├────────────┼────────────────────────────────────────┤
-│ Ctrl+T     │ New tab (window) in current session    │
-│ Ctrl+S     │ Vertical split in current session      │
-│ Ctrl+H     │ Horizontal split in current session    │
-└────────────┴────────────────────────────────────────┘
+┌──────────────────┬────────────────────────────────────────┐
+│ Shortcut         │ Action                                 │
+├──────────────────┼────────────────────────────────────────┤
+│ Ctrl+T           │ New tab (window) in current session    │
+│ Ctrl+S           │ Vertical split in current session      │
+│ Ctrl+Shift+S     │ Horizontal split in current session    │
+└──────────────────┴────────────────────────────────────────┘
 
 Termux Extra Keys (F1-F3):
   F1 → New tab       F2 → Vertical split

package/src/term-commands/work.ts

@@ -0,0 +1,415 @@
+/**
+ * Work command - Spawn worker bound to beads issue
+ *
+ * Usage:
+ *   term work <bd-id>     - Work on specific beads issue
+ *   term work next        - Work on next ready issue
+ *   term work wish        - Create a new wish (deferred)
+ *
+ * Options:
+ *   --no-worktree         - Use shared repo instead of worktree
+ *   -s, --session <name>  - Target tmux session
+ *   --focus               - Focus the worker pane (default: true)
+ */
+
+import { $ } from 'bun';
+import * as tmux from '../lib/tmux.js';
+import * as registry from '../lib/worker-registry.js';
+import { WorktreeManager } from '../lib/worktree.js';
+import { EventMonitor, detectState } from '../lib/orchestrator/index.js';
+import { join } from 'path';
+import { homedir } from 'os';
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export interface WorkOptions {
+  noWorktree?: boolean;
+  session?: string;
+  focus?: boolean;
+  prompt?: string;
+}
+
+interface BeadsIssue {
+  id: string;
+  title: string;
+  status: string;
+  blockedBy?: string[];
+}
+
+// ============================================================================
+// Configuration
+// ============================================================================
+
+const WORKTREE_BASE = join(homedir(), '.local', 'share', 'term', 'worktrees');
+
+// ============================================================================
+// Helper Functions
+// ============================================================================
+
+/**
+ * Run bd command and parse output
+ */
+async function runBd(args: string[]): Promise<{ stdout: string; exitCode: number }> {
+  try {
+    const result = await $`bd ${args}`.quiet();
+    return { stdout: result.stdout.toString().trim(), exitCode: 0 };
+  } catch (error: any) {
+    return { stdout: error.stdout?.toString().trim() || '', exitCode: error.exitCode || 1 };
+  }
+}
+
+/**
+ * Get a beads issue by ID
+ */
+async function getBeadsIssue(id: string): Promise<BeadsIssue | null> {
+  const { stdout, exitCode } = await runBd(['show', id, '--json']);
+  if (exitCode !== 0 || !stdout) return null;
+
+  try {
+    const issue = JSON.parse(stdout);
+    return {
+      id: issue.id,
+      title: issue.title || issue.description?.substring(0, 50) || 'Untitled',
+      status: issue.status,
+      blockedBy: issue.blockedBy || [],
+    };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Get next ready beads issue
+ */
+async function getNextReadyIssue(): Promise<BeadsIssue | null> {
+  const { stdout, exitCode } = await runBd(['ready', '--json']);
+  if (exitCode !== 0 || !stdout) return null;
+
+  try {
+    const issues = JSON.parse(stdout);
+    if (Array.isArray(issues) && issues.length > 0) {
+      const issue = issues[0];
+      return {
+        id: issue.id,
+        title: issue.title || issue.description?.substring(0, 50) || 'Untitled',
+        status: issue.status,
+        blockedBy: issue.blockedBy || [],
+      };
+    }
+    return null;
+  } catch {
+    // Try parsing as single issue or line-based format
+    const lines = stdout.split('\n').filter(l => l.trim());
+    if (lines.length > 0) {
+      // Extract ID from first line (format: "bd-1: title" or just "bd-1")
+      const match = lines[0].match(/^(bd-\d+)/);
+      if (match) {
+        return getBeadsIssue(match[1]);
+      }
+    }
+    return null;
+  }
+}
+
+/**
+ * Mark beads issue as in_progress
+ */
+async function claimIssue(id: string): Promise<boolean> {
+  const { exitCode } = await runBd(['update', id, '--status', 'in_progress']);
+  return exitCode === 0;
+}
+
+/**
+ * Get current tmux session name
+ */
+async function getCurrentSession(): Promise<string | null> {
+  try {
+    const result = await tmux.executeTmux(`display-message -p '#{session_name}'`);
+    return result.trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Create worktree for worker
+ */
+async function createWorktree(
+  taskId: string,
+  repoPath: string
+): Promise<string | null> {
+  try {
+    const manager = new WorktreeManager({
+      baseDir: WORKTREE_BASE,
+      repoPath,
+    });
+
+    // Check if worktree already exists
+    if (await manager.worktreeExists(taskId)) {
+      console.log(`ℹ️  Worktree for ${taskId} already exists`);
+      return manager.getWorktreePath(taskId);
+    }
+
+    // Create new worktree with branch
+    const info = await manager.createWorktree(taskId, true);
+    return info.path;
+  } catch (error: any) {
+    console.error(`⚠️  Failed to create worktree: ${error.message}`);
+    return null;
+  }
+}
+
+/**
+ * Spawn Claude worker in new pane
+ */
+async function spawnWorkerPane(
+  session: string,
+  workingDir: string
+): Promise<{ paneId: string } | null> {
+  try {
+    // Find current window
+    const sessionObj = await tmux.findSessionByName(session);
+    if (!sessionObj) {
+      console.error(`❌ Session "${session}" not found`);
+      return null;
+    }
+
+    const windows = await tmux.listWindows(sessionObj.id);
+    if (!windows || windows.length === 0) {
+      console.error(`❌ No windows in session "${session}"`);
+      return null;
+    }
+
+    const panes = await tmux.listPanes(windows[0].id);
+    if (!panes || panes.length === 0) {
+      console.error(`❌ No panes in session "${session}"`);
+      return null;
+    }
+
+    // Split current pane horizontally (side by side)
+    const newPane = await tmux.splitPane(
+      panes[0].id,
+      'horizontal',
+      50,
+      workingDir
+    );
+
+    if (!newPane) {
+      console.error(`❌ Failed to create new pane`);
+      return null;
+    }
+
+    return { paneId: newPane.id };
+  } catch (error: any) {
+    console.error(`❌ Error spawning worker pane: ${error.message}`);
+    return null;
+  }
+}
+
+/**
+ * Start monitoring worker state and update registry
+ */
+function startWorkerMonitoring(
+  workerId: string,
+  session: string,
+  paneId: string
+): void {
+  const monitor = new EventMonitor(session, {
+    pollIntervalMs: 1000,
+    paneId,
+  });
+
+  monitor.on('state_change', async (event) => {
+    if (!event.state) return;
+
+    let newState: registry.WorkerState;
+    switch (event.state.type) {
+      case 'working':
+      case 'tool_use':
+        newState = 'working';
+        break;
+      case 'idle':
+        newState = 'idle';
+        break;
+      case 'permission':
+        newState = 'permission';
+        break;
+      case 'question':
+        newState = 'question';
+        break;
+      case 'error':
+        newState = 'error';
+        break;
+      case 'complete':
+        newState = 'done';
+        break;
+      default:
+        return; // Don't update for unknown states
+    }
+
+    try {
+      await registry.updateState(workerId, newState);
+    } catch {
+      // Ignore errors in background monitoring
+    }
+  });
+
+  monitor.on('poll_error', () => {
+    // Pane may have been killed - unregister worker
+    registry.unregister(workerId).catch(() => {});
+    monitor.stop();
+  });
+
+  monitor.start().catch(() => {
+    // Session/pane not found - ignore
+  });
+
+  // Store monitor reference for cleanup (could be enhanced)
+  // For now, monitoring is fire-and-forget
+}
+
+// ============================================================================
+// Main Command
+// ============================================================================
+
+export async function workCommand(
+  target: string,
+  options: WorkOptions = {}
+): Promise<void> {
+  try {
+    // Get current working directory as repo path
+    const repoPath = process.cwd();
+
+    // 1. Resolve target
+    let issue: BeadsIssue | null = null;
+
+    if (target === 'next') {
+      console.log('🔍 Finding next ready issue...');
+      issue = await getNextReadyIssue();
+      if (!issue) {
+        console.log('ℹ️  No ready issues. Run `bd ready` to see the queue.');
+        return;
+      }
+      console.log(`📋 Found: ${issue.id} - "${issue.title}"`);
+    } else if (target === 'wish') {
+      console.error('❌ `term work wish` is not yet implemented. Coming in Phase 1.5.');
+      process.exit(1);
+    } else {
+      // Validate bd-id exists
+      issue = await getBeadsIssue(target);
+      if (!issue) {
+        console.error(`❌ Issue "${target}" not found. Run \`bd list\` to see issues.`);
+        process.exit(1);
+      }
+    }
+
+    const taskId = issue.id;
+
+    // 2. Check not already assigned
+    const existingWorker = await registry.findByTask(taskId);
+    if (existingWorker) {
+      console.error(`❌ ${taskId} already has a worker (pane ${existingWorker.paneId})`);
+      console.log(`   Run \`term kill ${existingWorker.id}\` first, or work on a different issue.`);
+      process.exit(1);
+    }
+
+    // 3. Get session
+    const session = options.session || await getCurrentSession();
+    if (!session) {
+      console.error('❌ Not in a tmux session. Attach to a session first or use --session.');
+      process.exit(1);
+    }
+
+    // 4. Claim in beads
+    console.log(`📝 Claiming ${taskId}...`);
+    const claimed = await claimIssue(taskId);
+    if (!claimed) {
+      console.error(`❌ Failed to claim ${taskId}. Check \`bd show ${taskId}\`.`);
+      process.exit(1);
+    }
+
+    // 5. Create worktree (unless --no-worktree)
+    let workingDir = repoPath;
+    let worktreePath: string | null = null;
+
+    if (!options.noWorktree) {
+      console.log(`🌳 Creating worktree for ${taskId}...`);
+      worktreePath = await createWorktree(taskId, repoPath);
+      if (worktreePath) {
+        workingDir = worktreePath;
+        console.log(`   Created: ${worktreePath}`);
+      } else {
+        console.log(`⚠️  Worktree creation failed. Using shared repo.`);
+      }
+    }
+
+    // 6. Spawn Claude pane
+    console.log(`🚀 Spawning worker pane...`);
+    const paneResult = await spawnWorkerPane(session, workingDir);
+    if (!paneResult) {
+      process.exit(1);
+    }
+
+    const { paneId } = paneResult;
+
+    // 7. Register worker
+    const worker: registry.Worker = {
+      id: taskId,
+      paneId,
+      session,
+      worktree: worktreePath,
+      taskId,
+      taskTitle: issue.title,
+      startedAt: new Date().toISOString(),
+      state: 'spawning',
+      lastStateChange: new Date().toISOString(),
+      repoPath,
+    };
+
+    await registry.register(worker);
+
+    // 8. Start Claude in pane
+    await tmux.executeCommand(paneId, 'claude', false, false);
+
+    // Wait a bit for Claude to start
+    await new Promise(r => setTimeout(r, 2000));
+
+    // 9. Send initial prompt
+    const prompt = options.prompt || `Work on beads issue ${taskId}: "${issue.title}"
+
+Read the issue details with: bd show ${taskId}
+
+When you're done, commit your changes and let me know.`;
+
+    await tmux.executeCommand(paneId, prompt, false, false);
+
+    // 10. Update state to working
+    await registry.updateState(taskId, 'working');
+
+    // 11. Start monitoring
+    startWorkerMonitoring(taskId, session, paneId);
+
+    // 12. Focus pane (unless disabled)
+    if (options.focus !== false) {
+      await tmux.executeTmux(`select-pane -t '${paneId}'`);
+    }
+
+    console.log(`\n✅ Worker started for ${taskId}`);
+    console.log(`   Pane: ${paneId}`);
+    console.log(`   Session: ${session}`);
+    if (worktreePath) {
+      console.log(`   Worktree: ${worktreePath}`);
+    }
+    console.log(`\nCommands:`);
+    console.log(`   term workers        - Check worker status`);
+    console.log(`   term approve ${taskId}  - Approve permissions`);
+    console.log(`   term close ${taskId}    - Close issue when done`);
+    console.log(`   term kill ${taskId}     - Force kill worker`);
+
+  } catch (error: any) {
+    console.error(`❌ Error: ${error.message}`);
+    process.exit(1);
+  }
+}