@litmers/cursorflow-orchestrator 0.1.20 → 0.1.28

package/package.json

@@ -1,32 +1,12 @@
 {
   "name": "@litmers/cursorflow-orchestrator",
-  "version": "0.1.20",
+  "version": "0.1.28",
   "description": "Git worktree-based parallel AI agent orchestration system for Cursor",
   "main": "dist/cli/index.js",
   "bin": {
     "cursorflow": "dist/cli/index.js",
     "cursorflow-setup": "dist/cli/setup-commands.js"
   },
-  "scripts": {
-    "build": "tsc",
-    "watch": "tsc -w",
-    "test": "jest",
-    "prepublishOnly": "npm run build && npm run validate",
-    "postinstall": "node scripts/postinstall.js",
-    "validate": "npm pack --dry-run",
-    "release": "scripts/release.sh",
-    "release:patch": "scripts/release.sh patch",
-    "release:minor": "scripts/release.sh minor",
-    "release:major": "scripts/release.sh major",
-    "security:check": "scripts/local-security-gate.sh",
-    "security:audit": "npm audit",
-    "security:audit:fix": "npm audit fix",
-    "security:setup": "scripts/setup-security.sh",
-    "verify": "scripts/verify-and-fix.sh",
-    "test:lifecycle": "tests/scripts/test-real-cursor-lifecycle.sh",
-    "test:comprehensive": "tests/scripts/test-comprehensive-lifecycle.sh",
-    "prepare": "husky"
-  },
   "keywords": [
     "cursor",
     "cursor-ide",
@@ -70,5 +50,40 @@
     "README.md",
     "LICENSE",
     "CHANGELOG.md"
-  ]
-}
+  ],
+  "scripts": {
+    "build": "tsc",
+    "watch": "tsc -w",
+    "test": "jest",
+    "postinstall": "node scripts/postinstall.js",
+    "validate": "pnpm pack",
+    "release": "scripts/release.sh",
+    "release:patch": "scripts/release.sh patch",
+    "release:minor": "scripts/release.sh minor",
+    "release:major": "scripts/release.sh major",
+    "security:check": "scripts/local-security-gate.sh",
+    "security:audit": "pnpm audit",
+    "security:audit:fix": "pnpm audit --fix",
+    "security:setup": "scripts/setup-security.sh",
+    "verify": "scripts/verify-and-fix.sh",
+    "monitor": "scripts/monitor-lanes.sh",
+    "monitor:watch": "scripts/monitor-lanes.sh --watch",
+    "monitor:stream": "scripts/stream-logs.sh",
+    "cf": "node dist/cli/index.js",
+    "cf:init": "node dist/cli/index.js init",
+    "cf:setup": "node dist/cli/index.js setup",
+    "cf:prepare": "node dist/cli/index.js prepare",
+    "cf:run": "node dist/cli/index.js run",
+    "cf:monitor": "node dist/cli/index.js monitor",
+    "cf:clean": "node dist/cli/index.js clean",
+    "cf:stop": "node dist/cli/index.js stop",
+    "cf:resume": "node dist/cli/index.js resume",
+    "cf:doctor": "node dist/cli/index.js doctor",
+    "cf:signal": "node dist/cli/index.js signal",
+    "cf:logs": "node dist/cli/index.js logs",
+    "cf:runs": "node dist/cli/index.js runs",
+    "cf:models": "node dist/cli/index.js models",
+    "test:lifecycle": "tests/scripts/test-real-cursor-lifecycle.sh",
+    "test:comprehensive": "tests/scripts/test-comprehensive-lifecycle.sh"
+  }
+}

package/scripts/ai-security-check.js

@@ -6,7 +6,6 @@
  */
 
 const fs = require('fs');
-const path = require('path');
 const { spawnSync } = require('child_process');
 
 // 색상 정의

package/scripts/monitor-lanes.sh

