@litmers/cursorflow-orchestrator 0.1.31 → 0.1.36

package/src/cli/stop.ts

@@ -86,7 +86,15 @@ async function stop(args: string[]): Promise<void> {
     return;
   }
   
+  const originalCwd = process.cwd();
   const config = loadConfig();
+  
+  // Change current directory to project root for consistent path handling
+  if (config.projectRoot !== originalCwd) {
+    logger.debug(`Changing directory to project root: ${config.projectRoot}`);
+    process.chdir(config.projectRoot);
+  }
+
   const logsDir = getLogsDir(config);
   const runsDir = safeJoin(logsDir, 'runs');
   const runService = new RunService(runsDir);

package/src/cli/tasks.ts

@@ -2,36 +2,55 @@
  * CursorFlow tasks command
  *
  * Usage:
- *   cursorflow tasks              # List all tasks
- *   cursorflow tasks --validate   # List all tasks with validation
- *   cursorflow tasks <name>       # Show detailed task info
+ *   cursorflow tasks              # List all flows (new) and tasks (legacy)
+ *   cursorflow tasks --flows      # List only flows
+ *   cursorflow tasks --legacy     # List only legacy tasks
+ *   cursorflow tasks --validate   # List with validation
+ *   cursorflow tasks <name>       # Show detailed info
  */
 
+import * as fs from 'fs';
+import * as path from 'path';
 import * as logger from '../utils/logger';
 import { TaskService, TaskDirInfo, ValidationStatus } from '../utils/task-service';
-import { findProjectRoot, loadConfig, getTasksDir } from '../utils/config';
+import { findProjectRoot, loadConfig, getTasksDir, getFlowsDir } from '../utils/config';
+import { safeJoin } from '../utils/path';
 
 const COLORS = logger.COLORS;
 
+interface FlowInfo {
+  id: string;
+  name: string;
+  path: string;
+  timestamp: Date;
+  lanes: string[];
+  status: string;
+}
+
 interface TasksCliOptions {
   validate: boolean;
   taskName: string | null;
+  flowsOnly: boolean;
+  legacyOnly: boolean;
 }
 
 function printHelp(): void {
   console.log(`
-Usage: cursorflow tasks [options] [task-name]
+Usage: cursorflow tasks [options] [name]
 
-Manage and view prepared tasks in _cursorflow/tasks/.
+List and view flows (new) and prepared tasks (legacy).
 
 Options:
-  --validate             Run validation on all tasks before listing
+  --flows                Show only flows (from _cursorflow/flows/)
+  --legacy               Show only legacy tasks (from _cursorflow/tasks/)
+  --validate             Run validation before listing
   --help, -h             Show help
 
 Examples:
-  cursorflow tasks
-  cursorflow tasks --validate
-  cursorflow tasks 2412221530_AuthSystem
+  cursorflow tasks                    # List all flows and tasks
+  cursorflow tasks --flows            # List only flows
+  cursorflow tasks TestFeature        # Show flow or task details
+  cursorflow tasks --validate         # Validate all entries
   `);
 }
 
