agileflow 2.89.2 → 2.90.0

package/scripts/tui/lib/loopControl.js

@@ -0,0 +1,371 @@
+'use strict';
+
+/**
+ * Loop Control - Pause/Resume mechanism for Ralph Loop
+ *
+ * Provides file-based pause/resume signals that ralph-loop.js checks
+ * between iterations. This allows external control (TUI, CLI) to
+ * pause ongoing loops without interrupting mid-work.
+ *
+ * Mechanism:
+ *   - Pause: Create .agileflow/sessions/loop.pause file
+ *   - Resume: Remove the pause file
+ *   - Status: Check if file exists
+ */
+
+const fs = require('fs');
+const path = require('path');
+const EventEmitter = require('events');
+
+// 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 = (path, opts = {}) => {
+    try {
+      const data = JSON.parse(fs.readFileSync(path, 'utf8'));
+      return { ok: true, data };
+    } catch (e) {
+      return { ok: false, error: e.message, data: opts.defaultValue };
+    }
+  };
+  safeWriteJSON = (path, data) => {
+    fs.writeFileSync(path, JSON.stringify(data, null, 2));
+    return { ok: true };
+  };
+}
+
+/**
+ * Get pause file path
+ */
+function getPauseFilePath(sessionId = 'default') {
+  const rootDir = getProjectRoot();
+  return path.join(rootDir, '.agileflow', 'sessions', `${sessionId}.pause`);
+}
+
+/**
+ * Get session state path
+ */
+function getSessionStatePath() {
+  const rootDir = getProjectRoot();
+  return path.join(rootDir, 'docs', '09-agents', 'session-state.json');
+}
+
+/**
+ * Check if loop is paused
+ */
+function isPaused(sessionId = 'default') {
+  const pauseFile = getPauseFilePath(sessionId);
+  return fs.existsSync(pauseFile);
+}
+
+/**
+ * Pause the loop
+ * Creates pause file and optionally updates session state
+ */
+function pause(sessionId = 'default', reason = 'user_request') {
+  const pauseFile = getPauseFilePath(sessionId);
+
+  // Ensure directory exists
+  const dir = path.dirname(pauseFile);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+
+  // Create pause file with metadata
+  const pauseData = {
+    paused_at: new Date().toISOString(),
+    reason,
+    session_id: sessionId
+  };
+
+  fs.writeFileSync(pauseFile, JSON.stringify(pauseData, null, 2));
+
+  // Update session state
+  const statePath = getSessionStatePath();
+  const result = safeReadJSON(statePath, { defaultValue: {} });
+  const state = result.ok ? result.data : {};
+
+  if (state.ralph_loop) {
+    state.ralph_loop.paused = true;
+    state.ralph_loop.paused_at = pauseData.paused_at;
+    state.ralph_loop.pause_reason = reason;
+    safeWriteJSON(statePath, state);
+  }
+
+  return pauseData;
+}
+
+/**
+ * Resume the loop
+ * Removes pause file and updates session state
+ */
+function resume(sessionId = 'default') {
+  const pauseFile = getPauseFilePath(sessionId);
+
+  // Get pause data before removing
+  let pauseData = null;
+  if (fs.existsSync(pauseFile)) {
+    try {
+      pauseData = JSON.parse(fs.readFileSync(pauseFile, 'utf8'));
+    } catch (e) {
+      // Ignore parse errors
+    }
+    fs.unlinkSync(pauseFile);
+  }
+
+  // Update session state
+  const statePath = getSessionStatePath();
+  const result = safeReadJSON(statePath, { defaultValue: {} });
+  const state = result.ok ? result.data : {};
+
+  if (state.ralph_loop) {
+    state.ralph_loop.paused = false;
+    state.ralph_loop.resumed_at = new Date().toISOString();
+    delete state.ralph_loop.paused_at;
+    delete state.ralph_loop.pause_reason;
+    safeWriteJSON(statePath, state);
+  }
+
+  return {
+    resumed_at: new Date().toISOString(),
+    was_paused: pauseData !== null,
+    pause_data: pauseData
+  };
+}
+
+/**
+ * Get loop status
+ */
+function getLoopStatus() {
+  const statePath = getSessionStatePath();
+  const result = safeReadJSON(statePath, { defaultValue: {} });
+  const state = result.ok ? result.data : {};
+
+  const loop = state.ralph_loop;
+  if (!loop || !loop.enabled) {
+    return {
+      active: false,
+      paused: false,
+      message: 'Loop not active'
+    };
+  }
+
+  const paused = isPaused() || loop.paused;
+
+  return {
+    active: true,
+    paused,
+    epic: loop.epic,
+    currentStory: loop.current_story,
+    iteration: loop.iteration || 0,
+    maxIterations: loop.max_iterations || 20,
+    visualMode: loop.visual_mode || false,
+    coverageMode: loop.coverage_mode || false,
+    coverageThreshold: loop.coverage_threshold || 80,
+    coverageCurrent: loop.coverage_current || 0,
+    pausedAt: loop.paused_at,
+    pauseReason: loop.pause_reason,
+    startedAt: loop.started_at
+  };
+}
+
+/**
+ * Stop the loop completely
+ */
+function stopLoop(reason = 'user_request') {
+  const statePath = getSessionStatePath();
+  const result = safeReadJSON(statePath, { defaultValue: {} });
+  const state = result.ok ? result.data : {};
+
+  if (state.ralph_loop) {
+    state.ralph_loop.enabled = false;
+    state.ralph_loop.stopped_at = new Date().toISOString();
+    state.ralph_loop.stopped_reason = reason;
+    safeWriteJSON(statePath, state);
+  }
+
+  // Also remove any pause file
+  const pauseFile = getPauseFilePath();
+  if (fs.existsSync(pauseFile)) {
+    fs.unlinkSync(pauseFile);
+  }
+
+  return {
+    stopped: true,
+    reason,
+    stopped_at: new Date().toISOString()
+  };
+}
+
+/**
+ * LoopController class - EventEmitter for loop control
+ *
+ * Emits events:
+ *   - 'paused' - Loop was paused
+ *   - 'resumed' - Loop was resumed
+ *   - 'stopped' - Loop was stopped
+ *   - 'statusChange' - Loop status changed
+ */
+class LoopController extends EventEmitter {
+  constructor(options = {}) {
+    super();
+
+    this.sessionId = options.sessionId || 'default';
+    this.pollInterval = options.pollInterval || 1000;
+    this.lastStatus = null;
+    this.pollTimer = null;
+    this.isWatching = false;
+  }
+
+  /**
+   * Start watching for status changes
+   */
+  startWatching() {
+    if (this.isWatching) return;
+
+    this.lastStatus = getLoopStatus();
+    this.isWatching = true;
+
+    this.pollTimer = setInterval(() => {
+      this._checkStatus();
+    }, this.pollInterval);
+
+    this.emit('started');
+  }
+
+  /**
+   * Stop watching
+   */
+  stopWatching() {
+    if (!this.isWatching) return;
+
+    if (this.pollTimer) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = null;
+    }
+
+    this.isWatching = false;
+    this.emit('stopped');
+  }
+
+  /**
+   * Check for status changes
+   */
+  _checkStatus() {
+    const newStatus = getLoopStatus();
+
+    if (!this.lastStatus) {
+      this.lastStatus = newStatus;
+      return;
+    }
+
+    // Check for changes
+    if (this.lastStatus.paused !== newStatus.paused) {
+      if (newStatus.paused) {
+        this.emit('paused', {
+          pausedAt: newStatus.pausedAt,
+          reason: newStatus.pauseReason
+        });
+      } else {
+        this.emit('resumed');
+      }
+    }
+
+    if (this.lastStatus.active !== newStatus.active) {
+      if (!newStatus.active && this.lastStatus.active) {
+        this.emit('loopStopped');
+      }
+    }
+
+    if (this.lastStatus.iteration !== newStatus.iteration) {
+      this.emit('iteration', {
+        iteration: newStatus.iteration,
+        maxIterations: newStatus.maxIterations
+      });
+    }
+
+    if (this.lastStatus.currentStory !== newStatus.currentStory) {
+      this.emit('storyChange', {
+        previousStory: this.lastStatus.currentStory,
+        currentStory: newStatus.currentStory
+      });
+    }
+
+    // Always emit statusChange if anything changed
+    const changed = JSON.stringify(this.lastStatus) !== JSON.stringify(newStatus);
+    if (changed) {
+      this.emit('statusChange', newStatus);
+    }
+
+    this.lastStatus = newStatus;
+  }
+
+  /**
+   * Pause the loop
+   */
+  pause(reason = 'user_request') {
+    const result = pause(this.sessionId, reason);
+    this._checkStatus();
+    return result;
+  }
+
+  /**
+   * Resume the loop
+   */
+  resume() {
+    const result = resume(this.sessionId);
+    this._checkStatus();
+    return result;
+  }
+
+  /**
+   * Stop the loop
+   */
+  stop(reason = 'user_request') {
+    const result = stopLoop(reason);
+    this._checkStatus();
+    return result;
+  }
+
+  /**
+   * Get current status
+   */
+  getStatus() {
+    return getLoopStatus();
+  }
+}
+
+/**
+ * Default controller instance
+ */
+let defaultController = null;
+
+function getDefaultController() {
+  if (!defaultController) {
+    defaultController = new LoopController();
+  }
+  return defaultController;
+}
+
+module.exports = {
+  isPaused,
+  pause,
+  resume,
+  getLoopStatus,
+  stopLoop,
+  getPauseFilePath,
+  LoopController,
+  getDefaultController
+};

