@litmers/cursorflow-orchestrator 0.1.30 → 0.1.34

package/src/types/config.ts

@@ -51,6 +51,8 @@ export interface EnhancedLogConfig {
 
 export interface CursorFlowConfig {
   tasksDir: string;
+  /** New flows directory (replaces tasksDir in new architecture) */
+  flowsDir: string;
   logsDir: string;
   pofDir: string;
   /** Base branch (optional, auto-detected from current branch if not specified) */
@@ -60,20 +62,18 @@ export interface CursorFlowConfig {
   pollInterval: number;
   allowDependencyChange: boolean;
   lockfileReadOnly: boolean;
-  enableReview: boolean;
-  reviewModel: string;
-  reviewAllTasks?: boolean;
-  maxReviewIterations: number;
   defaultLaneConfig: LaneConfig;
   logLevel: string;
   verboseGit: boolean;
   worktreePrefix: string;
   maxConcurrentLanes: number;
   projectRoot: string;
-  /** Output format for cursor-agent (default: 'stream-json') */
-  agentOutputFormat: 'stream-json' | 'json' | 'plain';
+  /** Output format for cursor-agent (default: 'json') */
+  agentOutputFormat: 'json' | 'plain';
   webhooks?: WebhookConfig[];
   /** Enhanced logging configuration */
   enhancedLogging?: Partial<EnhancedLogConfig>;
+  /** Default AI model for tasks (default: 'gemini-3-flash') */
+  defaultModel: string;
 }
 

package/src/types/flow.ts

@@ -0,0 +1,91 @@
+/**
+ * Flow type definitions for CursorFlow
+ * 
+ * Flow: A collection of Lanes working together on a feature
+ * Lane: A parallel execution path with its own worktree
+ * Task: A unit of work executed by an AI agent
+ */
+
+/**
+ * Flow metadata stored in flow.meta.json
+ */
+export interface FlowMeta {
+  /** Unique ID (sequential number) */
+  id: string;
+  /** Human-readable flow name */
+  name: string;
+  /** Creation timestamp (ISO 8601) */
+  createdAt: string;
+  /** Creator identifier */
+  createdBy: string;
+  /** Git branch this flow started from */
+  baseBranch: string;
+  /** Current flow status */
+  status: FlowStatus;
+  /** List of lane names in this flow */
+  lanes: string[];
+}
+
+/**
+ * Flow execution status
+ */
+export type FlowStatus = 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
+
+/**
+ * Lane configuration stored in {NN}-{laneName}.json
+ */
+export interface LaneConfig {
+  /** Lane identifier (matches filename without prefix/extension) */
+  laneName: string;
+  /** Branch prefix for this lane */
+  branchPrefix?: string;
+  /** Tasks to execute in this lane */
+  tasks: FlowTask[];
+}
+
+/**
+ * Task definition within a lane
+ */
+export interface FlowTask {
+  /** Task identifier (unique within lane) */
+  name: string;
+  /** AI model to use */
+  model: string;
+  /** Task prompt/instructions */
+  prompt: string;
+  /** Acceptance criteria (optional) */
+  acceptanceCriteria?: string[];
+  /** Dependencies: wait for these tasks to complete first */
+  dependsOn?: string[];
+  /** Task timeout in milliseconds (optional) */
+  timeout?: number;
+}
+
+/**
+ * Parsed task spec from CLI --task option
+ */
+export interface ParsedTaskSpec {
+  name: string;
+  model: string;
+  prompt: string;
+  acceptanceCriteria?: string[];
+  dependsOn?: string[];
+  timeout?: number;
+}
+
+/**
+ * Flow directory info for listing
+ */
+export interface FlowInfo {
+  /** Flow ID */
+  id: string;
+  /** Flow name */
+  name: string;
+  /** Full directory path */
+  path: string;
+  /** Flow metadata */
+  meta: FlowMeta;
+  /** Lane count */
+  laneCount: number;
+}
+

package/src/types/index.ts

@@ -3,15 +3,27 @@
  * Re-exports all types from separate modules
  */
 
-// Config
+// Config (LaneConfig defined here)
 export * from './config';
 
-// Lane
+// Lane (LaneInfo, LaneState, etc.)
 export * from './lane';
 
 // Task
 export * from './task';
 
+// Flow (new architecture) - explicit exports to avoid conflicts
+export { 
+  FlowMeta, 
+  FlowStatus, 
+  FlowTask, 
+  ParsedTaskSpec,
+  // Note: LaneConfig and FlowInfo are also defined in config.ts and run.ts
+  // Use aliases if you need the flow-specific versions:
+  LaneConfig as FlowLaneConfig,
+  FlowInfo as FlowDirInfo,
+} from './flow';
+
 // Agent
 export * from './agent';
 
@@ -24,6 +36,6 @@ export * from './events';
 // Logging
 export * from './logging';
 
-// Run
+// Run (FlowInfo also defined here - using this version as default)
 export * from './run';
 

package/src/types/lane.ts

@@ -35,7 +35,6 @@ export interface LaneState {
   dependencyRequest: DependencyRequestPlan | null;
   updatedAt?: number;
   tasksFile?: string; // Original tasks file path
-  dependsOn?: string[];
   pid?: number;
   /** List of completed task names in this lane */
   completedTasks?: string[];
@@ -51,6 +50,5 @@ export interface LaneFileInfo {
   preset: string;
   taskCount: number;
   taskFlow: string;
-  dependsOn: string[];
 }
 

package/src/types/logging.ts

@@ -71,11 +71,15 @@ export interface LogSession {
   model?: string;
   startTime: number;
   metadata?: Record<string, any>;
+  /** Lane index (0-based) for display as L01, L02, etc. */
+  laneIndex?: number;
+  /** Task index (0-based) for display as T01, T02, etc. */
+  taskIndex?: number;
 }
 
 export interface ConversationEntry {
   timestamp: string;
-  role: 'user' | 'assistant' | 'reviewer' | 'system' | 'intervention';
+  role: 'user' | 'assistant' | 'system' | 'intervention';
   task: string | null;
   fullText: string;
   textLength: number;

package/src/types/task.ts

@@ -9,8 +9,6 @@ export interface Task {
   name: string;
   prompt: string;
   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. */
@@ -19,7 +17,6 @@ export interface Task {
 
 export interface RunnerConfig {
   tasks: Task[];
-  dependsOn?: string[];
   pipelineBranch?: string;
   worktreeDir?: string;
   branchPrefix?: string;
@@ -27,13 +24,8 @@ 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[];
+  /** Output format for cursor-agent (default: 'json') */
+  agentOutputFormat?: 'json' | 'plain';
   /** Task execution timeout in milliseconds. Default: 600000 (10 minutes) */
   timeout?: number;
   /** 
@@ -48,6 +40,11 @@ export interface RunnerConfig {
    * Default: false
    */
   noGit?: boolean;
+  /**
+   * Enable verbose Git logging.
+   * Default: false
+   */
+  verboseGit?: boolean;
 }
 
 export interface TaskDirInfo {
@@ -71,7 +68,6 @@ export interface TaskExecutionResult {
 export interface TaskResult {
   taskName: string;
   taskBranch: string;
-  acceptanceCriteria?: string[];
   [key: string]: any;
 }
 

package/src/utils/config.ts

@@ -44,6 +44,7 @@ export function loadConfig(projectRoot: string | null = null): CursorFlowConfig
   const defaults: CursorFlowConfig = {
     // Directories
     tasksDir: '_cursorflow/tasks',
+    flowsDir: '_cursorflow/flows',
     logsDir: '_cursorflow/logs',
     pofDir: '_cursorflow/pof',
     
@@ -59,12 +60,6 @@ export function loadConfig(projectRoot: string | null = null): CursorFlowConfig
     allowDependencyChange: false,
     lockfileReadOnly: true,
     
-    // Review
-    enableReview: false,
-    reviewModel: 'sonnet-4.5-thinking',
-    reviewAllTasks: false,
-    maxReviewIterations: 3,
-    
     // Lane defaults
     defaultLaneConfig: {
       devPort: 3001,
@@ -73,12 +68,12 @@ export function loadConfig(projectRoot: string | null = null): CursorFlowConfig
     
     // Logging
     logLevel: 'info',
-    verboseGit: false,
+    verboseGit: true,
     
     // Advanced
     worktreePrefix: 'cursorflow-',
     maxConcurrentLanes: 10,
-    agentOutputFormat: 'stream-json',
+    agentOutputFormat: 'json',
     
     // Webhooks
     webhooks: [],
@@ -95,6 +90,9 @@ export function loadConfig(projectRoot: string | null = null): CursorFlowConfig
       timestampFormat: 'iso',
     },
     
+    // Default AI model
+    defaultModel: 'gemini-3-flash',
+    
     // Internal
     projectRoot,
   };
@@ -188,12 +186,6 @@ export function createDefaultConfig(projectRoot: string, force = false): string
   allowDependencyChange: false,
   lockfileReadOnly: true,
   
-  // Review configuration
-  enableReview: false,
-  reviewModel: 'sonnet-4.5-thinking',
-  reviewAllTasks: false,
-  maxReviewIterations: 3,
-  
   // Lane configuration
   defaultLaneConfig: {
     devPort: 3001,           // 3000 + laneNumber
@@ -202,12 +194,12 @@ export function createDefaultConfig(projectRoot: string, force = false): string
   
   // Logging
   logLevel: 'info',          // 'error' | 'warn' | 'info' | 'debug'
-  verboseGit: false,
+  verboseGit: true,
   
   // Advanced
   worktreePrefix: 'cursorflow-',
   maxConcurrentLanes: 10,
-  agentOutputFormat: 'stream-json', // 'stream-json' | 'json' | 'plain'
+  agentOutputFormat: 'json', // 'json' | 'plain'
 
   // Webhook configuration
   // webhooks: [

package/src/utils/dependency.ts

@@ -2,16 +2,19 @@
  * Dependency management utilities for CursorFlow
  * 
  * Features:
- * - Cyclic dependency detection
+ * - Task-level cyclic dependency detection
  * - Dependency wait with timeout
  * - Topological sorting
+ * 
+ * Note: Lane-level dependencies have been removed.
+ * Use task-level dependencies (format: "lane:task") for fine-grained control.
  */
 
 import * as fs from 'fs';
 import * as path from 'path';
 import { safeJoin } from './path';
 import { loadState } from './state';
-import { LaneState } from './types';
+import { LaneState, Task, RunnerConfig } from './types';
 import * as logger from './logger';
 
 export interface DependencyInfo {
@@ -19,6 +22,18 @@ export interface DependencyInfo {
   dependsOn: string[];
 }
 
+/** Task-level dependency info for cycle detection */
+export interface TaskDependencyInfo {
+  /** Full identifier: "lane:task" */
+  id: string;
+  /** Lane name */
+  lane: string;
+  /** Task name */
+  task: string;
+  /** Dependencies in "lane:task" format */
+  dependsOn: string[];
+}
+
 export interface CycleDetectionResult {
   hasCycle: boolean;
   cycle: string[] | null;
@@ -480,3 +495,297 @@ export function printDependencyGraph(lanes: DependencyInfo[]): void {
   console.log('');
 }
 
+// ============================================================================
+// Task-Level Dependency Detection (New)
+// ============================================================================
+
+/**
+ * Extract all task dependencies from lane configuration files
+ */
+export function extractTaskDependencies(tasksDir: string): TaskDependencyInfo[] {
+  if (!fs.existsSync(tasksDir)) {
+    return [];
+  }
+  
+  const tasks: TaskDependencyInfo[] = [];
+  const files = fs.readdirSync(tasksDir).filter(f => f.endsWith('.json'));
+  
+  for (const file of files) {
+    const filePath = safeJoin(tasksDir, file);
+    const laneName = path.basename(file, '.json');
+    
+    try {
+      const config = JSON.parse(fs.readFileSync(filePath, 'utf8')) as RunnerConfig;
+      
+      for (const task of config.tasks || []) {
+        const taskId = `${laneName}:${task.name}`;
+        tasks.push({
+          id: taskId,
+          lane: laneName,
+          task: task.name,
+          dependsOn: task.dependsOn || [],
+        });
+      }
+    } catch (e) {
+      logger.warn(`Failed to parse task config from ${file}: ${e}`);
+    }
+  }
+  
+  return tasks;
+}
+
+/**
+ * Detect cyclic dependencies in task-level dependencies
+ */
+export function detectTaskCyclicDependencies(tasks: TaskDependencyInfo[]): CycleDetectionResult {
+  // Build adjacency graph using task IDs (lane:task format)
+  const graph = new Map<string, Set<string>>();
+  const allNodes = new Set<string>();
+  
+  for (const task of tasks) {
+    allNodes.add(task.id);
+    graph.set(task.id, new Set(task.dependsOn));
+    
+    // Add dependency nodes even if they're not in the list
+    for (const dep of task.dependsOn) {
+      allNodes.add(dep);
+      if (!graph.has(dep)) {
+        graph.set(dep, new Set());
+      }
+    }
+  }
+  
+  // Kahn's algorithm for topological sort with cycle detection
+  const inDegree = new Map<string, number>();
+  
+  // Initialize in-degrees
+  for (const node of allNodes) {
+    inDegree.set(node, 0);
+  }
+  
+  for (const [, deps] of graph) {
+    for (const dep of deps) {
+      inDegree.set(dep, (inDegree.get(dep) || 0) + 1);
+    }
+  }
+  
+  // Queue of nodes with no incoming edges
+  const queue: string[] = [];
+  for (const [node, degree] of inDegree) {
+    if (degree === 0) {
+      queue.push(node);
+    }
+  }
+  
+  const sorted: string[] = [];
+  
+  while (queue.length > 0) {
+    const node = queue.shift()!;
+    sorted.push(node);
+    
+    const deps = graph.get(node) || new Set();
+    for (const dep of deps) {
+      const newDegree = (inDegree.get(dep) || 0) - 1;
+      inDegree.set(dep, newDegree);
+      
+      if (newDegree === 0) {
+        queue.push(dep);
+      }
+    }
+  }
+  
+  // If not all nodes are in sorted order, there's a cycle
+  if (sorted.length !== allNodes.size) {
+    const cycle = findTaskCycle(graph, allNodes);
+    return {
+      hasCycle: true,
+      cycle,
+      sortedOrder: null,
+    };
+  }
+  
+  return {
+    hasCycle: false,
+    cycle: null,
+    sortedOrder: sorted,
+  };
+}
+
+/**
+ * Find a cycle in task dependency graph using DFS
+ */
+function findTaskCycle(graph: Map<string, Set<string>>, allNodes: Set<string>): string[] | null {
+  const visited = new Set<string>();
+  const recursionStack = new Set<string>();
+  const parent = new Map<string, string>();
+  
+  function dfs(node: string): string | null {
+    visited.add(node);
+    recursionStack.add(node);
+    
+    const deps = graph.get(node) || new Set();
+    for (const dep of deps) {
+      if (!visited.has(dep)) {
+        parent.set(dep, node);
+        const cycleNode = dfs(dep);
+        if (cycleNode) return cycleNode;
+      } else if (recursionStack.has(dep)) {
+        // Found a cycle
+        parent.set(dep, node);
+        return dep;
+      }
+    }
+    
+    recursionStack.delete(node);
+    return null;
+  }
+  
+  for (const node of allNodes) {
+    if (!visited.has(node)) {
+      const cycleNode = dfs(node);
+      if (cycleNode) {
+        // Reconstruct the cycle
+        const cycle: string[] = [cycleNode];
+        let current = parent.get(cycleNode);
+        while (current && current !== cycleNode) {
+          cycle.push(current);
+          current = parent.get(current);
+        }
+        cycle.push(cycleNode);
+        return cycle.reverse();
+      }
+    }
+  }
+  
+  return null;
+}
+
+/**
+ * Validate task-level dependencies across all lanes
+ */
+export function validateTaskDependencies(tasksDir: string): {
+  valid: boolean;
+  errors: string[];
+  warnings: string[];
+  tasks: TaskDependencyInfo[];
+} {
+  const errors: string[] = [];
+  const warnings: string[] = [];
+  
+  const tasks = extractTaskDependencies(tasksDir);
+  const taskIds = new Set(tasks.map(t => t.id));
+  const laneNames = new Set(tasks.map(t => t.lane));
+  
+  // Check for missing dependencies
+  for (const task of tasks) {
+    for (const dep of task.dependsOn) {
+      // Validate format
+      if (!dep.includes(':')) {
+        errors.push(`Task "${task.id}" has invalid dependency format "${dep}". Expected "lane:task".`);
+        continue;
+      }
+      
+      const [depLane, depTask] = dep.split(':');
+      
+      // Check if lane exists
+      if (!laneNames.has(depLane!)) {
+        errors.push(`Task "${task.id}" depends on unknown lane "${depLane}"`);
+        continue;
+      }
+      
+      // Check if task exists (warning only, since task might be created later)
+      if (!taskIds.has(dep)) {
+        warnings.push(`Task "${task.id}" depends on "${dep}" which doesn't exist yet`);
+      }
+      
+      // Check for self-dependency
+      if (dep === task.id) {
+        errors.push(`Task "${task.id}" depends on itself`);
+      }
+    }
+  }
+  
+  // Check for cycles
+  const cycleResult = detectTaskCyclicDependencies(tasks);
+  if (cycleResult.hasCycle && cycleResult.cycle) {
+    errors.push(`Cyclic task dependency detected: ${cycleResult.cycle.join(' → ')}`);
+  }
+  
+  // Warning for deeply nested dependencies
+  const dependencyCounts = new Map<string, number>();
+  for (const task of tasks) {
+    let count = 0;
+    const visited = new Set<string>();
+    const queue = [...task.dependsOn];
+    
+    while (queue.length > 0) {
+      const dep = queue.shift()!;
+      if (visited.has(dep)) continue;
+      visited.add(dep);
+      count++;
+      
+      const depTask = tasks.find(t => t.id === dep);
+      if (depTask) {
+        queue.push(...depTask.dependsOn);
+      }
+    }
+    
+    dependencyCounts.set(task.id, count);
+    if (count > 10) {
+      warnings.push(`Task "${task.id}" has ${count} transitive dependencies`);
+    }
+  }
+  
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings,
+    tasks,
+  };
+}
+
+/**
+ * Print task-level dependency graph to console
+ */
+export function printTaskDependencyGraph(tasks: TaskDependencyInfo[]): void {
+  const cycleResult = detectTaskCyclicDependencies(tasks);
+  
+  logger.section('📊 Task Dependency Graph');
+  
+  if (cycleResult.hasCycle) {
+    logger.error(`⚠️  Cyclic dependency detected: ${cycleResult.cycle?.join(' → ')}`);
+    console.log('');
+  }
+  
+  // Group tasks by lane
+  const byLane = new Map<string, TaskDependencyInfo[]>();
+  for (const task of tasks) {
+    const existing = byLane.get(task.lane) || [];
+    existing.push(task);
+    byLane.set(task.lane, existing);
+  }
+  
+  for (const [lane, laneTasks] of byLane) {
+    console.log(`  ${logger.COLORS.cyan}${lane}${logger.COLORS.reset}`);
+    
+    for (const task of laneTasks) {
+      const deps = task.dependsOn.length > 0 
+        ? ` → ${task.dependsOn.join(', ')}` 
+        : '';
+      console.log(`    • ${task.task}${logger.COLORS.gray}${deps}${logger.COLORS.reset}`);
+    }
+  }
+  
+  if (cycleResult.sortedOrder) {
+    console.log('');
+    const order = cycleResult.sortedOrder.reverse();
+    if (order.length <= 10) {
+      console.log(`  Execution order: ${order.join(' → ')}`);
+    } else {
+      console.log(`  Execution order: ${order.slice(0, 5).join(' → ')} ... (${order.length} total)`);
+    }
+  }
+  
+  console.log('');
+}
+