@litmers/cursorflow-orchestrator 0.1.39 → 0.2.2

package/scripts/verify-change.sh

@@ -0,0 +1,272 @@
+#!/bin/bash
+#
+# verify-change.sh - Post-change verification script
+#
+# Runs a series of checks to verify that code changes don't break functionality.
+# Use this after making changes to ensure everything still works.
+#
+# Usage:
+#   ./scripts/verify-change.sh           # Run all checks
+#   ./scripts/verify-change.sh --quick   # Skip slow tests
+#   ./scripts/verify-change.sh --smoke   # Only run smoke tests
+#
+
+set -e
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Script directory
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+ROOT_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
+
+# Parse arguments
+QUICK_MODE=false
+SMOKE_ONLY=false
+VERBOSE=false
+
+while [[ $# -gt 0 ]]; do
+    case $1 in
+        --quick|-q)
+            QUICK_MODE=true
+            shift
+            ;;
+        --smoke|-s)
+            SMOKE_ONLY=true
+            shift
+            ;;
+        --verbose|-v)
+            VERBOSE=true
+            shift
+            ;;
+        --help|-h)
+            echo "Usage: $0 [options]"
+            echo ""
+            echo "Options:"
+            echo "  --quick, -q    Skip slow tests (integration, e2e)"
+            echo "  --smoke, -s    Only run smoke tests"
+            echo "  --verbose, -v  Show detailed output"
+            echo "  --help, -h     Show this help message"
+            exit 0
+            ;;
+        *)
+            echo -e "${RED}Unknown option: $1${NC}"
+            exit 1
+            ;;
+    esac
+done
+
+# Logging functions
+log_step() {
+    echo -e "\n${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+    echo -e "${BLUE}▶ $1${NC}"
+    echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+}
+
+log_success() {
+    echo -e "${GREEN}✓ $1${NC}"
+}
+
+log_error() {
+    echo -e "${RED}✗ $1${NC}"
+}
+
+log_warning() {
+    echo -e "${YELLOW}⚠ $1${NC}"
+}
+
+# Track results
+RESULTS=()
+FAILED=false
+
+run_check() {
+    local name="$1"
+    local command="$2"
+    
+    if $VERBOSE; then
+        echo -e "${YELLOW}Running: $command${NC}"
+    fi
+    
+    if eval "$command"; then
+        log_success "$name"
+        RESULTS+=("✓ $name")
+    else
+        log_error "$name"
+        RESULTS+=("✗ $name")
+        FAILED=true
+    fi
+}
+
+cd "$ROOT_DIR"
+
+echo -e "${BLUE}"
+echo "╔═══════════════════════════════════════════════════════════╗"
+echo "║           CursorFlow Change Verification                  ║"
+echo "╚═══════════════════════════════════════════════════════════╝"
+echo -e "${NC}"
+
+# Step 1: TypeScript Compilation
+log_step "Step 1: TypeScript Compilation"
+
+BUILD_OUTPUT=$(mktemp)
+if npm run build > "$BUILD_OUTPUT" 2>&1; then
+    log_success "TypeScript compilation passed"
+    RESULTS+=("✓ TypeScript compilation")
+else
+    log_error "TypeScript compilation failed"
+    echo "Build output:"
+    cat "$BUILD_OUTPUT"
+    RESULTS+=("✗ TypeScript compilation")
+    FAILED=true
+fi
+rm -f "$BUILD_OUTPUT"
+
+# Exit early if build failed
+if $FAILED; then
+    log_error "Build failed, skipping further checks"
+    exit 1
+fi
+
+# Step 2: Lint Check (if available)
+log_step "Step 2: Lint Check"
+if command -v eslint &> /dev/null && [ -f ".eslintrc.js" ] || [ -f ".eslintrc.json" ]; then
+    run_check "ESLint" "npx eslint src/ --quiet 2>/dev/null || true"
+else
+    log_warning "ESLint not configured, skipping"
+    RESULTS+=("⚠ ESLint (skipped)")
+fi
+
+# Step 3: Unit Tests (unless smoke-only mode)
+if ! $SMOKE_ONLY; then
+    log_step "Step 3: Unit Tests"
+    run_check "Unit tests" "npm run test:unit -- --passWithNoTests --silent"
+fi
+
+# Step 4: CLI Smoke Tests
+log_step "Step 4: CLI Smoke Tests"
+
+# Test 1: Version command
+echo -e "${YELLOW}Testing: cursorflow --version${NC}"
+VERSION_OUTPUT=$(node dist/cli/index.js --version 2>&1 || true)
+if echo "$VERSION_OUTPUT" | grep -qE '[0-9]+\.[0-9]+\.[0-9]+'; then
+    log_success "Version command works"
+    RESULTS+=("✓ Version command")
+else
+    log_error "Version command failed"
+    echo "Output: $VERSION_OUTPUT"
+    RESULTS+=("✗ Version command")
+    FAILED=true
+fi
+
+# Test 2: Help command
+echo -e "${YELLOW}Testing: cursorflow --help${NC}"
+HELP_OUTPUT=$(node dist/cli/index.js --help 2>&1 || true)
+if echo "$HELP_OUTPUT" | grep -qiE 'usage|commands|options'; then
+    log_success "Help command works"
+    RESULTS+=("✓ Help command")
+else
+    log_error "Help command failed"
+    echo "Output: $HELP_OUTPUT"
+    RESULTS+=("✗ Help command")
+    FAILED=true
+fi
+
+# Test 3: Doctor command (in a temp directory to avoid git issues)
+echo -e "${YELLOW}Testing: cursorflow doctor${NC}"
+TEMP_DIR=$(mktemp -d)
+cd "$TEMP_DIR"
+git init -q 2>/dev/null || true
+git config user.email "test@test.com" 2>/dev/null || true
+git config user.name "Test" 2>/dev/null || true
+touch README.md
+git add . 2>/dev/null || true
+git commit -m "init" -q 2>/dev/null || true
+
+DOCTOR_OUTPUT=$(node "$ROOT_DIR/dist/cli/index.js" doctor 2>&1 || true)
+cd "$ROOT_DIR"
+rm -rf "$TEMP_DIR"
+
+# Doctor should produce some output (even if checks fail)
+if [ -n "$DOCTOR_OUTPUT" ] && ! echo "$DOCTOR_OUTPUT" | grep -qiE 'undefined is not|cannot read'; then
+    log_success "Doctor command works"
+    RESULTS+=("✓ Doctor command")
+else
+    log_error "Doctor command has runtime errors"
+    echo "Output: $DOCTOR_OUTPUT"
+    RESULTS+=("✗ Doctor command")
+    FAILED=true
+fi
+
+# Step 5: Output Format Verification
+log_step "Step 5: Output Format Verification"
+
+# Check for common issues in CLI output
+check_output_format() {
+    local cmd="$1"
+    local name="$2"
+    
+    OUTPUT=$(node dist/cli/index.js $cmd 2>&1 || true)
+    
+    # Check for runtime errors
+    if echo "$OUTPUT" | grep -qiE 'undefined is not|cannot read propert|null is not'; then
+        log_error "$name has JavaScript runtime errors"
+        return 1
+    fi
+    
+    # Check for unhandled stack traces (but allow intentional error messages)
+    if echo "$OUTPUT" | grep -qE 'at\s+Object\.<anonymous>|at\s+Module\._compile'; then
+        log_warning "$name may have unhandled errors (stack trace detected)"
+    fi
+    
+    return 0
+}
+
+run_check "Version output format" "check_output_format '--version' 'Version'"
+run_check "Help output format" "check_output_format '--help' 'Help'"
+
+# Step 6: Integration Tests (unless quick or smoke-only mode)
+if ! $QUICK_MODE && ! $SMOKE_ONLY; then
+    log_step "Step 6: Integration Tests"
+    run_check "Integration tests" "npm run test:integration -- --passWithNoTests 2>/dev/null || true"
+fi
+
+# Step 7: Jest Smoke Tests
+log_step "Step 7: Jest Smoke Tests"
+if [ -f "tests/smoke/smoke.test.ts" ]; then
+    run_check "Jest smoke tests" "npx jest tests/smoke --passWithNoTests --runInBand 2>/dev/null"
+else
+    log_warning "Smoke test file not found"
+    RESULTS+=("⚠ Jest smoke tests (skipped)")
+fi
+
+# Summary
+echo -e "\n${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+echo -e "${BLUE}                    VERIFICATION SUMMARY                    ${NC}"
+echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+
+for result in "${RESULTS[@]}"; do
+    if [[ "$result" == ✓* ]]; then
+        echo -e "${GREEN}$result${NC}"
+    elif [[ "$result" == ✗* ]]; then
+        echo -e "${RED}$result${NC}"
+    else
+        echo -e "${YELLOW}$result${NC}"
+    fi
+done
+
+echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+
+if $FAILED; then
+    echo -e "\n${RED}❌ Verification FAILED${NC}"
+    echo -e "${RED}Some checks did not pass. Please fix the issues before committing.${NC}"
+    exit 1
+else
+    echo -e "\n${GREEN}✅ All verifications PASSED${NC}"
+    echo -e "${GREEN}Your changes look good!${NC}"
+    exit 0
+fi
+

