@litmers/cursorflow-orchestrator 0.1.15 → 0.1.18

package/src/utils/enhanced-logger.ts

@@ -13,7 +13,7 @@
 
 import * as fs from 'fs';
 import * as path from 'path';
-import { PassThrough, Transform, TransformCallback } from 'stream';
+import { Transform, TransformCallback } from 'stream';
 import { EnhancedLogConfig } from './types';
 
 // Re-export for backwards compatibility
@@ -163,6 +163,23 @@ export class StreamingMessageParser {
           },
         });
         break;
+        
+      case 'thinking':
+        // Thinking message (Claude 3.7+ etc.)
+        if (json.subtype === 'delta' && json.text) {
+          // Check if this is a new message or continuation
+          if (this.currentRole !== 'thinking') {
+            // Flush previous message if any
+            this.flush();
+            this.currentRole = 'thinking';
+            this.messageStartTime = json.timestamp_ms || Date.now();
+          }
+          this.currentMessage += json.text;
+        } else if (json.subtype === 'completed') {
+          // Thinking completed - flush immediately
+          this.flush();
+        }
+        break;
     }
   }
   
@@ -191,7 +208,7 @@ export class StreamingMessageParser {
 }
 
 export interface ParsedMessage {
-  type: 'system' | 'user' | 'assistant' | 'tool' | 'tool_result' | 'result';
+  type: 'system' | 'user' | 'assistant' | 'tool' | 'tool_result' | 'result' | 'thinking';
   role: string;
   content: string;
   timestamp: number;
@@ -505,6 +522,21 @@ export class EnhancedLogManager {
         formatted = `[${ts}] 📄 RESL: ${msg.metadata?.toolName || 'Tool'}${toolResultLines}\n`;
         break;
         
+      case 'thinking':
+        // Format thinking block
+        const thinkLabel = `[ 🤔 THINKING ] `;
+        const thinkWidth = 80;
+        const thinkTop = `┌─${thinkLabel}${'─'.repeat(Math.max(0, thinkWidth - thinkLabel.length - 2))}`;
+        const thinkBottom = `└─${'─'.repeat(thinkWidth - 2)}`;
+
+        const thinkLines = msg.content.trim().split('\n');
+        formatted = `[${ts}] ${thinkTop}\n`;
+        for (const line of thinkLines) {
+          formatted += `[${ts}] │ ${line}\n`;
+        }
+        formatted += `[${ts}] ${thinkBottom}\n`;
+        break;
+        
       default:
         formatted = `[${ts}] ${msg.content}\n`;
     }
@@ -669,20 +701,71 @@ export class EnhancedLogManager {
       this.cleanTransform.write(data);
     }
     
-    // Parse streaming JSON for readable log (handles boxes, messages, tool calls)
-    this.parseStreamingData(text);
+    // Process lines for readable log and JSON entries
+    this.lineBuffer += text;
+    const lines = this.lineBuffer.split('\n');
+    this.lineBuffer = lines.pop() || '';
     
-    // Also include significant info/status lines in readable log (compact)
-    if (this.readableLogFd !== null) {
-      const lines = text.split('\n');
-      for (const line of lines) {
-        const cleanLine = stripAnsi(line).trim();
+    for (const line of lines) {
+      const cleanLine = stripAnsi(line).trim();
+      if (!cleanLine) continue;
+
+      // Handle streaming JSON messages (for boxes, etc. in readable log)
+      if (cleanLine.startsWith('{')) {
+        if (this.streamingParser) {
+          this.streamingParser.parseLine(cleanLine);
+        }
+
+        // Special handling for terminal.jsonl entries for AI messages
+        if (this.config.writeJsonLog) {
+          try {
+            const json = JSON.parse(cleanLine);
+            let displayMsg = cleanLine;
+            let metadata = { ...json };
+
+            // Extract cleaner text for significant AI message types
+            if (json.type === 'thinking' && json.text) {
+              displayMsg = json.text;
+            } else if (json.type === 'assistant' && json.message?.content) {
+              displayMsg = json.message.content
+                .filter((c: any) => c.type === 'text')
+                .map((c: any) => c.text)
+                .join('');
+            } else if (json.type === 'user' && json.message?.content) {
+              displayMsg = json.message.content
+                .filter((c: any) => c.type === 'text')
+                .map((c: any) => c.text)
+                .join('');
+            } else if (json.type === 'tool_call' && json.subtype === 'started') {
+              const toolName = Object.keys(json.tool_call)[0] || 'unknown';
+              const args = json.tool_call[toolName]?.args || {};
+              displayMsg = `🔧 CALL: ${toolName}(${JSON.stringify(args)})`;
+            } else if (json.type === 'tool_call' && json.subtype === 'completed') {
+              const toolName = Object.keys(json.tool_call)[0] || 'unknown';
+              displayMsg = `📄 RESL: ${toolName}`;
+            } else if (json.type === 'result') {
+              displayMsg = json.result || 'Task completed';
+            }
+
+            this.writeJsonEntry({
+              timestamp: new Date().toISOString(),
+              level: 'stdout',
+              lane: this.session.laneName,
+              task: this.session.taskName,
+              message: displayMsg.substring(0, 2000), // Larger limit for AI text
+              metadata,
+            });
+            continue; // Already logged this JSON line
+          } catch {
+            // Not valid JSON or error, fall through to regular logging
+          }
+        }
+      }
+
+      // Also include significant info/status lines in readable log (compact)
+      if (this.readableLogFd !== null) {
         // Look for log lines: [ISO_DATE] [LEVEL] ...
-        if (cleanLine && 
-            !cleanLine.startsWith('{') && 
-            !this.isNoiseLog(cleanLine) && 
-            /\[\d{4}-\d{2}-\d{2}T/.test(cleanLine)) {
-          
+        if (!this.isNoiseLog(cleanLine) && /\[\d{4}-\d{2}-\d{2}T/.test(cleanLine)) {
           try {
             // Check if it has a level marker
             if (/\[(INFO|WARN|ERROR|SUCCESS|DEBUG)\]/.test(cleanLine)) {
@@ -698,44 +781,26 @@ export class EnhancedLogManager {
           } catch {}
         }
       }
-    }
-    
-    // Write JSON entry (for significant lines only)
-    if (this.config.writeJsonLog) {
-      const cleanText = stripAnsi(text).trim();
-      if (cleanText && !this.isNoiseLog(cleanText)) {
+      
+      // Write regular non-JSON lines to terminal.jsonl
+      if (this.config.writeJsonLog && !this.isNoiseLog(cleanLine)) {
         this.writeJsonEntry({
           timestamp: new Date().toISOString(),
           level: 'stdout',
           lane: this.session.laneName,
           task: this.session.taskName,
-          message: cleanText.substring(0, 1000), // Truncate very long lines
-          raw: this.config.keepRawLogs ? undefined : text.substring(0, 1000),
+          message: cleanLine.substring(0, 1000),
+          raw: this.config.keepRawLogs ? undefined : line.substring(0, 1000),
         });
       }
     }
   }
   
   /**
-   * Parse streaming JSON data for readable log
+   * Parse streaming JSON data for readable log - legacy, integrated into writeStdout
    */
   private parseStreamingData(text: string): void {
-    if (!this.streamingParser) return;
-    
-    // Buffer incomplete lines
-    this.lineBuffer += text;
-    const lines = this.lineBuffer.split('\n');
-    
-    // Keep the last incomplete line in buffer
-    this.lineBuffer = lines.pop() || '';
-    
-    // Parse complete lines
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if (trimmed.startsWith('{')) {
-        this.streamingParser.parseLine(trimmed);
-      }
-    }
+    // Legacy method, no longer used but kept for internal references if any
   }
 
   /**
@@ -873,7 +938,7 @@ export class EnhancedLogManager {
     
     // Skip common progress/spinner patterns
     const noisePatterns = [
-      /^[\s│├└─┌┐┘┴┬┤├]+$/, // Box drawing only
+      /^[\s│├└─┌┐┘┴┬┤]+$/, // Box drawing only (removed duplicate ├)
       /^[.\s]+$/, // Dots only
       /^[=>\s-]+$/, // Progress bar characters
       /^\d+%$/, // Percentage only

package/src/utils/repro-thinking-logs.ts

@@ -0,0 +1,54 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { createLogManager } from './enhanced-logger';
+
+async function testThinkingLogs() {
+  const testDir = path.join(process.cwd(), '_test_thinking_logs');
+  if (fs.existsSync(testDir)) {
+    fs.rmSync(testDir, { recursive: true });
+  }
+  fs.mkdirSync(testDir, { recursive: true });
+
+  console.log('--- Initializing Log Manager ---');
+  const manager = createLogManager(testDir, 'test-lane-thinking', {
+    writeJsonLog: true,
+    keepRawLogs: true
+  });
+
+  manager.setTask('repro-thinking-task', 'sonnet-4.5-thinking');
+
+  const logLines = [
+    '{"type":"tool_call","subtype":"started","call_id":"0_tool_54a8fcc9-6981-4f59-aeb6-3ab6d37b2","tool_call":{"readToolCall":{"args":{"path":"/home/eugene/workbench/workbench-os-eungjin/_cursorflow/worktrees/cursorflow/run-mjfxp57i/agent_output.txt"}}}}',
+    '{"type":"thinking","subtype":"delta","text":"**Defining Installation Strategy**\\n\\nI\'ve considered the `package.json` file as the central point for installation in automated environments. Thinking now about how that impacts the user\'s ultimate goal, given this is how the process begins in these environments.\\n\\n\\n"}',
+    '{"type":"thinking","subtype":"delta","text":"**Clarifying Execution Context**\\n\\nI\'m focused on the user\'s explicit command: `pnpm add @convex-dev/agent ai @ai-sdk/google zod`. My inability to directly execute this is a key constraint. I\'m exploring ways to inform the user about this. I\'ve considered that, without the tools required to run the original command, any attempt to run a command like `grep` or `date` is pointless and will fail.\\n\\n\\n"}',
+    '{"type":"tool_call","subtype":"started","call_id":"0_tool_d8f826c8-9d8f-4cab-9ff8-1c47d1ac1","tool_call":{"shellToolCall":{"args":{"command":"date"}}}}'
+  ];
+
+  console.log('\n--- Feeding Log Lines to Manager ---');
+  for (const line of logLines) {
+    console.log('Processing:', line.substring(0, 100) + '...');
+    manager.writeStdout(line + '\n');
+  }
+
+  manager.close();
+
+  console.log('\n--- Verifying terminal-readable.log ---');
+  const readableLog = fs.readFileSync(path.join(testDir, 'terminal-readable.log'), 'utf8');
+  console.log(readableLog);
+
+  console.log('\n--- Verifying terminal.jsonl (last 3 entries) ---');
+  const jsonlLog = fs.readFileSync(path.join(testDir, 'terminal.jsonl'), 'utf8');
+  const lines = jsonlLog.trim().split('\n');
+  for (const line of lines.slice(-3)) {
+    const parsed = JSON.parse(line);
+    console.log(JSON.stringify({
+      level: parsed.level,
+      message: parsed.message.substring(0, 50) + '...',
+      hasMetadata: !!parsed.metadata,
+      metadataType: parsed.metadata?.type
+    }, null, 2));
+  }
+}
+
+testThinkingLogs().catch(console.error);
+

package/src/utils/types.ts

@@ -18,6 +18,7 @@ export interface CursorFlowConfig {
   lockfileReadOnly: boolean;
   enableReview: boolean;
   reviewModel: string;
+  reviewAllTasks?: boolean;
   maxReviewIterations: number;
   defaultLaneConfig: LaneConfig;
   logLevel: string;
@@ -189,6 +190,10 @@ export interface Task {
   model?: string;
   /** Acceptance criteria for the AI reviewer to validate */
   acceptanceCriteria?: string[];
+  /** Task-level dependencies (format: "lane:task") */
+  dependsOn?: string[];
+  /** Task execution timeout in milliseconds. Overrides lane-level timeout. */
+  timeout?: number;
 }
 
 export interface RunnerConfig {
@@ -200,9 +205,11 @@ export interface RunnerConfig {
   baseBranch?: string;
   model?: string;
   dependencyPolicy: DependencyPolicy;
+  enableReview?: boolean;
   /** Output format for cursor-agent (default: 'stream-json') */
   agentOutputFormat?: 'stream-json' | 'json' | 'plain';
   reviewModel?: string;
+  reviewAllTasks?: boolean;
   maxReviewIterations?: number;
   acceptanceCriteria?: string[];
   /** Task execution timeout in milliseconds. Default: 600000 (10 minutes) */
@@ -263,6 +270,7 @@ export interface ReviewResult {
 export interface TaskResult {
   taskName: string;
   taskBranch: string;
+  acceptanceCriteria?: string[];
   [key: string]: any;
 }
 
@@ -281,6 +289,10 @@ export interface LaneState {
   tasksFile?: string; // Original tasks file path
   dependsOn?: string[];
   pid?: number;
+  /** List of completed task names in this lane */
+  completedTasks?: string[];
+  /** Task-level dependencies currently being waited for (format: "lane:task") */
+  waitingFor?: string[];
 }
 
 export interface ConversationEntry {

package/src/utils/webhook.ts

@@ -56,6 +56,9 @@ async function sendWebhook(config: WebhookConfig, event: CursorFlowEvent) {
       const controller = new AbortController();
       const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
 
+      // SECURITY NOTE: Intentionally sending event data to configured webhook URLs.
+      // This is the expected behavior - users explicitly configure webhook endpoints
+      // to receive CursorFlow events. The data is JSON-serialized event metadata.
       const response = await fetch(config.url, {
         method: 'POST',
         headers,

package/scripts/simple-logging-test.sh

@@ -1,97 +0,0 @@
-#!/bin/bash
-#
-# Simple Real Logging Test
-# This test runs cursor-agent directly and verifies log capture
-#
-
-set -e
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="$(dirname "$SCRIPT_DIR")"
-
-echo "🧪 Simple Cursor-Agent Logging Test"
-echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-
-# Check cursor-agent
-if ! command -v cursor-agent &> /dev/null; then
-    echo "❌ cursor-agent not found"
-    exit 1
-fi
-
-cd "$PROJECT_ROOT"
-
-# Build
-echo "Building..."
-npm run build > /dev/null 2>&1
-
-# Setup test dir
-TEST_DIR="$PROJECT_ROOT/_test-logs"
-rm -rf "$TEST_DIR"
-mkdir -p "$TEST_DIR"
-
-# Create a very simple task
-cat > "$TEST_DIR/task.json" << 'EOF'
-{
-  "baseBranch": "main",
-  "branchPrefix": "test/log-",
-  "timeout": 30000,
-  "tasks": [
-    {
-      "name": "echo-test",
-      "prompt": "Say 'test complete' and nothing else.",
-      "model": "sonnet-4.5"
-    }
-  ]
-}
-EOF
-
-# Run with node directly
-echo ""
-echo "Running cursor-agent via runner..."
-echo ""
-
-LANE_DIR="$TEST_DIR/lane"
-mkdir -p "$LANE_DIR"
-
-# Run runner.js directly
-timeout 60 node dist/core/runner.js "$TEST_DIR/task.json" \
-  --run-dir "$LANE_DIR" \
-  --executor cursor-agent \
-  --start-index 0 || true
-
-echo ""
-echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-echo "📋 Log Files Created:"
-echo ""
-
-ls -la "$LANE_DIR"/*.log "$LANE_DIR"/*.jsonl 2>/dev/null || echo "No log files found"
-
-echo ""
-echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-echo "📝 terminal.log content:"
-echo ""
-
-if [ -f "$LANE_DIR/terminal.log" ]; then
-    head -50 "$LANE_DIR/terminal.log"
-else
-    echo "No terminal.log"
-fi
-
-echo ""
-echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-echo "📝 terminal.jsonl (first 3 entries):"
-echo ""
-
-if [ -f "$LANE_DIR/terminal.jsonl" ]; then
-    head -3 "$LANE_DIR/terminal.jsonl"
-else
-    echo "No terminal.jsonl"
-fi
-
-# Cleanup git branches
-git branch -D test/log-* 2>/dev/null || true
-git worktree remove _cursorflow/worktrees/test/log-* --force 2>/dev/null || true
-
-echo ""
-echo "✅ Test finished"
-