package/scripts/tui/panels/OutputPanel.js

@@ -0,0 +1,278 @@
+'use strict';
+
+/**
+ * Agent Output Panel - Live updates from agent event stream
+ *
+ * Displays real-time agent messages with timestamps and agent names.
+ * Auto-scrolls to bottom, limits display to configurable message count.
+ */
+
+const React = require('react');
+const { Box, Text, Newline } = require('ink');
+const { EventStream, formatEvent } = require('../lib/eventStream');
+
+/**
+ * Get color for agent type
+ */
+function getAgentColor(agent) {
+  const colors = {
+    'agileflow-api': 'cyan',
+    'agileflow-ui': 'magenta',
+    'agileflow-testing': 'yellow',
+    'agileflow-ci': 'green',
+    'agileflow-security': 'red',
+    'agileflow-devops': 'blue',
+    'agileflow-database': 'white',
+    'agileflow-performance': 'cyan',
+    'agileflow-documentation': 'gray'
+  };
+
+  // Check for partial matches
+  for (const [key, color] of Object.entries(colors)) {
+    if (agent && agent.includes(key.replace('agileflow-', ''))) {
+      return color;
+    }
+  }
+
+  return 'gray';
+}
+
+/**
+ * Get status indicator for event type
+ */
+function getStatusIndicator(eventType) {
+  switch (eventType) {
+    case 'init':
+      return { symbol: '▶', color: 'blue' };
+    case 'iteration':
+      return { symbol: '↻', color: 'cyan' };
+    case 'passed':
+      return { symbol: '✓', color: 'green' };
+    case 'failed':
+      return { symbol: '✗', color: 'red' };
+    case 'abort':
+      return { symbol: '⊘', color: 'yellow' };
+    default:
+      return { symbol: '•', color: 'gray' };
+  }
+}
+
+/**
+ * Single output row component
+ */
+function OutputRow({ event, showTimestamp = true }) {
+  const formatted = formatEvent(event);
+  const agentColor = getAgentColor(formatted.agent);
+  const status = getStatusIndicator(formatted.eventType);
+
+  return React.createElement(
+    Box,
+    { flexDirection: 'row' },
+    // Timestamp
+    showTimestamp && formatted.timestamp && React.createElement(
+      Text,
+      { dimColor: true },
+      `[${formatted.timestamp}] `
+    ),
+    // Status indicator
+    React.createElement(
+      Text,
+      { color: status.color },
+      `${status.symbol} `
+    ),
+    // Agent name
+    React.createElement(
+      Text,
+      { color: agentColor, bold: true },
+      `[${formatted.agent}] `
+    ),
+    // Message
+    React.createElement(
+      Text,
+      null,
+      formatted.message
+    )
+  );
+}
+
+/**
+ * Main Output Panel component
+ */
+function OutputPanel({
+  maxMessages = 100,
+  showTimestamp = true,
+  logPath = null,
+  title = 'AGENT OUTPUT'
+}) {
+  const [messages, setMessages] = React.useState([]);
+  const [isConnected, setIsConnected] = React.useState(false);
+  const [error, setError] = React.useState(null);
+  const streamRef = React.useRef(null);
+
+  React.useEffect(() => {
+    // Create event stream
+    const options = logPath ? { logPath, emitHistory: true, historyLimit: 10 } : { emitHistory: true, historyLimit: 10 };
+    const stream = new EventStream(options);
+    streamRef.current = stream;
+
+    // Handle events
+    stream.on('event', (event) => {
+      setMessages((prev) => {
+        const newMessages = [...prev, event];
+        // Limit to maxMessages
+        if (newMessages.length > maxMessages) {
+          return newMessages.slice(-maxMessages);
+        }
+        return newMessages;
+      });
+    });
+
+    stream.on('started', () => {
+      setIsConnected(true);
+      setError(null);
+    });
+
+    stream.on('stopped', () => {
+      setIsConnected(false);
+    });
+
+    stream.on('error', (err) => {
+      setError(err.message);
+    });
+
+    stream.on('truncated', () => {
+      // Clear messages on log rotation
+      setMessages([]);
+    });
+
+    // Start watching
+    stream.start();
+
+    // Cleanup
+    return () => {
+      if (streamRef.current) {
+        streamRef.current.stop();
+      }
+    };
+  }, [logPath, maxMessages]);
+
+  // Render panel
+  return React.createElement(
+    Box,
+    {
+      flexDirection: 'column',
+      borderStyle: 'single',
+      borderColor: isConnected ? 'green' : 'gray',
+      padding: 1,
+      flexGrow: 1
+    },
+    // Header
+    React.createElement(
+      Box,
+      { marginBottom: 1 },
+      React.createElement(
+        Text,
+        { bold: true, color: 'cyan' },
+        title
+      ),
+      React.createElement(
+        Text,
+        { dimColor: true },
+        ` (${messages.length}/${maxMessages})`
+      ),
+      isConnected && React.createElement(
+        Text,
+        { color: 'green' },
+        ' ●'
+      ),
+      !isConnected && !error && React.createElement(
+        Text,
+        { color: 'yellow' },
+        ' ○'
+      ),
+      error && React.createElement(
+        Text,
+        { color: 'red' },
+        ' ✗'
+      )
+    ),
+    // Messages or placeholder
+    messages.length === 0
+      ? React.createElement(
+          Text,
+          { dimColor: true, italic: true },
+          error ? `Error: ${error}` : 'Waiting for agent activity...'
+        )
+      : messages.map((event, index) =>
+          React.createElement(OutputRow, {
+            key: `msg-${index}`,
+            event,
+            showTimestamp
+          })
+        )
+  );
+}
+
+/**
+ * Compact output view (for split panels)
+ */
+function CompactOutput({ maxLines = 5, logPath = null }) {
+  const [messages, setMessages] = React.useState([]);
+  const streamRef = React.useRef(null);
+
+  React.useEffect(() => {
+    const options = logPath ? { logPath } : {};
+    const stream = new EventStream(options);
+    streamRef.current = stream;
+
+    stream.on('event', (event) => {
+      setMessages((prev) => {
+        const newMessages = [...prev, event];
+        return newMessages.slice(-maxLines);
+      });
+    });
+
+    stream.start();
+
+    return () => {
+      if (streamRef.current) {
+        streamRef.current.stop();
+      }
+    };
+  }, [logPath, maxLines]);
+
+  if (messages.length === 0) {
+    return React.createElement(
+      Text,
+      { dimColor: true },
+      'No recent activity'
+    );
+  }
+
+  return React.createElement(
+    Box,
+    { flexDirection: 'column' },
+    messages.map((event, index) => {
+      const formatted = formatEvent(event);
+      const status = getStatusIndicator(formatted.eventType);
+      return React.createElement(
+        Text,
+        { key: `compact-${index}` },
+        React.createElement(Text, { color: status.color }, status.symbol),
+        ' ',
+        React.createElement(Text, { dimColor: true }, `[${formatted.agent}]`),
+        ' ',
+        formatted.message.substring(0, 50),
+        formatted.message.length > 50 ? '...' : ''
+      );
+    })
+  );
+}
+
+module.exports = {
+  OutputPanel,
+  OutputRow,
+  CompactOutput,
+  getAgentColor,
+  getStatusIndicator
+};