claude-brain 0.14.2 → 0.14.4

package/src/orchestrator/coordinator.ts

@@ -1,272 +1,272 @@
-/**
- * AgentCoordinator - Coordinate multiple operations and route events
- */
-
-import type { Logger } from 'pino'
-import type { Event, Operation, CoordinatorStats } from './types'
-import { EventBus } from './event-emitter'
-import { EventQueue } from './event-queue'
-
-export class AgentCoordinator {
-  private logger: Logger
-  private eventBus: EventBus
-  private eventQueue: EventQueue
-  private operations: Map<string, Operation>
-  private maxConcurrent: number
-  private processingPromise: Promise<void> | null = null
-  private shouldStop: boolean = false
-
-  constructor(
-    logger: Logger,
-    eventBus: EventBus,
-    maxConcurrent: number = 5
-  ) {
-    this.logger = logger.child({ component: 'agent-coordinator' })
-    this.eventBus = eventBus
-    this.eventQueue = new EventQueue(logger)
-    this.operations = new Map()
-    this.maxConcurrent = maxConcurrent
-  }
-
-  /**
-   * Route event to appropriate handler via queue
-   */
-  async routeEvent(event: Event): Promise<void> {
-    this.logger.debug(
-      { eventId: event.id, type: event.type },
-      'Routing event'
-    )
-
-    // Add to queue
-    this.eventQueue.enqueue(event)
-
-    // Start processing if not already running
-    if (!this.processingPromise && !this.shouldStop) {
-      this.processingPromise = this.processQueue()
-    }
-  }
-
-  /**
-   * Process event queue
-   */
-  private async processQueue(): Promise<void> {
-    this.eventQueue.setProcessing(true)
-
-    try {
-      while (!this.shouldStop && !this.eventQueue.isEmpty()) {
-        const running = this.getRunningCount()
-
-        if (running >= this.maxConcurrent) {
-          this.logger.debug('Max concurrent operations reached, waiting')
-          await this.waitForCompletion()
-          continue
-        }
-
-        const item = this.eventQueue.dequeue()
-        if (!item) {
-          // No ready items, wait a bit
-          await new Promise(resolve => setTimeout(resolve, 100))
-          continue
-        }
-
-        // Process the event
-        await this.processEvent(item)
-      }
-    } finally {
-      this.eventQueue.setProcessing(false)
-      this.processingPromise = null
-    }
-  }
-
-  /**
-   * Process a single event
-   */
-  private async processEvent(item: ReturnType<EventQueue['dequeue']>): Promise<void> {
-    if (!item) return
-
-    const operation: Operation = {
-      id: item.event.id,
-      type: item.event.type,
-      status: 'running',
-      startTime: new Date()
-    }
-
-    this.operations.set(operation.id, operation)
-
-    try {
-      // Emit event to bus (handlers will process)
-      this.eventBus.emitEvent(
-        item.event.type,
-        item.event.payload,
-        'coordinator',
-        item.event.priority
-      )
-
-      operation.status = 'completed'
-      operation.endTime = new Date()
-
-      this.logger.debug(
-        { operationId: operation.id, duration: this.getDuration(operation) },
-        'Operation completed'
-      )
-    } catch (error) {
-      operation.status = 'failed'
-      operation.error = error
-      operation.endTime = new Date()
-
-      this.logger.error(
-        { error, operationId: operation.id },
-        'Operation failed'
-      )
-
-      // Reschedule if retriable
-      const delayMs = Math.pow(2, item.retries) * 1000 // Exponential backoff
-      const rescheduled = this.eventQueue.reschedule(item, delayMs)
-
-      if (!rescheduled) {
-        this.logger.error(
-          { operationId: operation.id },
-          'Operation exhausted retries'
-        )
-      }
-    }
-  }
-
-  /**
-   * Get operation duration in milliseconds
-   */
-  private getDuration(operation: Operation): number | undefined {
-    if (operation.startTime && operation.endTime) {
-      return operation.endTime.getTime() - operation.startTime.getTime()
-    }
-    return undefined
-  }
-
-  /**
-   * Wait for at least one operation to complete
-   */
-  private async waitForCompletion(): Promise<void> {
-    // Simple polling approach
-    const checkInterval = 100
-    const maxWait = 10000
-    let waited = 0
-
-    while (waited < maxWait) {
-      const running = this.getRunningCount()
-      if (running < this.maxConcurrent) {
-        return
-      }
-      await new Promise(resolve => setTimeout(resolve, checkInterval))
-      waited += checkInterval
-    }
-  }
-
-  /**
-   * Get count of running operations
-   */
-  private getRunningCount(): number {
-    return Array.from(this.operations.values())
-      .filter(op => op.status === 'running').length
-  }
-
-  /**
-   * Get operation by ID
-   */
-  getOperation(id: string): Operation | undefined {
-    return this.operations.get(id)
-  }
-
-  /**
-   * Get all operations, optionally filtered by status
-   */
-  getOperations(status?: Operation['status']): Operation[] {
-    const ops = Array.from(this.operations.values())
-
-    if (status) {
-      return ops.filter(op => op.status === status)
-    }
-
-    return ops
-  }
-
-  /**
-   * Get coordinator stats
-   */
-  getStats(): CoordinatorStats {
-    const statuses = new Map<string, number>()
-
-    for (const op of this.operations.values()) {
-      const count = statuses.get(op.status) || 0
-      statuses.set(op.status, count + 1)
-    }
-
-    return {
-      totalOperations: this.operations.size,
-      queueSize: this.eventQueue.size(),
-      operationsByStatus: Object.fromEntries(statuses),
-      maxConcurrent: this.maxConcurrent
-    }
-  }
-
-  /**
-   * Clear completed operations to free memory
-   */
-  clearCompleted(): number {
-    let cleared = 0
-
-    for (const [id, op] of this.operations) {
-      if (op.status === 'completed' || op.status === 'failed') {
-        this.operations.delete(id)
-        cleared++
-      }
-    }
-
-    if (cleared > 0) {
-      this.logger.debug({ cleared }, 'Completed operations cleared')
-    }
-
-    return cleared
-  }
-
-  /**
-   * Stop the coordinator
-   */
-  stop(): void {
-    this.shouldStop = true
-    this.eventQueue.clear()
-    this.logger.info('Coordinator stopped')
-  }
-
-  /**
-   * Resume the coordinator
-   */
-  resume(): void {
-    this.shouldStop = false
-    this.logger.info('Coordinator resumed')
-  }
-
-  /**
-   * Check if coordinator is running
-   */
-  isRunning(): boolean {
-    return !this.shouldStop && this.processingPromise !== null
-  }
-
-  /**
-   * Get queue status
-   */
-  getQueueStatus() {
-    return this.eventQueue.getStatus()
-  }
-
-  /**
-   * Set max concurrent operations
-   */
-  setMaxConcurrent(value: number): void {
-    if (value < 1) {
-      throw new Error('Max concurrent must be at least 1')
-    }
-    this.maxConcurrent = value
-    this.logger.info({ maxConcurrent: value }, 'Max concurrent updated')
-  }
-}
+/**
+ * AgentCoordinator - Coordinate multiple operations and route events
+ */
+
+import type { Logger } from 'pino'
+import type { Event, Operation, CoordinatorStats } from './types'
+import { EventBus } from './event-emitter'
+import { EventQueue } from './event-queue'
+
+export class AgentCoordinator {
+  private logger: Logger
+  private eventBus: EventBus
+  private eventQueue: EventQueue
+  private operations: Map<string, Operation>
+  private maxConcurrent: number
+  private processingPromise: Promise<void> | null = null
+  private shouldStop: boolean = false
+
+  constructor(
+    logger: Logger,
+    eventBus: EventBus,
+    maxConcurrent: number = 5
+  ) {
+    this.logger = logger.child({ component: 'agent-coordinator' })
+    this.eventBus = eventBus
+    this.eventQueue = new EventQueue(logger)
+    this.operations = new Map()
+    this.maxConcurrent = maxConcurrent
+  }
+
+  /**
+   * Route event to appropriate handler via queue
+   */
+  async routeEvent(event: Event): Promise<void> {
+    this.logger.debug(
+      { eventId: event.id, type: event.type },
+      'Routing event'
+    )
+
+    // Add to queue
+    this.eventQueue.enqueue(event)
+
+    // Start processing if not already running
+    if (!this.processingPromise && !this.shouldStop) {
+      this.processingPromise = this.processQueue()
+    }
+  }
+
+  /**
+   * Process event queue
+   */
+  private async processQueue(): Promise<void> {
+    this.eventQueue.setProcessing(true)
+
+    try {
+      while (!this.shouldStop && !this.eventQueue.isEmpty()) {
+        const running = this.getRunningCount()
+
+        if (running >= this.maxConcurrent) {
+          this.logger.debug('Max concurrent operations reached, waiting')
+          await this.waitForCompletion()
+          continue
+        }
+
+        const item = this.eventQueue.dequeue()
+        if (!item) {
+          // No ready items, wait a bit
+          await new Promise(resolve => setTimeout(resolve, 100))
+          continue
+        }
+
+        // Process the event
+        await this.processEvent(item)
+      }
+    } finally {
+      this.eventQueue.setProcessing(false)
+      this.processingPromise = null
+    }
+  }
+
+  /**
+   * Process a single event
+   */
+  private async processEvent(item: ReturnType<EventQueue['dequeue']>): Promise<void> {
+    if (!item) return
+
+    const operation: Operation = {
+      id: item.event.id,
+      type: item.event.type,
+      status: 'running',
+      startTime: new Date()
+    }
+
+    this.operations.set(operation.id, operation)
+
+    try {
+      // Emit event to bus (handlers will process)
+      this.eventBus.emitEvent(
+        item.event.type,
+        item.event.payload,
+        'coordinator',
+        item.event.priority
+      )
+
+      operation.status = 'completed'
+      operation.endTime = new Date()
+
+      this.logger.debug(
+        { operationId: operation.id, duration: this.getDuration(operation) },
+        'Operation completed'
+      )
+    } catch (error) {
+      operation.status = 'failed'
+      operation.error = error
+      operation.endTime = new Date()
+
+      this.logger.error(
+        { error, operationId: operation.id },
+        'Operation failed'
+      )
+
+      // Reschedule if retriable
+      const delayMs = Math.pow(2, item.retries) * 1000 // Exponential backoff
+      const rescheduled = this.eventQueue.reschedule(item, delayMs)
+
+      if (!rescheduled) {
+        this.logger.error(
+          { operationId: operation.id },
+          'Operation exhausted retries'
+        )
+      }
+    }
+  }
+
+  /**
+   * Get operation duration in milliseconds
+   */
+  private getDuration(operation: Operation): number | undefined {
+    if (operation.startTime && operation.endTime) {
+      return operation.endTime.getTime() - operation.startTime.getTime()
+    }
+    return undefined
+  }
+
+  /**
+   * Wait for at least one operation to complete
+   */
+  private async waitForCompletion(): Promise<void> {
+    // Simple polling approach
+    const checkInterval = 100
+    const maxWait = 10000
+    let waited = 0
+
+    while (waited < maxWait) {
+      const running = this.getRunningCount()
+      if (running < this.maxConcurrent) {
+        return
+      }
+      await new Promise(resolve => setTimeout(resolve, checkInterval))
+      waited += checkInterval
+    }
+  }
+
+  /**
+   * Get count of running operations
+   */
+  private getRunningCount(): number {
+    return Array.from(this.operations.values())
+      .filter(op => op.status === 'running').length
+  }
+
+  /**
+   * Get operation by ID
+   */
+  getOperation(id: string): Operation | undefined {
+    return this.operations.get(id)
+  }
+
+  /**
+   * Get all operations, optionally filtered by status
+   */
+  getOperations(status?: Operation['status']): Operation[] {
+    const ops = Array.from(this.operations.values())
+
+    if (status) {
+      return ops.filter(op => op.status === status)
+    }
+
+    return ops
+  }
+
+  /**
+   * Get coordinator stats
+   */
+  getStats(): CoordinatorStats {
+    const statuses = new Map<string, number>()
+
+    for (const op of this.operations.values()) {
+      const count = statuses.get(op.status) || 0
+      statuses.set(op.status, count + 1)
+    }
+
+    return {
+      totalOperations: this.operations.size,
+      queueSize: this.eventQueue.size(),
+      operationsByStatus: Object.fromEntries(statuses),
+      maxConcurrent: this.maxConcurrent
+    }
+  }
+
+  /**
+   * Clear completed operations to free memory
+   */
+  clearCompleted(): number {
+    let cleared = 0
+
+    for (const [id, op] of this.operations) {
+      if (op.status === 'completed' || op.status === 'failed') {
+        this.operations.delete(id)
+        cleared++
+      }
+    }
+
+    if (cleared > 0) {
+      this.logger.debug({ cleared }, 'Completed operations cleared')
+    }
+
+    return cleared
+  }
+
+  /**
+   * Stop the coordinator
+   */
+  stop(): void {
+    this.shouldStop = true
+    this.eventQueue.clear()
+    this.logger.info('Coordinator stopped')
+  }
+
+  /**
+   * Resume the coordinator
+   */
+  resume(): void {
+    this.shouldStop = false
+    this.logger.info('Coordinator resumed')
+  }
+
+  /**
+   * Check if coordinator is running
+   */
+  isRunning(): boolean {
+    return !this.shouldStop && this.processingPromise !== null
+  }
+
+  /**
+   * Get queue status
+   */
+  getQueueStatus() {
+    return this.eventQueue.getStatus()
+  }
+
+  /**
+   * Set max concurrent operations
+   */
+  setMaxConcurrent(value: number): void {
+    if (value < 1) {
+      throw new Error('Max concurrent must be at least 1')
+    }
+    this.maxConcurrent = value
+    this.logger.info({ maxConcurrent: value }, 'Max concurrent updated')
+  }
+}