@litmers/cursorflow-orchestrator 0.1.20 → 0.1.26

package/src/utils/task-service.ts

@@ -0,0 +1,370 @@
+/**
+ * TaskService - Manages CursorFlow task directories and validation
+ * 
+ * Provides:
+ * - List prepared task directories
+ * - Get task details (lanes, dependencies)
+ * - Validate tasks (doctor integration)
+ * - Check run eligibility
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { TaskDirInfo, LaneFileInfo, ValidationStatus, Task } from './types';
+
+// Re-export types for consumers
+export { TaskDirInfo, LaneFileInfo, ValidationStatus } from './types';
+import * as logger from './logger';
+
+export interface ValidationResult {
+  /** Combined errors + warnings for backwards compatibility */
+  issues: string[];
+  status: ValidationStatus;
+  errors: string[];
+  warnings: string[];
+  lastValidated: number;
+}
+
+// Cache for validation results
+const validationCache = new Map<string, ValidationResult>();
+
+export class TaskService {
+  private tasksDir: string;
+
+  constructor(tasksDir: string) {
+    this.tasksDir = tasksDir;
+  }
+
+  /**
+   * List all prepared task directories
+   */
+  listTaskDirs(): TaskDirInfo[] {
+    if (!fs.existsSync(this.tasksDir)) {
+      return [];
+    }
+
+    const dirs = fs.readdirSync(this.tasksDir)
+      .filter(name => {
+        const dirPath = path.join(this.tasksDir, name);
+        return fs.statSync(dirPath).isDirectory() && !name.startsWith('.');
+      })
+      .sort((a, b) => b.localeCompare(a)); // Most recent first (assuming timestamp prefix)
+
+    return dirs.map(name => this.getTaskDirInfo(name)).filter((t): t is TaskDirInfo => t !== null);
+  }
+
+  /**
+   * Get detailed information about a task directory
+   */
+  getTaskDirInfo(taskName: string): TaskDirInfo | null {
+    const taskPath = path.join(this.tasksDir, taskName);
+    
+    if (!fs.existsSync(taskPath)) {
+      return null;
+    }
+
+    try {
+      const stat = fs.statSync(taskPath);
+      const timestamp = this.parseTimestampFromName(taskName) || stat.mtime;
+      const featureName = this.extractFeatureName(taskName);
+      const lanes = this.scanLaneFiles(taskPath);
+      
+      // Get cached validation status
+      const cached = validationCache.get(taskName);
+      const validationStatus = cached?.status || 'unknown';
+      const lastValidated = cached?.lastValidated;
+
+      return {
+        name: taskName,
+        path: taskPath,
+        timestamp,
+        featureName,
+        lanes,
+        validationStatus,
+        lastValidated,
+      };
+    } catch (error) {
+      logger.debug(`Failed to read task dir ${taskName}: ${error}`);
+      return null;
+    }
+  }
+
+  /**
+   * Scan lane files in a task directory
+   */
+  private scanLaneFiles(taskPath: string): LaneFileInfo[] {
+    const files = fs.readdirSync(taskPath)
+      .filter(name => name.endsWith('.json'))
+      .sort();
+
+    const lanes: LaneFileInfo[] = [];
+
+    for (const fileName of files) {
+      try {
+        const filePath = path.join(taskPath, fileName);
+        const content = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+        
+        const laneName = this.extractLaneName(fileName);
+        const tasks = content.tasks || [];
+        const dependsOn = content.dependsOn || [];
+        const preset = this.detectPreset(tasks);
+        const taskFlow = this.generateTaskFlow(tasks);
+
+        lanes.push({
+          fileName,
+          laneName,
+          preset,
+          taskCount: tasks.length,
+          taskFlow,
+          dependsOn,
+        });
+      } catch (error) {
+        logger.debug(`Failed to parse lane file ${fileName}: ${error}`);
+      }
+    }
+
+    return lanes;
+  }
+
+  /**
+   * Extract lane name from filename (e.g., "01-lane-1.json" -> "lane-1")
+   */
+  private extractLaneName(fileName: string): string {
+    const baseName = fileName.replace('.json', '');
+    // Remove numeric prefix if present (e.g., "01-lane-1" -> "lane-1")
+    const match = baseName.match(/^\d+-(.+)$/);
+    return match ? match[1] : baseName;
+  }
+
+  /**
+   * Parse timestamp from task name (format: YYMMDDHHMM_FeatureName)
+   */
+  private parseTimestampFromName(taskName: string): Date | null {
+    const match = taskName.match(/^(\d{10})_/);
+    if (!match) return null;
+
+    const ts = match[1];
+    const year = 2000 + parseInt(ts.substring(0, 2), 10);
+    const month = parseInt(ts.substring(2, 4), 10) - 1;
+    const day = parseInt(ts.substring(4, 6), 10);
+    const hour = parseInt(ts.substring(6, 8), 10);
+    const minute = parseInt(ts.substring(8, 10), 10);
+
+    return new Date(year, month, day, hour, minute);
+  }
+
+  /**
+   * Extract feature name from task directory name
+   */
+  private extractFeatureName(taskName: string): string {
+    const parts = taskName.split('_');
+    if (parts.length >= 2) {
+      return parts.slice(1).join('_');
+    }
+    return taskName;
+  }
+
+  /**
+   * Detect task preset based on task structure
+   */
+  private detectPreset(tasks: Task[]): string {
+    if (tasks.length === 0) return 'empty';
+    
+    const taskNames = tasks.map(t => t.name.toLowerCase());
+    
+    if (taskNames.includes('plan') && taskNames.includes('implement') && taskNames.includes('test')) {
+      return 'complex';
+    }
+    if (taskNames.includes('implement') && taskNames.includes('test') && !taskNames.includes('plan')) {
+      return 'simple';
+    }
+    if (taskNames.includes('merge')) {
+      return 'merge';
+    }
+    
+    return 'custom';
+  }
+
+  /**
+   * Generate task flow string (e.g., "plan → implement → test")
+   */
+  private generateTaskFlow(tasks: Task[]): string {
+    if (tasks.length === 0) return '';
+    return tasks.map(t => t.name).join(' → ');
+  }
+
+  /**
+   * Validate a task directory
+   */
+  validateTaskDir(taskName: string): ValidationResult {
+    const taskInfo = this.getTaskDirInfo(taskName);
+    
+    if (!taskInfo) {
+      return {
+        status: 'errors',
+        errors: [`Task directory not found: ${taskName}`],
+        warnings: [],
+        issues: [`Task directory not found: ${taskName}`],
+        lastValidated: Date.now(),
+      };
+    }
+
+    const errors: string[] = [];
+    const warnings: string[] = [];
+
+    // Check if there are any lane files
+    if (taskInfo.lanes.length === 0) {
+      errors.push('No lane files found in task directory');
+    }
+
+    // Validate each lane file
+    for (const lane of taskInfo.lanes) {
+      // Check task count
+      if (lane.taskCount === 0) {
+        errors.push(`Lane ${lane.fileName} has no tasks defined`);
+      }
+
+      // Check dependencies exist
+      for (const dep of lane.dependsOn) {
+        const depExists = taskInfo.lanes.some(l => 
+          l.laneName === dep || l.fileName === dep || l.fileName === `${dep}.json`
+        );
+        if (!depExists) {
+          warnings.push(`Lane ${lane.fileName} depends on unknown lane: ${dep}`);
+        }
+      }
+
+      // Validate lane file structure
+      try {
+        const filePath = path.join(taskInfo.path, lane.fileName);
+        const content = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+        
+        // Check tasks array
+        if (!Array.isArray(content.tasks)) {
+          errors.push(`Lane ${lane.fileName}: 'tasks' must be an array`);
+        } else {
+          // Validate each task
+          for (let i = 0; i < content.tasks.length; i++) {
+            const task = content.tasks[i];
+            if (!task.name) {
+              errors.push(`Lane ${lane.fileName}: Task ${i + 1} missing 'name'`);
+            }
+            if (!task.prompt) {
+              errors.push(`Lane ${lane.fileName}: Task ${i + 1} missing 'prompt'`);
+            }
+          }
+        }
+      } catch (error) {
+        errors.push(`Lane ${lane.fileName}: Invalid JSON - ${error}`);
+      }
+    }
+
+    // Check for circular dependencies
+    const circularDeps = this.detectCircularDependencies(taskInfo.lanes);
+    if (circularDeps.length > 0) {
+      errors.push(`Circular dependencies detected: ${circularDeps.join(' -> ')}`);
+    }
+
+    // Determine overall status
+    let status: ValidationStatus = 'valid';
+    if (errors.length > 0) {
+      status = 'errors';
+    } else if (warnings.length > 0) {
+      status = 'warnings';
+    }
+
+    const issues = [...errors, ...warnings];
+    const result: ValidationResult = {
+      issues,
+      status,
+      errors,
+      warnings,
+      lastValidated: Date.now(),
+    };
+
+    // Cache the result
+    validationCache.set(taskName, result);
+
+    return result;
+  }
+
+  /**
+   * Detect circular dependencies in lane dependency graph
+   */
+  private detectCircularDependencies(lanes: LaneFileInfo[]): string[] {
+    const visited = new Set<string>();
+    const stack = new Set<string>();
+    const cycle: string[] = [];
+
+    const dfs = (laneName: string): boolean => {
+      if (stack.has(laneName)) {
+        cycle.push(laneName);
+        return true; // Cycle found
+      }
+      if (visited.has(laneName)) {
+        return false;
+      }
+
+      visited.add(laneName);
+      stack.add(laneName);
+
+      const lane = lanes.find(l => l.laneName === laneName);
+      if (lane) {
+        for (const dep of lane.dependsOn) {
+          if (dfs(dep)) {
+            cycle.unshift(laneName);
+            return true;
+          }
+        }
+      }
+
+      stack.delete(laneName);
+      return false;
+    };
+
+    for (const lane of lanes) {
+      if (dfs(lane.laneName)) {
+        break;
+      }
+    }
+
+    return cycle;
+  }
+
+  /**
+   * Get cached validation status
+   */
+  getValidationStatus(taskName: string): ValidationStatus {
+    const cached = validationCache.get(taskName);
+    return cached?.status || 'unknown';
+  }
+
+  /**
+   * Check if a task can be run
+   */
+  canRun(taskName: string): { ok: boolean; issues: string[] } {
+    const validation = this.validateTaskDir(taskName);
+    
+    if (validation.status === 'errors') {
+      return { ok: false, issues: validation.errors };
+    }
+
+    return { ok: true, issues: validation.warnings };
+  }
+
+  /**
+   * Clear validation cache
+   */
+  clearCache(): void {
+    validationCache.clear();
+  }
+}
+
+/**
+ * Create a TaskService instance with default paths
+ */
+export function createTaskService(projectRoot?: string): TaskService {
+  const root = projectRoot || process.cwd();
+  const tasksDir = path.join(root, '_cursorflow', 'tasks');
+  return new TaskService(tasksDir);
+}

