teleportation-cli 1.1.5 → 1.2.0

package/lib/daemon/timeline-analyzer.js

@@ -0,0 +1,215 @@
+/**
+ * Timeline Analyzer
+ *
+ * Analyzes timeline events to determine task state without in-memory tracking.
+ * This makes the daemon stateless and crash-resistant.
+ *
+ * @module lib/daemon/timeline-analyzer
+ */
+
+/**
+ * Fetch timeline events for a session
+ * @param {string} session_id - Teleportation session ID
+ * @param {Object} config - Configuration with relayApiUrl and apiKey
+ * @returns {Promise<Array>} Timeline events
+ */
+export async function fetchTimeline(session_id, config) {
+  const { relayApiUrl, apiKey } = config;
+
+  const response = await fetch(`${relayApiUrl}/api/timeline/${session_id}`, {
+    headers: { 'Authorization': `Bearer ${apiKey}` }
+  });
+
+  if (!response.ok) {
+    throw new Error(`Failed to fetch timeline: ${response.status}`);
+  }
+
+  const data = await response.json();
+  return data.events || [];
+}
+
+/**
+ * Analyze timeline to determine current task state
+ * @param {Array} events - Timeline events (sorted chronologically)
+ * @param {string} task_id - Task ID to analyze
+ * @returns {Object} Current state analysis
+ */
+export function analyzeTaskState(events, task_id) {
+  // Filter events for this specific task
+  const taskEvents = events.filter(e => e.meta?.task_id === task_id);
+
+  if (taskEvents.length === 0) {
+    return {
+      state: 'not_started',
+      turn_count: 0,
+      ready_for_execution: true,
+      prompt: null,
+      claude_session_id: null,
+    };
+  }
+
+  // Sort by timestamp to ensure correct order
+  taskEvents.sort((a, b) => a.timestamp - b.timestamp);
+
+  const lastEvent = taskEvents[taskEvents.length - 1];
+
+  // Count turns (each assistant_response indicates a completed turn)
+  const turn_count = taskEvents.filter(e =>
+    e.type === 'assistant_response' && e.source === 'autonomous_task'
+  ).length;
+
+  // Find the latest claude_session_id from task execution
+  let claude_session_id = null;
+  for (let i = taskEvents.length - 1; i >= 0; i--) {
+    if (taskEvents[i].meta?.claude_session_id) {
+      claude_session_id = taskEvents[i].meta.claude_session_id;
+      break;
+    }
+  }
+
+  // Check for pending approvals
+  const pendingApprovals = taskEvents.filter(e =>
+    e.type === 'approval_requested' &&
+    !taskEvents.some(later =>
+      later.type === 'approval_decided' &&
+      later.meta?.approval_id === e.meta?.approval_id
+    )
+  );
+
+  if (pendingApprovals.length > 0) {
+    return {
+      state: 'waiting_approval',
+      turn_count,
+      ready_for_execution: false,
+      reason: `Waiting for ${pendingApprovals.length} approval(s)`,
+      claude_session_id,
+      pending_approvals: pendingApprovals.length,
+    };
+  }
+
+  // Check if task was explicitly paused
+  if (lastEvent.type === 'task_paused') {
+    return {
+      state: 'paused',
+      turn_count,
+      ready_for_execution: false,
+      reason: lastEvent.meta?.reason || 'Task paused',
+      claude_session_id,
+      waiting_for_user_message: true,
+    };
+  }
+
+  // Check if task was stopped
+  if (lastEvent.type === 'task_stopped') {
+    return {
+      state: 'stopped',
+      turn_count,
+      ready_for_execution: false,
+      reason: lastEvent.meta?.reason || 'Task stopped',
+      claude_session_id,
+    };
+  }
+
+  // Check if task completed successfully
+  if (lastEvent.type === 'task_completed') {
+    return {
+      state: 'completed',
+      turn_count,
+      ready_for_execution: false,
+      claude_session_id,
+    };
+  }
+
+  // Check if waiting for budget increase
+  if (lastEvent.type === 'task_budget_hit') {
+    return {
+      state: 'budget_exhausted',
+      turn_count,
+      ready_for_execution: false,
+      reason: 'Budget exhausted',
+      claude_session_id,
+    };
+  }
+
+  // If last event is assistant_response, ready for next turn
+  // Use stop_reason to determine if Claude is done (works like CLI)
+  if (lastEvent.type === 'assistant_response') {
+    const stopReason = lastEvent.meta?.stop_reason;
+
+    // Claude uses "end_turn" when it's done with the current turn and waiting for input
+    // This is the natural stopping point, just like in the CLI
+    if (stopReason === 'end_turn') {
+      return {
+        state: 'ready_for_next_turn',
+        turn_count,
+        ready_for_execution: true,
+        claude_session_id,
+      };
+    }
+
+    // Other stop reasons (max_tokens, stop_sequence, etc.)
+    return {
+      state: 'ready_for_next_turn',
+      turn_count,
+      ready_for_execution: true,
+      claude_session_id,
+    };
+  }
+
+  // Default: ready to execute if we have task_started
+  const hasStarted = taskEvents.some(e => e.type === 'task_started');
+
+  return {
+    state: hasStarted ? 'in_progress' : 'not_started',
+    turn_count,
+    ready_for_execution: true,
+    claude_session_id,
+  };
+}
+
+/**
+ * Determine the next prompt to use for task execution
+ * @param {Object} state - Current state from analyzeTaskState
+ * @param {Object} task - Task object from Redis
+ * @returns {string|null} Prompt to use, or null if not ready
+ */
+export function getNextPrompt(state, task) {
+  if (!state.ready_for_execution) {
+    return null;
+  }
+
+  // First turn: use original task description
+  if (state.turn_count === 0) {
+    return task.task;
+  }
+
+  // If paused and resumed with user message, use that message
+  if (task.pending_question) {
+    return task.pending_question;
+  }
+
+  // Default continuation prompt
+  return 'Continue working on the task.';
+}
+
+/**
+ * Check if task should stop based on timeline analysis
+ * @param {Object} state - Current state from analyzeTaskState
+ * @param {number} maxTurns - Maximum allowed turns
+ * @returns {Object|null} Stop reason if should stop, null otherwise
+ */
+export function shouldStopTask(state, maxTurns = 100) {
+  if (state.state === 'stopped' || state.state === 'completed') {
+    return { should_stop: true, reason: state.state };
+  }
+
+  if (state.turn_count >= maxTurns) {
+    return { should_stop: true, reason: `Max turns limit reached (${maxTurns})` };
+  }
+
+  if (state.state === 'budget_exhausted') {
+    return { should_stop: true, reason: 'Budget exhausted' };
+  }
+
+  return null;
+}