@@ -0,0 +1,94 @@
+#!/bin/bash
+
+# CursorFlow Lane Monitor
+# Displays the latest logs from all active lanes in the current or latest run.
+
+# Colors for output
+BLUE='\033[0;34m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+RED='\033[0;31m'
+NC='\033[0m' # No Color
+BOLD='\033[1m'
+
+LOGS_DIR_BASE="${1:-.}"
+LOGS_DIR="${LOGS_DIR_BASE}/_cursorflow/logs/runs"
+
+# Shift arguments if path was provided
+if [[ -d "$1" && "$1" != "-w" && "$1" != "--watch" ]]; then
+    shift
+fi
+
+# Ensure we are in the root of the project or target dir
+if [ ! -d "$LOGS_DIR" ]; then
+    echo -e "${RED}Error: ${LOGS_DIR} directory not found.${NC}"
+    echo "Please run this script from the root of the CursorFlow project or provide a path."
+    exit 1
+fi
+
+# Find the latest run directory
+LATEST_RUN=$(ls -td ${LOGS_DIR}/run-* 2>/dev/null | head -n 1)
+
+if [ -z "$LATEST_RUN" ]; then
+    echo -e "${YELLOW}No runs found in ${LOGS_DIR}${NC}"
+    exit 1
+fi
+
+RUN_ID=$(basename "$LATEST_RUN")
+
+# Clear screen if requested or if using watch
+show_summary() {
+    echo -e "${BOLD}CursorFlow Lane Monitor${NC} - Run: ${GREEN}${RUN_ID}${NC}"
+    echo -e "Time: $(date '+%Y-%m-%d %H:%M:%S')"
+    echo "--------------------------------------------------------------------------------"
+
+    for lane_dir in "${LATEST_RUN}/lanes"/*; do
+        if [ -d "$lane_dir" ]; then
+            lane_name=$(basename "$lane_dir")
+            log_file="${lane_dir}/terminal-readable.log"
+            
+            # Extract status if possible (last line of log often contains status info)
+            if [ -f "$log_file" ]; then
+                # Get the last few lines
+                LAST_LOG=$(tail -n 1 "$log_file")
+                
+                # Check for completion or errors
+                STATUS="${BLUE}RUNNING${NC}"
+                if grep -q "✅ Pipeline completed" "$log_file" 2>/dev/null; then
+                     STATUS="${GREEN}SUCCESS${NC}"
+                elif grep -q "❌ Pipeline failed" "$log_file" 2>/dev/null; then
+                     STATUS="${RED}ERROR${NC}"
+                elif grep -q "❌ Task failed" "$log_file" 2>/dev/null; then
+                     STATUS="${RED}ERROR${NC}"
+                elif grep -q "✅ ✓ Configuration valid" "$log_file" 2>/dev/null; then
+                     STATUS="${BLUE}ACTIVE${NC}"
+                fi
+                
+                echo -e "[${STATUS}] ${BOLD}${lane_name}${NC}"
+                echo -e "   ${LAST_LOG:0:100}"
+                echo ""
+            else
+                echo -e "[${YELLOW}WAITING${NC}] ${BOLD}${lane_name}${NC}"
+                echo "   (No logs yet)"
+                echo ""
+            fi
+        fi
+    done
+}
+
+# Check for watch mode
+if [[ "$1" == "-w" || "$1" == "--watch" ]]; then
+    # Use simple loop to avoid argument passing issues with 'watch' command
+    while true; do
+        clear
+        show_summary
+        echo "Press Ctrl+C to stop..."
+        sleep 2
+    done
+else
+    show_summary
+    echo -e "${NC}Tip: Use ${BOLD}$0 --watch${NC} to monitor in real-time."
+fi
+
+exit 0
+

package/scripts/patches/test-cursor-agent.js

@@ -15,7 +15,6 @@
  */
 
 const { spawn, spawnSync } = require('child_process');
-const path = require('path');
 
 // Parse args
 const args = process.argv.slice(2);

package/scripts/stream-logs.sh

@@ -0,0 +1,72 @@
+#!/bin/bash
+
+# CursorFlow All Lanes Log Streamer
+# Replicates the output of 'cursorflow run' by streaming logs from all lanes.
+
+BLUE='\033[0;34m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+RED='\033[0;31m'
+NC='\033[0m' # No Color
+BOLD='\033[1m'
+
+LOGS_DIR_BASE="${1:-.}"
+LOGS_DIR="${LOGS_DIR_BASE}/_cursorflow/logs/runs"
+
+if [ ! -d "$LOGS_DIR" ]; then
+    echo -e "${RED}Error: ${LOGS_DIR} directory not found.${NC}"
+    exit 1
+fi
+
+LATEST_RUN=$(ls -td ${LOGS_DIR}/run-* 2>/dev/null | head -n 1)
+
+if [ -z "$LATEST_RUN" ]; then
+    echo -e "${YELLOW}No runs found in ${LOGS_DIR}${NC}"
+    exit 1
+fi
+
+RUN_ID=$(basename "$LATEST_RUN")
+echo -e "${BOLD}Streaming logs for Run: ${GREEN}${RUN_ID}${NC}"
+echo "--------------------------------------------------------------------------------"
+
+# Function to stream a single log file with a prefix
+stream_log() {
+    local lane_name=$1
+    local log_file=$2
+    local color=$3
+    
+    # Check if file exists, if not wait for it
+    until [ -f "$log_file" ]; do
+        sleep 1
+    done
+
+    # Tail the file and prefix each line
+    tail -n +1 -f "$log_file" | while IFS= read -r line; do
+        echo -e "${color}[${lane_name}]${NC} ${line}"
+    done
+}
+
+# Colors to rotate through
+COLORS=('\033[0;32m' '\033[0;34m' '\033[0;35m' '\033[0;36m' '\033[1;32m' '\033[1;34m' '\033[1;35m' '\033[1;36m')
+color_idx=0
+
+# Clean up background processes on exit
+trap 'kill $(jobs -p) 2>/dev/null' EXIT
+
+# Find all lanes and start streaming
+for lane_dir in "${LATEST_RUN}/lanes"/*; do
+    if [ -d "$lane_dir" ]; then
+        lane_name=$(basename "$lane_dir")
+        log_file="${lane_dir}/terminal-readable.log"
+        color=${COLORS[$color_idx]}
+        
+        # Start streaming in background
+        stream_log "$lane_name" "$log_file" "$color" &
+        
+        color_idx=$(( (color_idx + 1) % ${#COLORS[@]} ))
+    fi
+done
+
+# Wait for all background processes
+wait
+

package/src/cli/clean.ts

@@ -10,6 +10,7 @@ import * as logger from '../utils/logger';
 import * as git from '../utils/git';
 import { loadConfig, getLogsDir, getTasksDir } from '../utils/config';
 import { safeJoin } from '../utils/path';
+import { RunService } from '../utils/run-service';
 
 interface CleanOptions {
   type?: string;
@@ -20,6 +21,9 @@ interface CleanOptions {
   help: boolean;
   keepLatest: boolean;
   includeLatest: boolean;
+  run?: string;
+  olderThan?: number;
+  orphaned: boolean;
 }
 
 function printHelp(): void {
@@ -36,6 +40,9 @@ Types:
   all                    Remove all of the above (default)
 
 Options:
+  --run <id>             Clean resources linked to a specific run
+  --older-than <days>    Clean resources older than N days
+  --orphaned             Clean orphaned resources (not linked to any run)
   --dry-run              Show what would be removed without deleting
   --force                Force removal (ignore uncommitted changes)
   --include-latest       Also remove the most recent item (by default, latest is kept)
@@ -45,6 +52,9 @@ Options:
 
 function parseArgs(args: string[]): CleanOptions {
   const includeLatest = args.includes('--include-latest');
+  const runIdx = args.indexOf('--run');
+  const olderThanIdx = args.indexOf('--older-than');
+
   return {
     type: args.find(a => ['branches', 'worktrees', 'logs', 'tasks', 'all'].includes(a)),
     pattern: null,
@@ -54,6 +64,9 @@ function parseArgs(args: string[]): CleanOptions {
     help: args.includes('--help') || args.includes('-h'),
     keepLatest: !includeLatest, // Default: keep latest, unless --include-latest is specified
     includeLatest,
+    run: runIdx >= 0 ? args[runIdx + 1] : undefined,
+    olderThan: olderThanIdx >= 0 ? parseInt(args[olderThanIdx + 1] || '0') : undefined,
+    orphaned: args.includes('--orphaned'),
   };
 }
 
@@ -79,9 +92,33 @@ async function clean(args: string[]): Promise<void> {
 
   const config = loadConfig();
   const repoRoot = git.getRepoRoot();
+  const logsDir = getLogsDir(config);
+  const runsDir = safeJoin(logsDir, 'runs');
+  const runService = new RunService(runsDir);
 
   logger.section('🧹 Cleaning CursorFlow Resources');
 
+  // Handle specific run cleanup
+  if (options.run) {
+    await cleanRunResources(runService, options.run, repoRoot, options);
+    logger.success('\n✨ Run cleaning complete!');
+    return;
+  }
+
+  // Handle older-than cleanup
+  if (options.olderThan !== undefined) {
+    await cleanOlderRuns(runService, options.olderThan, repoRoot, options);
+    logger.success(`\n✨ Older than ${options.olderThan} days cleaning complete!`);
+    return;
+  }
+
+  // Handle orphaned cleanup
+  if (options.orphaned) {
+    await cleanOrphanedResources(runService, config, repoRoot, options);
+    logger.success('\n✨ Orphaned resources cleaning complete!');
+    return;
+  }
+
   const type = options.type || 'all';
 
   if (type === 'all') {
@@ -338,4 +375,147 @@ async function cleanTasks(config: any, options: CleanOptions) {
   }
 }
 
+async function cleanRunResources(runService: RunService, runId: string, repoRoot: string, options: CleanOptions) {
+  const run = runService.getRunInfo(runId);
+  if (!run) {
+    logger.warn(`Run not found: ${runId}`);
+    return;
+  }
+
+  logger.info(`\nCleaning resources for run: ${runId} (${run.taskName})`);
+
+  // Clean branches
+  if (run.branches.length > 0) {
+    logger.info('  Cleaning branches...');
+    for (const branch of run.branches) {
+      if (options.dryRun) {
+        logger.info(`    [DRY RUN] Would delete branch: ${branch}`);
+      } else {
+        try {
+          git.deleteBranch(branch, { cwd: repoRoot, force: true });
+          logger.info(`    Deleted branch: ${branch}`);
+        } catch (e: any) {
+          logger.warn(`    Could not delete branch ${branch}: ${e.message}`);
+        }
+      }
+    }
+  }
+
+  // Clean worktrees
+  if (run.worktrees.length > 0) {
+    logger.info('  Cleaning worktrees...');
+    for (const wtPath of run.worktrees) {
+      if (options.dryRun) {
+        logger.info(`    [DRY RUN] Would remove worktree: ${wtPath}`);
+      } else {
+        try {
+          git.removeWorktree(wtPath, { cwd: repoRoot, force: true });
+          if (fs.existsSync(wtPath)) {
+            fs.rmSync(wtPath, { recursive: true, force: true });
+          }
+          logger.info(`    Removed worktree: ${wtPath}`);
+        } catch (e: any) {
+          logger.warn(`    Could not remove worktree ${wtPath}: ${e.message}`);
+        }
+      }
+    }
+  }
+
+  // Delete run directory
+  if (options.dryRun) {
+    logger.info(`  [DRY RUN] Would delete run directory: ${run.path}`);
+  } else {
+    try {
+      runService.deleteRun(runId, { force: options.force });
+      logger.info(`  Deleted run directory: ${run.path}`);
+    } catch (e: any) {
+      logger.error(`  Failed to delete run ${runId}: ${e.message}`);
+    }
+  }
+}
+
+async function cleanOlderRuns(runService: RunService, days: number, repoRoot: string, options: CleanOptions) {
+  const cutoff = Date.now() - (days * 24 * 60 * 60 * 1000);
+  const runs = runService.listRuns();
+  const olderRuns = runs.filter(run => run.startTime < cutoff);
+
+  if (olderRuns.length === 0) {
+    logger.info(`No runs found older than ${days} days.`);
+    return;
+  }
+
+  logger.info(`Found ${olderRuns.length} runs older than ${days} days.`);
+  for (const run of olderRuns) {
+    await cleanRunResources(runService, run.id, repoRoot, options);
+  }
+}
+
+async function cleanOrphanedResources(runService: RunService, config: any, repoRoot: string, options: CleanOptions) {
+  const runs = runService.listRuns();
+  const linkedWorktrees = new Set(runs.flatMap(r => r.worktrees));
+  const linkedBranches = new Set(runs.flatMap(r => r.branches));
+
+  // Clean orphaned worktrees
+  logger.info('\nChecking for orphaned worktrees...');
+  const worktrees = git.listWorktrees(repoRoot);
+  const worktreeRoot = safeJoin(repoRoot, config.worktreeRoot || '_cursorflow/worktrees');
+  
+  const orphanedWorktrees = worktrees.filter(wt => {
+    if (wt.path === repoRoot) return false;
+    const isInsideRoot = wt.path.startsWith(worktreeRoot);
+    const hasPrefix = path.basename(wt.path).startsWith(config.worktreePrefix || 'cursorflow-');
+    return (isInsideRoot || hasPrefix) && !linkedWorktrees.has(wt.path);
+  });
+
+  if (orphanedWorktrees.length === 0) {
+    logger.info('  No orphaned worktrees found.');
+  } else {
+    for (const wt of orphanedWorktrees) {
+      if (options.dryRun) {
+        logger.info(`  [DRY RUN] Would remove orphaned worktree: ${wt.path}`);
+      } else {
+        try {
+          git.removeWorktree(wt.path, { cwd: repoRoot, force: true });
+          if (fs.existsSync(wt.path)) {
+            fs.rmSync(wt.path, { recursive: true, force: true });
+          }
+          logger.info(`  Removed orphaned worktree: ${wt.path}`);
+        } catch (e: any) {
+          logger.warn(`  Could not remove orphaned worktree ${wt.path}: ${e.message}`);
+        }
+      }
+    }
+  }
+
+  // Clean orphaned branches
+  logger.info('\nChecking for orphaned branches...');
+  const result = git.runGitResult(['branch', '--list'], { cwd: repoRoot });
+  if (result.success) {
+    const branches = result.stdout
+      .split('\n')
+      .map(b => b.replace(/\*/g, '').trim())
+      .filter(b => b && b !== 'main' && b !== 'master');
+
+    const prefix = config.branchPrefix || 'feature/';
+    const orphanedBranches = branches.filter(b => b.startsWith(prefix) && !linkedBranches.has(b));
+
+    if (orphanedBranches.length === 0) {
+      logger.info('  No orphaned branches found.');
+    } else {
+      for (const branch of orphanedBranches) {
+        if (options.dryRun) {
+          logger.info(`  [DRY RUN] Would delete orphaned branch: ${branch}`);
+        } else {
+          try {
+            git.deleteBranch(branch, { cwd: repoRoot, force: true });
+            logger.info(`  Deleted orphaned branch: ${branch}`);
+          } catch (e: any) {
+            logger.warn(`  Could not delete orphaned branch ${branch}: ${e.message}`);
+          }
+        }
+      }
+    }
+  }
+}
+
 export = clean;

