agileflow 2.89.3 → 2.90.1

package/scripts/session-manager.js

@@ -259,6 +259,23 @@ function unregisterSession(sessionId) {
   }
 }
 
+// Get session by ID
+function getSession(sessionId) {
+  const registry = loadRegistry();
+  const session = registry.sessions[sessionId];
+  if (!session) {
+    return null;
+  }
+  // Ensure thread_type exists (migration for legacy sessions)
+  const threadType = session.thread_type || (session.is_main ? 'base' : 'parallel');
+  return {
+    id: sessionId,
+    ...session,
+    thread_type: threadType,
+    active: isSessionActive(sessionId),
+  };
+}
+
 // Create new session with worktree
 function createSession(options = {}) {
   const registry = loadRegistry();
@@ -1006,6 +1023,22 @@ function main() {
       break;
     }
 
+    case 'get': {
+      const sessionId = args[1];
+      if (!sessionId) {
+        console.log(JSON.stringify({ success: false, error: 'Session ID required' }));
+        return;
+      }
+      // Use the exported getSession function for consistency
+      const session = getSession(sessionId);
+      if (!session) {
+        console.log(JSON.stringify({ success: false, error: `Session ${sessionId} not found` }));
+        return;
+      }
+      console.log(JSON.stringify({ success: true, ...session }));
+      break;
+    }
+
     // PERFORMANCE: Combined command for welcome script (saves ~200ms from 3 subprocess calls)
     case 'full-status': {
       const nickname = args[1] || null;
@@ -1248,6 +1281,7 @@ ${c.cyan}Commands:${c.reset}
   count                   Count other active sessions
   delete <id> [--remove-worktree]  Delete session
   status                  Get current session status
+  get <id>                Get specific session by ID
   full-status             Combined register+count+status (optimized)
   switch <id|nickname>    Switch active session context (for /add-dir)
   active                  Get currently switched session (if any)
@@ -1667,14 +1701,47 @@ function resolveConflict(resolution) {
   try {
     switch (gitStrategy) {
       case 'union':
-        // Union merge - keep both sides (works for text files)
-        execSync(`git checkout --ours "${file}" && git checkout --theirs "${file}" --`, {
-          cwd: ROOT,
-          encoding: 'utf8',
-        });
-        // Actually, use git merge-file for union
-        // For simplicity, accept theirs for now and log
-        execSync(`git checkout --theirs "${file}"`, { cwd: ROOT, encoding: 'utf8' });
+        // Union merge - concatenate both versions (works for additive files like docs/tests)
+        // Use git merge-file with --union flag for true union merge
+        // This keeps both ours and theirs changes, separated by markers only if truly conflicting
+        try {
+          // Get the base, ours, and theirs versions
+          const base = spawnSync('git', ['show', `:1:${file}`], { cwd: ROOT, encoding: 'utf8' });
+          const ours = spawnSync('git', ['show', `:2:${file}`], { cwd: ROOT, encoding: 'utf8' });
+          const theirs = spawnSync('git', ['show', `:3:${file}`], { cwd: ROOT, encoding: 'utf8' });
+
+          // If we can get all three, use merge-file with union
+          if (base.status === 0 && ours.status === 0 && theirs.status === 0) {
+            // Write temp files for merge-file
+            const tmpBase = path.join(ROOT, '.git', 'MERGE_BASE_TMP');
+            const tmpOurs = path.join(ROOT, '.git', 'MERGE_OURS_TMP');
+            const tmpTheirs = path.join(ROOT, '.git', 'MERGE_THEIRS_TMP');
+
+            fs.writeFileSync(tmpBase, base.stdout);
+            fs.writeFileSync(tmpOurs, ours.stdout);
+            fs.writeFileSync(tmpTheirs, theirs.stdout);
+
+            // Run merge-file with --union (keeps both sides for conflicts)
+            spawnSync('git', ['merge-file', '--union', tmpOurs, tmpBase, tmpTheirs], {
+              cwd: ROOT,
+              encoding: 'utf8',
+            });
+
+            // Copy merged result to working tree
+            fs.copyFileSync(tmpOurs, path.join(ROOT, file));
+
+            // Cleanup temp files
+            fs.unlinkSync(tmpBase);
+            fs.unlinkSync(tmpOurs);
+            fs.unlinkSync(tmpTheirs);
+          } else {
+            // Fallback: accept theirs for docs/tests (session's additions are more important)
+            execSync(`git checkout --theirs "${file}"`, { cwd: ROOT, encoding: 'utf8' });
+          }
+        } catch (unionError) {
+          // Fallback to theirs on any error
+          execSync(`git checkout --theirs "${file}"`, { cwd: ROOT, encoding: 'utf8' });
+        }
         break;
 
       case 'theirs':
@@ -1689,8 +1756,7 @@ function resolveConflict(resolution) {
 
       case 'recursive':
       default:
-        // Try to use git's recursive strategy
-        // For conflicts, we'll favor theirs (the session's work)
+        // For source code conflicts, favor theirs (the session's work)
         execSync(`git checkout --theirs "${file}"`, { cwd: ROOT, encoding: 'utf8' });
         break;
     }
@@ -1936,6 +2002,7 @@ module.exports = {
   saveRegistry,
   registerSession,
   unregisterSession,
+  getSession,
   createSession,
   getSessions,
   getActiveSessionCount,

package/scripts/tui/App.js

@@ -0,0 +1,151 @@
+'use strict';
+
+const React = require('react');
+const { Box, Text, useInput, useApp } = require('ink');
+const { KeyboardHandler, formatBindings, DEFAULT_BINDINGS } = require('./lib/keyboard');
+
+/**
+ * Main TUI Application Component
+ *
+ * Provides the base layout and keyboard handling for AgileFlow TUI.
+ * Key bindings: Q=quit, S=start, P=pause, R=resume, T=trace, 1-9=sessions
+ */
+function App({
+  children,
+  title = 'AgileFlow TUI',
+  showFooter = true,
+  onAction = null,
+  bindings = DEFAULT_BINDINGS,
+}) {
+  const { exit } = useApp();
+  const [showHelp, setShowHelp] = React.useState(false);
+  const [lastAction, setLastAction] = React.useState(null);
+
+  // Create keyboard handler
+  const keyboardRef = React.useRef(null);
+  if (!keyboardRef.current) {
+    keyboardRef.current = new KeyboardHandler({ bindings });
+  }
+
+  // Set up event listeners
+  React.useEffect(() => {
+    const keyboard = keyboardRef.current;
+
+    keyboard.on('quit', () => exit());
+    keyboard.on('help', () => setShowHelp(prev => !prev));
+
+    // Forward all actions to parent
+    keyboard.on('action', action => {
+      setLastAction(action);
+      if (onAction) {
+        onAction(action);
+      }
+    });
+
+    return () => {
+      keyboard.removeAllListeners();
+    };
+  }, [exit, onAction]);
+
+  // Handle key input
+  useInput((input, key) => {
+    keyboardRef.current.processKey(input, key);
+  });
+
+  // Format footer bindings
+  const footerBindings = formatBindings(bindings);
+
+  return React.createElement(
+    Box,
+    {
+      flexDirection: 'column',
+      width: '100%',
+      minHeight: 20,
+    },
+    // Header
+    React.createElement(
+      Box,
+      {
+        borderStyle: 'round',
+        borderColor: 'cyan',
+        paddingX: 1,
+        justifyContent: 'center',
+      },
+      React.createElement(Text, { bold: true, color: 'cyan' }, title),
+      lastAction && React.createElement(Text, { dimColor: true }, ` [${lastAction.action}]`)
+    ),
+    // Main content area
+    React.createElement(
+      Box,
+      {
+        flexDirection: 'column',
+        flexGrow: 1,
+        paddingX: 1,
+        paddingY: 1,
+      },
+      showHelp ? React.createElement(HelpPanel, { bindings }) : children
+    ),
+    // Footer with key bindings
+    showFooter &&
+      React.createElement(
+        Box,
+        {
+          borderStyle: 'single',
+          borderColor: 'gray',
+          paddingX: 1,
+          justifyContent: 'space-between',
+        },
+        React.createElement(
+          Box,
+          { flexDirection: 'row' },
+          footerBindings.map((binding, i) =>
+            React.createElement(
+              Text,
+              { key: `binding-${i}`, dimColor: true },
+              i > 0 ? ' | ' : '',
+              binding
+            )
+          )
+        ),
+        React.createElement(Text, { dimColor: true }, '1-9:Sessions | AgileFlow v2.89.3')
+      )
+  );
+}
+
+/**
+ * Help Panel component
+ */
+function HelpPanel({ bindings = DEFAULT_BINDINGS }) {
+  const groups = {
+    'Loop Control': ['start', 'pause', 'resume'],
+    View: ['trace', 'help'],
+    Navigation: ['quit'],
+    Sessions: ['session1', 'session2', 'session3'],
+  };
+
+  return React.createElement(
+    Box,
+    { flexDirection: 'column', padding: 1 },
+    React.createElement(Text, { bold: true, color: 'cyan' }, 'Key Bindings'),
+    React.createElement(Box, { marginTop: 1 }),
+    Object.entries(groups).map(([groupName, actions]) =>
+      React.createElement(
+        Box,
+        { key: groupName, flexDirection: 'column', marginBottom: 1 },
+        React.createElement(Text, { bold: true }, groupName + ':'),
+        actions.map(action => {
+          const binding = bindings[action];
+          if (!binding) return null;
+          return React.createElement(
+            Text,
+            { key: action, dimColor: true },
+            `  ${binding.key.toUpperCase()} - ${binding.description}`
+          );
+        })
+      )
+    ),
+    React.createElement(Text, { dimColor: true, marginTop: 1 }, 'Press ? to close help')
+  );
+}
+
+module.exports = { App, HelpPanel };

package/scripts/tui/index.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * AgileFlow TUI - Terminal User Interface
+ *
+ * Real-time visualization for session monitoring, multi-agent orchestration,
+ * and interactive loop control.
+ *
+ * Usage:
+ *   node scripts/tui/index.js
+ *   npx agileflow tui
+ *
+ * Key bindings:
+ *   q - Quit TUI
+ *   s - Start loop on current story
+ *   p - Pause active loop
+ *   r - Resume paused loop
+ *   t - Toggle trace panel
+ *   1-9 - Switch session focus
+ */
+
+// Use the simple TUI implementation (pure Node.js, no React dependencies)
+const { main } = require('./simple-tui');
+
+// Run if executed directly
+if (require.main === module) {
+  main();
+}
+
+module.exports = { main };

package/scripts/tui/lib/crashRecovery.js

@@ -0,0 +1,304 @@
+'use strict';
+
+/**
+ * Crash Recovery - Session state persistence and recovery
+ *
+ * Persists ralph-loop state to enable recovery after crashes.
+ * Stores checkpoints on each iteration and prompts for recovery
+ * when incomplete state is detected.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Get project root
+let getProjectRoot;
+try {
+  getProjectRoot = require('../../../lib/paths').getProjectRoot;
+} catch (e) {
+  getProjectRoot = () => process.cwd();
+}
+
+// Get safe JSON utilities
+let safeReadJSON, safeWriteJSON;
+try {
+  const errors = require('../../../lib/errors');
+  safeReadJSON = errors.safeReadJSON;
+  safeWriteJSON = errors.safeWriteJSON;
+} catch (e) {
+  safeReadJSON = (filePath, opts = {}) => {
+    try {
+      const data = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+      return { ok: true, data };
+    } catch (e) {
+      return { ok: false, error: e.message, data: opts.defaultValue };
+    }
+  };
+  safeWriteJSON = (filePath, data) => {
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
+    return { ok: true };
+  };
+}
+
+/**
+ * Get checkpoint file path
+ */
+function getCheckpointPath(sessionId = 'default') {
+  const rootDir = getProjectRoot();
+  return path.join(rootDir, '.agileflow', 'sessions', `${sessionId}.checkpoint`);
+}
+
+/**
+ * Get session state path
+ */
+function getSessionStatePath() {
+  const rootDir = getProjectRoot();
+  return path.join(rootDir, 'docs', '09-agents', 'session-state.json');
+}
+
+/**
+ * Create checkpoint
+ * Called after each iteration to persist state
+ */
+function createCheckpoint(sessionId = 'default', loopState = null) {
+  const checkpointPath = getCheckpointPath(sessionId);
+
+  // Get current loop state if not provided
+  if (!loopState) {
+    const statePath = getSessionStatePath();
+    const result = safeReadJSON(statePath, { defaultValue: {} });
+    loopState = result.ok ? result.data.ralph_loop : null;
+  }
+
+  if (!loopState || !loopState.enabled) {
+    return { ok: false, error: 'No active loop state to checkpoint' };
+  }
+
+  const checkpoint = {
+    version: 1,
+    session_id: sessionId,
+    created_at: new Date().toISOString(),
+    loop_state: {
+      epic: loopState.epic,
+      current_story: loopState.current_story,
+      iteration: loopState.iteration || 0,
+      max_iterations: loopState.max_iterations || 20,
+      visual_mode: loopState.visual_mode || false,
+      coverage_mode: loopState.coverage_mode || false,
+      coverage_threshold: loopState.coverage_threshold || 80,
+      coverage_current: loopState.coverage_current || 0,
+      started_at: loopState.started_at,
+      conditions: loopState.conditions || [],
+    },
+    recovery_info: {
+      can_resume: true,
+      last_checkpoint: new Date().toISOString(),
+    },
+  };
+
+  const result = safeWriteJSON(checkpointPath, checkpoint);
+
+  return {
+    ok: result.ok,
+    checkpoint,
+    path: checkpointPath,
+  };
+}
+
+/**
+ * Load checkpoint
+ */
+function loadCheckpoint(sessionId = 'default') {
+  const checkpointPath = getCheckpointPath(sessionId);
+
+  if (!fs.existsSync(checkpointPath)) {
+    return { ok: false, exists: false, error: 'No checkpoint found' };
+  }
+
+  const result = safeReadJSON(checkpointPath, { defaultValue: null });
+
+  if (!result.ok || !result.data) {
+    return { ok: false, exists: true, error: 'Failed to read checkpoint' };
+  }
+
+  return {
+    ok: true,
+    exists: true,
+    checkpoint: result.data,
+  };
+}
+
+/**
+ * Check if recovery is needed
+ * Detects incomplete loop state from crash
+ */
+function checkRecoveryNeeded(sessionId = 'default') {
+  // Check for checkpoint file
+  const checkpointResult = loadCheckpoint(sessionId);
+
+  if (!checkpointResult.exists) {
+    return { needed: false, reason: 'no_checkpoint' };
+  }
+
+  if (!checkpointResult.ok) {
+    return { needed: false, reason: 'checkpoint_invalid' };
+  }
+
+  const checkpoint = checkpointResult.checkpoint;
+
+  // Check if checkpoint is stale (older than 1 hour without update)
+  const lastCheckpoint = new Date(
+    checkpoint.recovery_info?.last_checkpoint || checkpoint.created_at
+  );
+  const now = new Date();
+  const hoursSinceCheckpoint = (now - lastCheckpoint) / (1000 * 60 * 60);
+
+  if (hoursSinceCheckpoint > 24) {
+    return { needed: false, reason: 'checkpoint_expired', checkpoint };
+  }
+
+  // Check if loop was in progress
+  const loopState = checkpoint.loop_state;
+  if (!loopState || loopState.iteration === 0) {
+    return { needed: false, reason: 'loop_not_started', checkpoint };
+  }
+
+  // Check current session state
+  const statePath = getSessionStatePath();
+  const stateResult = safeReadJSON(statePath, { defaultValue: {} });
+  const currentState = stateResult.ok ? stateResult.data : {};
+
+  // If loop is still enabled and matches checkpoint, no recovery needed
+  if (currentState.ralph_loop && currentState.ralph_loop.enabled) {
+    if (currentState.ralph_loop.iteration === loopState.iteration) {
+      return { needed: false, reason: 'loop_still_active', checkpoint };
+    }
+  }
+
+  // Loop was in progress but not active now - recovery needed
+  return {
+    needed: true,
+    reason: 'incomplete_loop',
+    checkpoint,
+    recovery_options: {
+      resume: {
+        iteration: loopState.iteration,
+        story: loopState.current_story,
+        epic: loopState.epic,
+      },
+      fresh: {
+        message: 'Start fresh from beginning of epic',
+      },
+    },
+  };
+}
+
+/**
+ * Resume from checkpoint
+ */
+function resumeFromCheckpoint(sessionId = 'default') {
+  const checkpointResult = loadCheckpoint(sessionId);
+
+  if (!checkpointResult.ok || !checkpointResult.checkpoint) {
+    return { ok: false, error: 'No valid checkpoint to resume from' };
+  }
+
+  const checkpoint = checkpointResult.checkpoint;
+  const loopState = checkpoint.loop_state;
+
+  // Restore loop state to session state
+  const statePath = getSessionStatePath();
+  const stateResult = safeReadJSON(statePath, { defaultValue: {} });
+  const state = stateResult.ok ? stateResult.data : {};
+
+  state.ralph_loop = {
+    enabled: true,
+    epic: loopState.epic,
+    current_story: loopState.current_story,
+    iteration: loopState.iteration,
+    max_iterations: loopState.max_iterations,
+    visual_mode: loopState.visual_mode,
+    coverage_mode: loopState.coverage_mode,
+    coverage_threshold: loopState.coverage_threshold,
+    coverage_current: loopState.coverage_current,
+    conditions: loopState.conditions,
+    started_at: loopState.started_at,
+    resumed_at: new Date().toISOString(),
+    resumed_from_checkpoint: true,
+  };
+
+  safeWriteJSON(statePath, state);
+
+  return {
+    ok: true,
+    resumed: true,
+    iteration: loopState.iteration,
+    story: loopState.current_story,
+    epic: loopState.epic,
+  };
+}
+
+/**
+ * Clear checkpoint (on clean completion)
+ */
+function clearCheckpoint(sessionId = 'default') {
+  const checkpointPath = getCheckpointPath(sessionId);
+
+  if (fs.existsSync(checkpointPath)) {
+    fs.unlinkSync(checkpointPath);
+    return { ok: true, cleared: true };
+  }
+
+  return { ok: true, cleared: false };
+}
+
+/**
+ * Start fresh (clear checkpoint and any existing loop state)
+ */
+function startFresh(sessionId = 'default') {
+  // Clear checkpoint
+  clearCheckpoint(sessionId);
+
+  // Clear loop state
+  const statePath = getSessionStatePath();
+  const stateResult = safeReadJSON(statePath, { defaultValue: {} });
+  const state = stateResult.ok ? stateResult.data : {};
+
+  if (state.ralph_loop) {
+    delete state.ralph_loop;
+    safeWriteJSON(statePath, state);
+  }
+
+  return { ok: true, cleared: true };
+}
+
+/**
+ * Get recovery status summary
+ */
+function getRecoveryStatus(sessionId = 'default') {
+  const recovery = checkRecoveryNeeded(sessionId);
+  const checkpoint = loadCheckpoint(sessionId);
+
+  return {
+    recoveryNeeded: recovery.needed,
+    reason: recovery.reason,
+    hasCheckpoint: checkpoint.exists,
+    checkpoint: checkpoint.checkpoint,
+    options: recovery.recovery_options,
+  };
+}
+
+module.exports = {
+  getCheckpointPath,
+  createCheckpoint,
+  loadCheckpoint,
+  checkRecoveryNeeded,
+  resumeFromCheckpoint,
+  clearCheckpoint,
+  startFresh,
+  getRecoveryStatus,
+};