@litmers/cursorflow-orchestrator 0.1.34 → 0.1.36

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()}`;
@@ -118,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) {
@@ -146,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/orchestrator.ts

@@ -278,11 +278,12 @@ export function spawnLane({
   };
   
   if (logConfig.enabled) {
-    // Helper to get dynamic lane label like [L01-T01-laneName]
+    // Helper to get dynamic lane label like [L1-T1-lanename10]
     const getDynamicLabel = () => {
-      const laneNum = `L${(laneIndex + 1).toString().padStart(2, '0')}`;
-      const taskPart = info.currentTaskIndex ? `-T${info.currentTaskIndex.toString().padStart(2, '0')}` : '';
-      return `[${laneNum}${taskPart}-${laneName}]`;
+      const laneNum = `L${laneIndex + 1}`;
+      const taskPart = info.currentTaskIndex ? `-T${info.currentTaskIndex}` : '';
+      const shortLaneName = laneName.substring(0, 10);
+      return `[${laneNum}${taskPart}-${shortLaneName}]`;
     };
 
     // Create callback for clean console output
@@ -474,7 +475,7 @@ export function listLaneFiles(tasksDir: string): LaneInfo[] {
   
   const files = fs.readdirSync(tasksDir);
   return files
-    .filter(f => f.endsWith('.json'))
+    .filter(f => f.endsWith('.json') && f !== 'flow.meta.json')
     .sort()
     .map(f => {
       const filePath = safeJoin(tasksDir, f);

package/src/services/logging/console.ts

@@ -143,7 +143,8 @@ export function withContext(context: string) {
  */
 export function laneOutput(laneName: string, message: string, isError = false): void {
   const timestamp = `${COLORS.gray}[${formatTimestamp()}]${COLORS.reset}`;
-  const laneLabel = `${COLORS.magenta}${laneName.padEnd(10)}${COLORS.reset}`;
+  const shortName = laneName.substring(0, 10).padEnd(10);
+  const laneLabel = `${COLORS.magenta}${shortName}${COLORS.reset}`;
   const output = isError ? `${COLORS.red}${message}${COLORS.reset}` : message;
   
   if (isError) {

package/src/utils/config.ts

@@ -112,12 +112,19 @@ export function loadConfig(projectRoot: string | null = null): CursorFlowConfig
 }
 
 /**
- * Get absolute path for tasks directory
+ * Get absolute path for tasks directory (legacy)
  */
 export function getTasksDir(config: CursorFlowConfig): string {
   return safeJoin(config.projectRoot, config.tasksDir);
 }
 
+/**
+ * Get absolute path for flows directory (new architecture)
+ */
+export function getFlowsDir(config: CursorFlowConfig): string {
+  return safeJoin(config.projectRoot, config.flowsDir);
+}
+
 /**
  * Get absolute path for logs directory
  */

package/src/utils/doctor.ts

@@ -19,6 +19,8 @@ import * as git from './git';
 import { checkCursorAgentInstalled, checkCursorAuth } from './cursor-agent';
 import { areCommandsInstalled } from '../cli/setup-commands';
 import { safeJoin } from './path';
+import { findFlowDir } from './flow';
+import { loadConfig, getFlowsDir } from './config';
 
 export type DoctorSeverity = 'error' | 'warn';
 
@@ -150,7 +152,7 @@ function branchExists(repoRoot: string, branchName: string): boolean {
 function readLaneJsonFiles(tasksDir: string): { path: string; json: any; fileName: string }[] {
   const files = fs
     .readdirSync(tasksDir)
-    .filter(f => f.endsWith('.json'))
+    .filter(f => f.endsWith('.json') && f !== 'flow.meta.json')
     .sort()
     .map(f => safeJoin(tasksDir, f));
 
@@ -858,20 +860,46 @@ export function runDoctor(options: DoctorOptions = {}): DoctorReport {
 
   // 2) Tasks-dir checks (optional; used by `cursorflow run` preflight)
   if (options.tasksDir) {
-    const tasksDirAbs = path.isAbsolute(options.tasksDir)
-      ? options.tasksDir
-      : safeJoin(cwd, options.tasksDir);
+    // Resolve tasks dir with flow name support:
+    // 1. Absolute paths are used as-is
+    // 2. Relative paths that exist are used as-is
+    // 3. Try finding as a flow name in flowsDir
+    // 4. Fall back to relative path from cwd
+    let tasksDirAbs = '';
+    if (path.isAbsolute(options.tasksDir)) {
+      tasksDirAbs = options.tasksDir;
+    } else {
+      const relPath = safeJoin(cwd, options.tasksDir);
+      if (fs.existsSync(relPath)) {
+        tasksDirAbs = relPath;
+      } else {
+        // Try finding as a flow name
+        try {
+          const config = loadConfig(repoRoot || cwd);
+          const flowsDir = getFlowsDir(config);
+          const foundFlow = findFlowDir(flowsDir, options.tasksDir);
+          if (foundFlow) {
+            tasksDirAbs = foundFlow;
+          } else {
+            tasksDirAbs = relPath;
+          }
+        } catch {
+          tasksDirAbs = relPath;
+        }
+      }
+    }
     context.tasksDir = tasksDirAbs;
 
     if (!fs.existsSync(tasksDirAbs)) {
       addIssue(issues, {
         id: 'tasks.missing_dir',
         severity: 'error',
-        title: 'Tasks directory not found',
-        message: `Tasks directory does not exist: ${tasksDirAbs}`,
+        title: 'Tasks or Flow directory not found',
+        message: `Tasks/Flow directory does not exist: ${options.tasksDir} (resolved to: ${tasksDirAbs})`,
         fixes: [
-          'Double-check the path you passed to `cursorflow run`',
-          'If needed, run: cursorflow init --example',
+          'Double-check the path or flow name you passed',
+          'Use: cursorflow new <FlowName> --lanes "lane1,lane2" to create a new flow',
+          'Or run: cursorflow init --example for legacy tasks',
         ],
       });
     } else {

package/src/utils/enhanced-logger.ts

@@ -131,12 +131,13 @@ export class EnhancedLogManager {
   }
 
   /**
-   * Get lane-task label like [L01-T02]
+   * Get lane-task label like [L1-T2-lanename10]
    */
   private getLaneTaskLabel(): string {
     const laneNum = (this.session.laneIndex ?? 0) + 1;
     const taskNum = (this.session.taskIndex ?? 0) + 1;
-    return `L${laneNum.toString().padStart(2, '0')}-T${taskNum.toString().padStart(2, '0')}`;
+    const shortLaneName = this.session.laneName.substring(0, 10);
+    return `L${laneNum}-T${taskNum}-${shortLaneName}`;
   }
 
   /**

package/src/utils/flow.ts

@@ -0,0 +1,42 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { safeJoin } from './path';
+
+/**
+ * Find flow directory by name in the flows directory.
+ * Matches by exact name or by suffix (ignoring ID prefix like '001_').
+ * 
+ * @param flowsDir The base flows directory (e.g., _cursorflow/flows)
+ * @param flowName The name of the flow to find
+ * @returns The absolute path to the flow directory, or null if not found
+ */
+export function findFlowDir(flowsDir: string, flowName: string): string | null {
+  if (!fs.existsSync(flowsDir)) {
+    return null;
+  }
+
+  const dirs = fs.readdirSync(flowsDir)
+    .filter(name => {
+      const dirPath = safeJoin(flowsDir, name);
+      try {
+        return fs.statSync(dirPath).isDirectory();
+      } catch {
+        return false;
+      }
+    })
+    .filter(name => {
+      // Match by exact name or by suffix (ignoring ID prefix)
+      const match = name.match(/^\d+_(.+)$/);
+      return match ? match[1] === flowName : name === flowName;
+    });
+
+  if (dirs.length === 0) {
+    return null;
+  }
+
+  // Return the most recent one (highest ID / alphabetical)
+  dirs.sort((a, b) => b.localeCompare(a));
+  return safeJoin(flowsDir, dirs[0]!);
+}
+
+