@litmers/cursorflow-orchestrator 0.1.13 → 0.1.15

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

@@ -217,12 +217,27 @@ export function commit(message: string, options: { cwd?: string; addAll?: boolea
   runGit(['commit', '-m', message], { cwd });
 }
 
+/**
+ * Check if a remote exists
+ */
+export function remoteExists(remoteName = 'origin', options: { cwd?: string } = {}): boolean {
+  const result = runGitResult(['remote'], { cwd: options.cwd });
+  if (!result.success) return false;
+  return result.stdout.split('\n').map(r => r.trim()).includes(remoteName);
+}
+
 /**
  * Push to remote
  */
 export function push(branchName: string, options: { cwd?: string; force?: boolean; setUpstream?: boolean } = {}): void {
   const { cwd, force = false, setUpstream = false } = options;
   
+  // Check if origin exists before pushing
+  if (!remoteExists('origin', { cwd })) {
+    // If no origin, just skip pushing (useful for local tests)
+    return;
+  }
+
   const args = ['push'];
   
   if (force) {
@@ -323,3 +338,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/logger.ts

@@ -16,7 +16,9 @@ export const COLORS = {
   green: '\x1b[32m',
   blue: '\x1b[34m',
   cyan: '\x1b[36m',
+  magenta: '\x1b[35m',
   gray: '\x1b[90m',
+  bold: '\x1b[1m',
 };
 
 let currentLogLevel: number = LogLevel.info;
@@ -38,7 +40,8 @@ export function setLogLevel(level: string | number): void {
 function formatMessage(level: string, message: string, emoji = ''): string {
   const timestamp = new Date().toISOString();
   const prefix = emoji ? `${emoji} ` : '';
-  return `[${timestamp}] [${level.toUpperCase()}] ${prefix}${message}`;
+  const lines = String(message).split('\n');
+  return lines.map(line => `[${timestamp}] [${level.toUpperCase()}] ${prefix}${line}`).join('\n');
 }
 
 /**

package/src/utils/types.ts

@@ -25,6 +25,157 @@ export interface CursorFlowConfig {
   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 {
@@ -49,10 +200,12 @@ export interface RunnerConfig {
   baseBranch?: string;
   model?: string;
   dependencyPolicy: DependencyPolicy;
+  /** Output format for cursor-agent (default: 'stream-json') */
+  agentOutputFormat?: 'stream-json' | 'json' | 'plain';
   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).
@@ -60,6 +213,12 @@ export interface RunnerConfig {
    * 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 {

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;
+}
+