package/src/cli/index.ts

@@ -21,6 +21,9 @@ const COMMANDS: Record<string, CommandFn> = {
   signal: require('./signal'),
   models: require('./models'),
   logs: require('./logs'),
+  runs: require('./runs'),
+  tasks: require('./tasks'),
+  stop: require('./stop'),
   setup: require('./setup-commands').main,
   'setup-commands': require('./setup-commands').main,
 };
@@ -38,6 +41,9 @@ function printHelp(): void {
   \x1b[33mprepare\x1b[0m <feature> [opts]    Prepare task directory and JSON files
   \x1b[33mrun\x1b[0m <tasks-dir> [options]   Run orchestration (DAG-based)
   \x1b[33mmonitor\x1b[0m [run-dir] [options] \x1b[36mInteractive\x1b[0m lane dashboard
+  \x1b[33mtasks\x1b[0m [name] [options]      Browse and validate prepared tasks
+  \x1b[33mruns\x1b[0m [run-id] [options]     List and view run details
+  \x1b[33mstop\x1b[0m [run-id] [options]     Stop running workflows
   \x1b[33mclean\x1b[0m <type> [options]      Clean branches/worktrees/logs/tasks
   \x1b[33mresume\x1b[0m [lane] [options]     Resume lane(s) - use --all for batch resume
   \x1b[33mdoctor\x1b[0m [options]            Check environment and preflight
@@ -56,6 +62,7 @@ function printHelp(): void {
   $ \x1b[32mcursorflow run _cursorflow/tasks/MyFeature/\x1b[0m
   $ \x1b[32mcursorflow monitor latest\x1b[0m
   $ \x1b[32mcursorflow logs --all --follow\x1b[0m
+  $ \x1b[32mcursorflow runs --running\x1b[0m
   $ \x1b[32mcursorflow resume --all\x1b[0m
   $ \x1b[32mcursorflow doctor\x1b[0m
   $ \x1b[32mcursorflow models\x1b[0m

package/src/cli/init.ts

@@ -112,7 +112,7 @@ function createExampleTasks(projectRoot: string, config: CursorFlowConfig): void
   
   const exampleTask = {
     repository: "https://github.com/your-org/your-repo",
-    baseBranch: "main",
+    // baseBranch is auto-detected from current branch at runtime
     branchPrefix: "cursorflow/example-",
     executor: "cursor-agent",
     autoCreatePr: false,