@@ -39,6 +58,8 @@ function parseArgs(args: string[]): TasksCliOptions {
   const options: TasksCliOptions = {
     validate: args.includes('--validate'),
     taskName: null,
+    flowsOnly: args.includes('--flows'),
+    legacyOnly: args.includes('--legacy'),
   };
 
   const nameArg = args.find(arg => !arg.startsWith('-'));
@@ -54,6 +75,136 @@ function parseArgs(args: string[]): TasksCliOptions {
   return options;
 }
 
+/**
+ * List flows from _cursorflow/flows/
+ */
+function listFlows(flowsDir: string): FlowInfo[] {
+  if (!fs.existsSync(flowsDir)) {
+    return [];
+  }
+
+  const dirs = fs.readdirSync(flowsDir)
+    .filter(name => {
+      const dirPath = safeJoin(flowsDir, name);
+      return fs.statSync(dirPath).isDirectory() && !name.startsWith('.');
+    })
+    .sort((a, b) => b.localeCompare(a)); // Most recent first
+
+  return dirs.map(name => {
+    const flowPath = safeJoin(flowsDir, name);
+    const metaPath = safeJoin(flowPath, 'flow.meta.json');
+    
+    let meta: any = {};
+    try {
+      if (fs.existsSync(metaPath)) {
+        meta = JSON.parse(fs.readFileSync(metaPath, 'utf-8'));
+      }
+    } catch {}
+
+    // Parse flow name from directory (e.g., "001_TestFeature" -> "TestFeature")
+    const match = name.match(/^(\d+)_(.+)$/);
+    const id = match ? match[1] : name;
+    const flowName = match ? match[2] : name;
+
+    // Get lane files
+    const laneFiles = fs.readdirSync(flowPath)
+      .filter(f => f.endsWith('.json') && f !== 'flow.meta.json')
+      .map(f => {
+        const laneMatch = f.match(/^\d+-([^.]+)\.json$/);
+        return laneMatch ? laneMatch[1] : f.replace('.json', '');
+      });
+
+    return {
+      id,
+      name: flowName,
+      path: flowPath,
+      timestamp: meta.createdAt ? new Date(meta.createdAt) : new Date(),
+      lanes: laneFiles,
+      status: meta.status || 'pending',
+    };
+  });
+}
+
+/**
+ * Get flow info by name
+ */
+function getFlowInfo(flowsDir: string, flowName: string): FlowInfo | null {
+  const flows = listFlows(flowsDir);
+  return flows.find(f => f.name === flowName || `${f.id}_${f.name}` === flowName) || null;
+}
+
+/**
+ * Print flows list
+ */
+function printFlowsList(flows: FlowInfo[]): void {
+  if (flows.length === 0) {
+    logger.info('No flows found in _cursorflow/flows/');
+    return;
+  }
+
+  console.log(`${COLORS.bold}Flows:${COLORS.reset}`);
+  
+  for (let i = 0; i < flows.length; i++) {
+    const flow = flows[i]!;
+    const prefix = i === 0 ? '  ▶' : '   ';
+    const name = `${flow.id}_${flow.name}`.padEnd(30);
+    const lanes = `${flow.lanes.length} lane${flow.lanes.length !== 1 ? 's' : ''}`.padEnd(10);
+    const status = flow.status.padEnd(10);
+    const date = formatDate(flow.timestamp);
+    
+    let color = COLORS.reset;
+    if (flow.status === 'completed') color = COLORS.green;
+    else if (flow.status === 'running') color = COLORS.cyan;
+    else if (flow.status === 'failed') color = COLORS.red;
+
+    console.log(`${color}${prefix} ${name} ${lanes} ${status} ${date}${COLORS.reset}`);
+  }
+}
+
+/**
+ * Print flow details
+ */
+function printFlowDetail(flow: FlowInfo, flowsDir: string): void {
+  console.log(`${COLORS.bold}Flow: ${flow.name}${COLORS.reset}`);
+  console.log(`${COLORS.cyan}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${COLORS.reset}`);
+  console.log(`  ID: ${flow.id}`);
+  console.log(`  Status: ${flow.status}`);
+  console.log(`  Path: ${flow.path}`);
+  console.log('');
+
+  if (flow.lanes.length === 0) {
+    console.log('No lanes defined.');
+  } else {
+    console.log(`${COLORS.bold}Lanes:${COLORS.reset}`);
+    for (const laneName of flow.lanes) {
+      // Read lane file for task info
+      const laneFiles = fs.readdirSync(flow.path)
+        .filter(f => f.endsWith('.json') && f !== 'flow.meta.json');
+      
+      const laneFile = laneFiles.find(f => {
+        const match = f.match(/^\d+-([^.]+)\.json$/);
+        return match && match[1] === laneName;
+      });
+
+      if (laneFile) {
+        try {
+          const laneData = JSON.parse(fs.readFileSync(safeJoin(flow.path, laneFile), 'utf-8'));
+          const tasks = laneData.tasks || [];
+          const taskFlow = tasks.map((t: any) => t.name).join(' → ');
+          console.log(`  ${laneName.padEnd(18)} ${COLORS.blue}[${tasks.length} tasks]${COLORS.reset} ${taskFlow}`);
+        } catch {
+          console.log(`  ${laneName.padEnd(18)} ${COLORS.yellow}[error reading]${COLORS.reset}`);
+        }
+      } else {
+        console.log(`  ${laneName}`);
+      }
+    }
+  }
+  
+  console.log('');
+  console.log(`${COLORS.gray}Run: cursorflow run ${flow.name}${COLORS.reset}`);
+}
+
 function formatDate(date: Date): string {
   const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
   return `${months[date.getMonth()]} ${date.getDate()}`;
@@ -107,9 +258,8 @@ function printTaskDetail(info: TaskDirInfo): void {
       const fileName = lane.fileName.padEnd(18);
       const preset = `[${lane.preset}]`.padEnd(10);
       const flow = lane.taskFlow;
-      const depends = lane.dependsOn.length > 0 ? ` ${COLORS.gray}(depends: ${lane.dependsOn.join(', ')})${COLORS.reset}` : '';
       
-      console.log(`  ${fileName} ${COLORS.blue}${preset}${COLORS.reset} ${flow}${depends}`);
+      console.log(`  ${fileName} ${COLORS.blue}${preset}${COLORS.reset} ${flow}`);
     }
   }
 
@@ -119,25 +269,37 @@ async function tasks(args: string[]): Promise<void> {
   const options = parseArgs(args);
   const projectRoot = findProjectRoot();
   const config = loadConfig(projectRoot);
+  const flowsDir = getFlowsDir(config);
   const tasksDir = getTasksDir(config);
   const taskService = new TaskService(tasksDir);
 
+  // Check for specific flow/task by name
   if (options.taskName) {
-    const info = taskService.getTaskDirInfo(options.taskName);
-    if (!info) {
-      logger.error(`Task not found: ${options.taskName}`);
-      process.exit(1);
+    // First try to find as a flow
+    const flowInfo = getFlowInfo(flowsDir, options.taskName);
+    if (flowInfo) {
+      printFlowDetail(flowInfo, flowsDir);
+      return;
     }
     
-    // Always validate for detail view to have report
+    // Then try as a legacy task
+    const taskInfo = taskService.getTaskDirInfo(options.taskName);
+    if (taskInfo) {
     taskService.validateTaskDir(options.taskName);
     const updatedInfo = taskService.getTaskDirInfo(options.taskName)!;
-    
     printTaskDetail(updatedInfo);
-  } else {
-    let taskList = taskService.listTaskDirs();
+      return;
+    }
+    
+    logger.error(`Flow or task not found: ${options.taskName}`);
+    process.exit(1);
+  }
+
+  // List flows and/or tasks
+  const flows = options.legacyOnly ? [] : listFlows(flowsDir);
+  let taskList = options.flowsOnly ? [] : taskService.listTaskDirs();
     
-    if (options.validate) {
+  if (options.validate && taskList.length > 0) {
       const spinner = logger.createSpinner('Validating tasks...');
       spinner.start();
       for (const task of taskList) {
@@ -147,8 +309,25 @@ async function tasks(args: string[]): Promise<void> {
       taskList = taskService.listTaskDirs();
     }
     
+  // Print results
+  if (flows.length > 0) {
+    printFlowsList(flows);
+    if (taskList.length > 0) {
+      console.log('');
+    }
+  }
+  
+  if (taskList.length > 0) {
+    console.log(`${COLORS.gray}Legacy Tasks:${COLORS.reset}`);
     printTasksList(taskList);
   }
+  
+  if (flows.length === 0 && taskList.length === 0) {
+    logger.info('No flows or tasks found.');
+    console.log('');
+    console.log('Create a new flow:');
+    console.log('  cursorflow new <FlowName> --lanes "lane1,lane2"');
+  }
 }
 
 export = tasks;

package/src/core/failure-policy.ts

@@ -129,6 +129,15 @@ export interface FailureContext {
 /**
  * Analyze stall condition with multi-layer detection and escalating recovery
  * 
+ * @deprecated Use StallDetectionService from './stall-detection' instead.
+ * This function is kept for backward compatibility but will be removed in a future version.
+ * 
+ * The new unified StallDetectionService provides:
+ * - Single source of truth for stall state
+ * - Automatic recovery action execution
+ * - Better heartbeat filtering
+ * - Consistent state management
+ * 
  * Recovery escalation stages:
  * 1. Phase 0 → Phase 1: Send continue signal (after 2 min idle)
  * 2. Phase 1 → Phase 2: Send stronger prompt (after 2 min grace)