@litmers/cursorflow-orchestrator 0.1.13 → 0.1.14

package/src/utils/events.ts

@@ -0,0 +1,117 @@
+import { EventEmitter } from 'events';
+import { 
+  CursorFlowEvent, 
+  EventHandler,
+  OrchestrationStartedPayload,
+  OrchestrationCompletedPayload,
+  OrchestrationFailedPayload,
+  LaneStartedPayload,
+  LaneCompletedPayload,
+  LaneFailedPayload,
+  LaneDependencyRequestedPayload,
+  TaskStartedPayload,
+  TaskCompletedPayload,
+  TaskFailedPayload,
+  AgentPromptSentPayload,
+  AgentResponseReceivedPayload,
+  ReviewStartedPayload,
+  ReviewCompletedPayload,
+  ReviewApprovedPayload,
+  ReviewRejectedPayload
+} from './types';
+
+class CursorFlowEvents extends EventEmitter {
+  private runId: string = '';
+
+  setRunId(id: string) {
+    this.runId = id;
+  }
+
+  // Specific event overloads for emit
+  emit(type: 'orchestration.started', payload: OrchestrationStartedPayload): boolean;
+  emit(type: 'orchestration.completed', payload: OrchestrationCompletedPayload): boolean;
+  emit(type: 'orchestration.failed', payload: OrchestrationFailedPayload): boolean;
+  emit(type: 'lane.started', payload: LaneStartedPayload): boolean;
+  emit(type: 'lane.completed', payload: LaneCompletedPayload): boolean;
+  emit(type: 'lane.failed', payload: LaneFailedPayload): boolean;
+  emit(type: 'lane.dependency_requested', payload: LaneDependencyRequestedPayload): boolean;
+  emit(type: 'task.started', payload: TaskStartedPayload): boolean;
+  emit(type: 'task.completed', payload: TaskCompletedPayload): boolean;
+  emit(type: 'task.failed', payload: TaskFailedPayload): boolean;
+  emit(type: 'agent.prompt_sent', payload: AgentPromptSentPayload): boolean;
+  emit(type: 'agent.response_received', payload: AgentResponseReceivedPayload): boolean;
+  emit(type: 'review.started', payload: ReviewStartedPayload): boolean;
+  emit(type: 'review.completed', payload: ReviewCompletedPayload): boolean;
+  emit(type: 'review.approved', payload: ReviewApprovedPayload): boolean;
+  emit(type: 'review.rejected', payload: ReviewRejectedPayload): boolean;
+  emit(type: string, payload: any): boolean;
+  emit(type: string, payload: any): boolean {
+    const event: CursorFlowEvent = {
+      id: `evt_${Date.now()}_${Math.random().toString(36).slice(2)}`,
+      type,
+      timestamp: new Date().toISOString(),
+      runId: this.runId,
+      payload,
+    };
+
+    // Emit specific event
+    super.emit(type, event);
+
+    // Emit wildcard patterns (e.g., 'task.*' listeners)
+    const parts = type.split('.');
+    if (parts.length > 1) {
+      const category = parts[0];
+      super.emit(`${category}.*`, event);
+    }
+    
+    super.emit('*', event);
+
+    return true;
+  }
+
+  // Specific event overloads for on
+  on(pattern: 'orchestration.started', handler: EventHandler<OrchestrationStartedPayload>): this;
+  on(pattern: 'orchestration.completed', handler: EventHandler<OrchestrationCompletedPayload>): this;
+  on(pattern: 'orchestration.failed', handler: EventHandler<OrchestrationFailedPayload>): this;
+  on(pattern: 'lane.started', handler: EventHandler<LaneStartedPayload>): this;
+  on(pattern: 'lane.completed', handler: EventHandler<LaneCompletedPayload>): this;
+  on(pattern: 'lane.failed', handler: EventHandler<LaneFailedPayload>): this;
+  on(pattern: 'lane.dependency_requested', handler: EventHandler<LaneDependencyRequestedPayload>): this;
+  on(pattern: 'task.started', handler: EventHandler<TaskStartedPayload>): this;
+  on(pattern: 'task.completed', handler: EventHandler<TaskCompletedPayload>): this;
+  on(pattern: 'task.failed', handler: EventHandler<TaskFailedPayload>): this;
+  on(pattern: 'agent.prompt_sent', handler: EventHandler<AgentPromptSentPayload>): this;
+  on(pattern: 'agent.response_received', handler: EventHandler<AgentResponseReceivedPayload>): this;
+  on(pattern: 'review.started', handler: EventHandler<ReviewStartedPayload>): this;
+  on(pattern: 'review.completed', handler: EventHandler<ReviewCompletedPayload>): this;
+  on(pattern: 'review.approved', handler: EventHandler<ReviewApprovedPayload>): this;
+  on(pattern: 'review.rejected', handler: EventHandler<ReviewRejectedPayload>): this;
+  on(pattern: string, handler: EventHandler): this;
+  on(pattern: string, handler: EventHandler): this {
+    return super.on(pattern, handler);
+  }
+
+  once(pattern: 'orchestration.started', handler: EventHandler<OrchestrationStartedPayload>): this;
+  once(pattern: 'orchestration.completed', handler: EventHandler<OrchestrationCompletedPayload>): this;
+  once(pattern: 'orchestration.failed', handler: EventHandler<OrchestrationFailedPayload>): this;
+  once(pattern: 'lane.started', handler: EventHandler<LaneStartedPayload>): this;
+  once(pattern: 'lane.completed', handler: EventHandler<LaneCompletedPayload>): this;
+  once(pattern: 'lane.failed', handler: EventHandler<LaneFailedPayload>): this;
+  once(pattern: 'lane.dependency_requested', handler: EventHandler<LaneDependencyRequestedPayload>): this;
+  once(pattern: 'task.started', handler: EventHandler<TaskStartedPayload>): this;
+  once(pattern: 'task.completed', handler: EventHandler<TaskCompletedPayload>): this;
+  once(pattern: 'task.failed', handler: EventHandler<TaskFailedPayload>): this;
+  once(pattern: 'agent.prompt_sent', handler: EventHandler<AgentPromptSentPayload>): this;
+  once(pattern: 'agent.response_received', handler: EventHandler<AgentResponseReceivedPayload>): this;
+  once(pattern: 'review.started', handler: EventHandler<ReviewStartedPayload>): this;
+  once(pattern: 'review.completed', handler: EventHandler<ReviewCompletedPayload>): this;
+  once(pattern: 'review.approved', handler: EventHandler<ReviewApprovedPayload>): this;
+  once(pattern: 'review.rejected', handler: EventHandler<ReviewRejectedPayload>): this;
+  once(pattern: string, handler: EventHandler): this;
+  once(pattern: string, handler: EventHandler): this {
+    return super.once(pattern, handler);
+  }
+}
+
+export const events = new CursorFlowEvents();
+