package/src/utils/types.ts

@@ -1,319 +1,6 @@
 /**
  * Shared type definitions for CursorFlow
+ * Re-exports from central types directory for backward compatibility
  */
 
-export interface LaneConfig {
-  devPort: number;
-  autoCreatePr: boolean;
-}
-
-export interface CursorFlowConfig {
-  tasksDir: string;
-  logsDir: string;
-  baseBranch: string;
-  branchPrefix: string;
-  executor: 'cursor-agent' | 'cloud';
-  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';
-  webhooks?: WebhookConfig[];
-  /** Enhanced logging configuration */
-  enhancedLogging?: Partial<EnhancedLogConfig>;
-}
-
-export interface WebhookConfig {
-  enabled?: boolean;
-  url: string;
-  secret?: string;
-  events?: string[]; // ['*'] for all, ['task.*'] for wildcards
-  headers?: Record<string, string>;
-  retries?: number;
-  timeoutMs?: number;
-}
-
-/**
- * Enhanced logging configuration
- */
-export interface EnhancedLogConfig {
-  /** Enable enhanced logging features (default: true) */
-  enabled: boolean;
-  
-  /** Strip ANSI escape codes from clean logs (default: true) */
-  stripAnsi: boolean;
-  
-  /** Add timestamps to each line (default: true) */
-  addTimestamps: boolean;
-  
-  /** Maximum size in bytes before rotation (default: 50MB) */
-  maxFileSize: number;
-  
-  /** Number of rotated files to keep (default: 5) */
-  maxFiles: number;
-  
-  /** Write raw output with ANSI codes to separate file (default: true) */
-  keepRawLogs: boolean;
-  
-  /** Write structured JSON log entries (default: true) */
-  writeJsonLog: boolean;
-  
-  /** Timestamp format: 'iso' | 'relative' | 'short' (default: 'iso') */
-  timestampFormat: 'iso' | 'relative' | 'short';
-}
-
-export interface CursorFlowEvent<T = Record<string, any>> {
-  id: string;
-  type: string;
-  timestamp: string;
-  runId: string;
-  payload: T;
-}
-
-export type EventHandler<T = any> = (event: CursorFlowEvent<T>) => void | Promise<void>;
-
-// Specific Event Payloads
-export interface OrchestrationStartedPayload {
-  runId: string;
-  tasksDir: string;
-  laneCount: number;
-  runRoot: string;
-}
-
-export interface OrchestrationCompletedPayload {
-  runId: string;
-  laneCount: number;
-  completedCount: number;
-  failedCount: number;
-}
-
-export interface OrchestrationFailedPayload {
-  error: string;
-  blockedLanes?: string[];
-}
-
-export interface LaneStartedPayload {
-  laneName: string;
-  pid?: number;
-  logPath: string;
-}
-
-export interface LaneCompletedPayload {
-  laneName: string;
-  exitCode: number;
-}
-
-export interface LaneFailedPayload {
-  laneName: string;
-  exitCode: number;
-  error: string;
-}
-
-export interface LaneDependencyRequestedPayload {
-  laneName: string;
-  dependencyRequest: DependencyRequestPlan;
-}
-
-export interface TaskStartedPayload {
-  taskName: string;
-  taskBranch: string;
-  index: number;
-}
-
-export interface TaskCompletedPayload {
-  taskName: string;
-  taskBranch: string;
-  status: string;
-}
-
-export interface TaskFailedPayload {
-  taskName: string;
-  taskBranch: string;
-  error: string;
-}
-
-export interface AgentPromptSentPayload {
-  taskName: string;
-  model: string;
-  promptLength: number;
-}
-
-export interface AgentResponseReceivedPayload {
-  taskName: string;
-  ok: boolean;
-  duration: number;
-  responseLength: number;
-  error?: string;
-}
-
-export interface ReviewStartedPayload {
-  taskName: string;
-  taskBranch: string;
-}
-
-export interface ReviewCompletedPayload {
-  taskName: string;
-  status: 'approved' | 'needs_changes';
-  issueCount: number;
-  summary: string;
-}
-
-export interface ReviewApprovedPayload {
-  taskName: string;
-  iterations: number;
-}
-
-export interface ReviewRejectedPayload {
-  taskName: string;
-  reason: string;
-  iterations: number;
-}
-
-export interface DependencyPolicy {
-  allowDependencyChange: boolean;
-  lockfileReadOnly: boolean;
-}
-
-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. */
-  timeout?: number;
-}
-
-export interface RunnerConfig {
-  tasks: Task[];
-  dependsOn?: string[];
-  pipelineBranch?: string;
-  worktreeDir?: string;
-  branchPrefix?: string;
-  worktreeRoot?: string;
-  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[];
-  /** Task execution timeout in milliseconds. Default: 600000 (10 minutes) */
-  timeout?: number;
-  /** 
-   * Enable intervention feature (stdin piping for message injection).
-   * Warning: May cause stdout buffering issues on some systems.
-   * Default: false
-   */
-  enableIntervention?: boolean;
-  /**
-   * Disable Git operations (worktree, branch, push, commit).
-   * Useful for testing or environments without Git remote.
-   * Default: false
-   */
-  noGit?: boolean;
-}
-
-export interface DependencyRequestPlan {
-  reason: string;
-  changes: string[];
-  commands: string[];
-  notes?: string;
-}
-
-export interface TaskExecutionResult {
-  taskName: string;
-  taskBranch: string;
-  status: 'FINISHED' | 'ERROR' | 'BLOCKED_DEPENDENCY';
-  error?: string;
-  dependencyRequest?: DependencyRequestPlan | null;
-}
-
-export interface AgentSendResult {
-  ok: boolean;
-  exitCode: number;
-  error?: string;
-  sessionId?: string;
-  resultText?: string;
-}
-
-export interface ReviewIssue {
-  severity: 'critical' | 'major' | 'minor';
-  description: string;
-  file?: string;
-  suggestion?: string;
-}
-
-export interface ReviewResult {
-  status: 'approved' | 'needs_changes';
-  buildSuccess: boolean;
-  issues: ReviewIssue[];
-  suggestions: string[];
-  summary: string;
-  raw: string;
-}
-
-export interface TaskResult {
-  taskName: string;
-  taskBranch: string;
-  acceptanceCriteria?: string[];
-  [key: string]: any;
-}
-
-export interface LaneState {
-  label: string;
-  status: 'pending' | 'running' | 'completed' | 'failed' | 'paused' | 'waiting' | 'reviewing';
-  currentTaskIndex: number;
-  totalTasks: number;
-  worktreeDir: string | null;
-  pipelineBranch: string | null;
-  startTime: number;
-  endTime: number | null;
-  error: string | null;
-  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[];
-  /** Task-level dependencies currently being waited for (format: "lane:task") */
-  waitingFor?: string[];
-}
-
-export interface ConversationEntry {
-  timestamp: string;
-  role: 'user' | 'assistant' | 'reviewer' | 'system';
-  task: string | null;
-  fullText: string;
-  textLength: number;
-  model: string | null;
-}
-
-export interface GitLogEntry {
-  timestamp: string;
-  operation: string;
-  [key: string]: any;
-}
-
-export interface EventEntry {
-  timestamp: string;
-  event: string;
-  [key: string]: any;
-}
-
+export * from '../types';