package/src/cli/logs.ts

@@ -14,6 +14,7 @@ import {
   JsonLogEntry 
 } from '../utils/enhanced-logger';
 import { formatPotentialJsonMessage } from '../utils/log-formatter';
+import { MAIN_LOG_FILENAME } from '../utils/log-constants';
 import { startLogViewer } from '../ui/log-viewer';
 
 interface LogsOptions {
@@ -44,13 +45,13 @@ function printHelp(): void {
   console.log(`
 Usage: cursorflow logs [run-dir] [options]
 
-View and export lane logs.
+View and export logs.
 
 Options:
   [run-dir]              Run directory (default: latest)
   --run <id>             Specific run directory
-  --lane <name>          Filter to specific lane
-  --all, -a              View all lanes merged (sorted by timestamp)
+  --lane <name>          View a specific lane (subprocess) log
+  --all, -a              View all lane logs merged (sorted by timestamp)
   --format <fmt>         Output format: text, json, markdown, html (default: text)
   --output <path>        Write output to file instead of stdout
   --tail <n>             Show last n lines/entries (default: all)
@@ -58,13 +59,13 @@ Options:
   --interactive, -i      Open interactive log viewer
   --filter <pattern>     Filter entries by regex pattern
   --level <level>        Filter by log level: stdout, stderr, info, error, debug
-  --readable, -r         Show readable log (parsed AI output) (default)
-  --clean                Show clean terminal logs without ANSI codes
+  --readable, -r         Show readable lane log (parsed AI output) (default for lanes)
+  --clean                Strip ANSI codes (default is raw for main logs)
   --raw                  Show raw terminal logs with ANSI codes
   --help, -h             Show help
 
 Examples:
-  cursorflow logs                              # View latest run logs summary
+  cursorflow logs                              # View latest run main log (raw)
   cursorflow logs --lane api-setup             # View readable parsed log (default)
   cursorflow logs --lane api-setup --clean     # View clean terminal logs
   cursorflow logs --all                        # View all lanes merged by time
@@ -195,6 +196,35 @@ function displayTextLogs(
   console.log(lines.join('\n'));
 }
 
+/**
+ * Read and display main process logs
+ */
+function displayMainLogs(runDir: string, options: LogsOptions): void {
+  const logFile = safeJoin(runDir, MAIN_LOG_FILENAME);
+  if (!fs.existsSync(logFile)) {
+    console.log('No main log file found.');
+    return;
+  }
+
+  let content = fs.readFileSync(logFile, 'utf8');
+  let lines = content.split('\n');
+
+  if (options.filter) {
+    const filterLower = options.filter.toLowerCase();
+    lines = lines.filter(line => line.toLowerCase().includes(filterLower));
+  }
+
+  if (options.tail && lines.length > options.tail) {
+    lines = lines.slice(-options.tail);
+  }
+
+  if (options.clean) {
+    lines = lines.map(line => stripAnsi(line));
+  }
+
+  console.log(lines.join('\n'));
+}
+
 /**
  * Read and display JSON logs
  */
@@ -751,6 +781,68 @@ function followLogs(laneDir: string, options: LogsOptions): void {
   });
 }
 
+/**
+ * Follow main process log in real-time
+ */
+function followMainLogs(runDir: string, options: LogsOptions): void {
+  const logFile = safeJoin(runDir, MAIN_LOG_FILENAME);
+
+  if (!fs.existsSync(logFile)) {
+    console.log('Waiting for main log file...');
+  }
+
+  let lastSize = 0;
+  try {
+    lastSize = fs.statSync(logFile).size;
+  } catch {
+    lastSize = 0;
+  }
+
+  console.log(`${logger.COLORS.cyan}Following ${logFile}... (Ctrl+C to stop)${logger.COLORS.reset}\n`);
+
+  const checkInterval = setInterval(() => {
+    let fd: number | null = null;
+    try {
+      fd = fs.openSync(logFile, 'r');
+      const stats = fs.fstatSync(fd);
+      if (stats.size > lastSize) {
+        const buffer = Buffer.alloc(stats.size - lastSize);
+        fs.readSync(fd, buffer, 0, buffer.length, lastSize);
+
+        let content = buffer.toString();
+
+        if (options.filter) {
+          const filterLower = options.filter.toLowerCase();
+          const lines = content.split('\n');
+          content = lines.filter(line => line.toLowerCase().includes(filterLower)).join('\n');
+        }
+
+        if (options.clean) {
+          content = stripAnsi(content);
+        }
+
+        if (content.trim()) {
+          process.stdout.write(content);
+        }
+
+        lastSize = stats.size;
+      }
+    } catch {
+      // Ignore errors (file might be rotating)
+    } finally {
+      if (fd !== null) {
+        try { fs.closeSync(fd); } catch { /* ignore */ }
+      }
+    }
+  }, 100);
+
+  process.on('SIGINT', () => {
+    clearInterval(checkInterval);
+    console.log('\n\nStopped following logs.');
+    process.exit(0);
+  });
+}
+
 /**
  * Display logs summary for all lanes
  */
@@ -865,10 +957,30 @@ async function logs(args: string[]): Promise<void> {
     return;
   }
   
-  // If no lane specified, show summary
+  // If no lane specified, show main process log by default
   if (!options.lane) {
-    displaySummary(runDir);
-    console.log(`${logger.COLORS.gray}Use --lane <name> to view logs (default: readable), --clean for terminal logs, or --all to view all lanes merged${logger.COLORS.reset}`);
+    if (options.follow) {
+      followMainLogs(runDir, options);
+      return;
+    }
+
+    if (options.output) {
+      const logFile = safeJoin(runDir, MAIN_LOG_FILENAME);
+      if (!fs.existsSync(logFile)) {
+        console.log('No main log file found.');
+        return;
+      }
+      let content = fs.readFileSync(logFile, 'utf8');
+      if (options.clean) {
+        content = stripAnsi(content);
+      }
+      fs.writeFileSync(options.output, content, 'utf8');
+      console.log(`Exported main log to: ${options.output}`);
+      return;
+    }
+
+    displayMainLogs(runDir, options);
+    console.log(`${logger.COLORS.gray}Use --lane <name> for lane logs, --all to merge lanes, or --clean to strip ANSI codes.${logger.COLORS.reset}`);
     return;
   }
   
@@ -904,4 +1016,3 @@ async function logs(args: string[]): Promise<void> {
 }
 
 export = logs;
-

package/src/cli/models.ts

@@ -9,16 +9,33 @@ import { getAvailableModels } from '../utils/cursor-agent';
 
 /**
  * Model details metadata
+ * Reference: docs/CURSOR_AGENT_GUIDE.md (2025.12 version)
  */
 const MODEL_METADATA: Record<string, { name: string; provider: string; description: string }> = {
+  // Special modes
+  'composer-1': { name: 'Composer 1', provider: 'Cursor', description: 'Multi-file orchestration mode' },
+  'auto': { name: 'Auto', provider: 'Cursor', description: 'Automatic model selection' },
+  // Anthropic Claude models
   'sonnet-4.5': { name: 'Claude 3.7 Sonnet', provider: 'Anthropic', description: 'General implementation, fast work (Most versatile)' },
-  'sonnet-4.5-thinking': { name: 'Claude 3.7 Sonnet (Thinking)', provider: 'Anthropic', description: 'Code review, deeper reasoning (Thinking model)' },
+  'sonnet-4.5-thinking': { name: 'Claude 3.7 Sonnet (Thinking)', provider: 'Anthropic', description: 'Deeper reasoning (Thinking model)' },
   'opus-4.5': { name: 'Claude 4.0 Opus', provider: 'Anthropic', description: 'Complex tasks, high quality (Advanced)' },
   'opus-4.5-thinking': { name: 'Claude 4.0 Opus (Thinking)', provider: 'Anthropic', description: 'Architecture design (Premium)' },
+  'opus-4.1': { name: 'Claude 4.1 Opus', provider: 'Anthropic', description: 'Latest Opus model' },
+  // Google Gemini models
+  'gemini-3-flash': { name: 'Gemini 3 Flash', provider: 'Google', description: 'Fast, general tasks (Default)' },
+  'gemini-3-pro': { name: 'Gemini 3 Pro', provider: 'Google', description: 'Advanced reasoning (High performance)' },
+  // OpenAI GPT models
   'gpt-5.2': { name: 'GPT-5.2', provider: 'OpenAI', description: 'General tasks' },
   'gpt-5.2-high': { name: 'GPT-5.2 High Reasoning', provider: 'OpenAI', description: 'Advanced reasoning (High performance)' },
-  'gemini-3-flash': { name: 'Gemini 3 Flash', provider: 'Google', description: 'General tasks' },
-  'gemini-3-pro': { name: 'Gemini 3 Pro', provider: 'Google', description: 'Advanced reasoning (High performance)' }
+  'gpt-5.1': { name: 'GPT-5.1', provider: 'OpenAI', description: 'General tasks' },
+  'gpt-5.1-high': { name: 'GPT-5.1 High Reasoning', provider: 'OpenAI', description: 'Advanced reasoning' },
+  // OpenAI Codex models
+  'gpt-5.1-codex': { name: 'GPT-5.1 Codex', provider: 'OpenAI', description: 'Code-optimized model' },
+  'gpt-5.1-codex-high': { name: 'GPT-5.1 Codex High', provider: 'OpenAI', description: 'Code-optimized (High performance)' },
+  'gpt-5.1-codex-max': { name: 'GPT-5.1 Codex Max', provider: 'OpenAI', description: 'Code-optimized (Maximum)' },
+  'gpt-5.1-codex-max-high': { name: 'GPT-5.1 Codex Max High', provider: 'OpenAI', description: 'Code-optimized (Maximum, High performance)' },
+  // xAI
+  'grok': { name: 'Grok', provider: 'xAI', description: 'xAI Grok model' },
 };
 
 function printHelp(): void {