package/src/utils/git.ts

@@ -323,3 +323,28 @@ export function getCommitInfo(commitHash: string, options: { cwd?: string } = {}
     subject: lines[5] || '',
   };
 }
+
+/**
+ * Get diff statistics for the last operation (commit or merge)
+ * Comparing HEAD with its first parent
+ */
+export function getLastOperationStats(cwd?: string): string {
+  try {
+    // Check if there are any commits
+    const hasCommits = runGitResult(['rev-parse', 'HEAD'], { cwd }).success;
+    if (!hasCommits) return '';
+
+    // Check if HEAD has a parent
+    const hasParent = runGitResult(['rev-parse', 'HEAD^1'], { cwd }).success;
+    if (!hasParent) {
+      // If no parent, show stats for the first commit
+      // Using an empty tree hash as the base
+      const emptyTree = '4b825dc642cb6eb9a060e54bf8d69288fbee4904';
+      return runGit(['diff', '--stat', emptyTree, 'HEAD'], { cwd, silent: true });
+    }
+
+    return runGit(['diff', '--stat', 'HEAD^1', 'HEAD'], { cwd, silent: true });
+  } catch (e) {
+    return '';
+  }
+}

package/src/utils/types.ts

@@ -25,6 +25,155 @@ export interface CursorFlowConfig {
   worktreePrefix: string;
   maxConcurrentLanes: number;
   projectRoot: string;
+  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 {
@@ -52,7 +201,7 @@ export interface RunnerConfig {
   reviewModel?: string;
   maxReviewIterations?: number;
   acceptanceCriteria?: string[];
-  /** Task execution timeout in milliseconds. Default: 300000 (5 minutes) */
+  /** Task execution timeout in milliseconds. Default: 600000 (10 minutes) */
   timeout?: number;
   /** 
    * Enable intervention feature (stdin piping for message injection).

package/src/utils/webhook.ts

@@ -0,0 +1,85 @@
+import * as crypto from 'crypto';
+import { events } from './events';
+import { WebhookConfig, CursorFlowEvent } from './types';
+import * as logger from './logger';
+
+/**
+ * Register webhooks from configuration
+ */
+export function registerWebhooks(configs: WebhookConfig[]) {
+  if (!configs || !Array.isArray(configs)) return;
+
+  for (const config of configs) {
+    if (config.enabled === false) continue;
+
+    const patterns = config.events || ['*'];
+
+    for (const pattern of patterns) {
+      events.on(pattern, async (event) => {
+        try {
+          await sendWebhook(config, event);
+        } catch (error: any) {
+          logger.error(`Webhook failed for ${config.url}: ${error.message}`);
+        }
+      });
+    }
+  }
+}
+
+/**
+ * Send webhook with retry logic and HMAC signature
+ */
+async function sendWebhook(config: WebhookConfig, event: CursorFlowEvent) {
+  const payload = JSON.stringify(event);
+  const headers: Record<string, string> = {
+    'Content-Type': 'application/json',
+    'User-Agent': 'CursorFlow-Orchestrator',
+    ...config.headers,
+  };
+
+  // Add HMAC signature if secret is provided
+  if (config.secret) {
+    const signature = crypto
+      .createHmac('sha256', config.secret)
+      .update(payload)
+      .digest('hex');
+    headers['X-CursorFlow-Signature'] = `sha256=${signature}`;
+  }
+
+  const retries = config.retries ?? 3;
+  const timeoutMs = config.timeoutMs ?? 10000;
+
+  let lastError: any;
+
+  for (let attempt = 1; attempt <= retries + 1; attempt++) {
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+
+      const response = await fetch(config.url, {
+        method: 'POST',
+        headers,
+        body: payload,
+        signal: controller.signal,
+      });
+
+      clearTimeout(timeoutId);
+
+      if (response.ok) {
+        return;
+      }
+
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    } catch (error: any) {
+      lastError = error;
+      
+      if (attempt <= retries) {
+        const delay = Math.pow(2, attempt) * 1000; // Exponential backoff
+        await new Promise(resolve => setTimeout(resolve, delay));
+      }
+    }
+  }
+
+  throw lastError;
+}
+