claude-brain 0.15.2 → 0.16.0

package/src/orchestrator/event-emitter.ts

@@ -1,198 +1,198 @@
-/**
- * EventBus - Event-driven pub/sub system for orchestration
- */
-
-import { EventEmitter } from 'events'
-import { randomUUID } from 'crypto'
-import type { Logger } from 'pino'
-import type {
-  Event,
-  EventType,
-  EventPriority,
-  EventHandler,
-  EventBusStats
-} from './types'
-
-export class EventBus extends EventEmitter {
-  private logger: Logger
-  private handlers: Map<string, EventHandler>
-  private eventHistory: Event[]
-  private maxHistorySize: number
-
-  constructor(logger: Logger, maxHistorySize: number = 1000) {
-    super()
-    this.logger = logger.child({ component: 'event-bus' })
-    this.handlers = new Map()
-    this.eventHistory = []
-    this.maxHistorySize = maxHistorySize
-  }
-
-  /**
-   * Register an event handler
-   */
-  registerHandler(handler: EventHandler): void {
-    this.handlers.set(handler.name, handler)
-
-    // Subscribe to each event type
-    for (const type of handler.types) {
-      this.on(type, async (event: Event) => {
-        try {
-          await handler.handle(event)
-        } catch (error) {
-          this.logger.error(
-            { error, event, handler: handler.name },
-            'Handler failed to process event'
-          )
-          this.emitEvent(
-            'system:error',
-            {
-              error: error instanceof Error ? error.message : String(error),
-              event,
-              handler: handler.name
-            },
-            'event-bus'
-          )
-        }
-      })
-    }
-
-    this.logger.info(
-      { handler: handler.name, types: handler.types },
-      'Handler registered'
-    )
-  }
-
-  /**
-   * Unregister an event handler
-   */
-  unregisterHandler(handlerName: string): void {
-    const handler = this.handlers.get(handlerName)
-    if (handler) {
-      // Remove all listeners for this handler's types
-      for (const type of handler.types) {
-        this.removeAllListeners(type)
-      }
-      this.handlers.delete(handlerName)
-      this.logger.info({ handler: handlerName }, 'Handler unregistered')
-    }
-  }
-
-  /**
-   * Emit an event
-   */
-  emitEvent(
-    type: EventType,
-    payload: Record<string, unknown>,
-    source: string,
-    priority: EventPriority = 'normal'
-  ): Event {
-    const event: Event = {
-      id: randomUUID(),
-      type,
-      priority,
-      timestamp: new Date(),
-      payload,
-      source
-    }
-
-    // Add to history
-    this.addToHistory(event)
-
-    // Log event
-    this.logger.debug(
-      { event: event.id, type, priority, source },
-      'Event emitted'
-    )
-
-    // Emit to handlers
-    this.emit(type, event)
-
-    return event
-  }
-
-  /**
-   * Add event to history
-   */
-  private addToHistory(event: Event): void {
-    this.eventHistory.push(event)
-
-    // Maintain max history size
-    if (this.eventHistory.length > this.maxHistorySize) {
-      this.eventHistory.shift()
-    }
-  }
-
-  /**
-   * Get event history
-   */
-  getHistory(
-    options: {
-      type?: EventType
-      source?: string
-      since?: Date
-      limit?: number
-    } = {}
-  ): Event[] {
-    let filtered = this.eventHistory
-
-    if (options.type) {
-      filtered = filtered.filter(e => e.type === options.type)
-    }
-
-    if (options.source) {
-      filtered = filtered.filter(e => e.source === options.source)
-    }
-
-    if (options.since) {
-      filtered = filtered.filter(e => e.timestamp >= options.since!)
-    }
-
-    if (options.limit) {
-      filtered = filtered.slice(-options.limit)
-    }
-
-    return filtered
-  }
-
-  /**
-   * Clear event history
-   */
-  clearHistory(): void {
-    this.eventHistory = []
-    this.logger.debug('Event history cleared')
-  }
-
-  /**
-   * Get statistics
-   */
-  getStats(): EventBusStats {
-    const typeCounts = new Map<EventType, number>()
-
-    for (const event of this.eventHistory) {
-      const count = typeCounts.get(event.type) || 0
-      typeCounts.set(event.type, count + 1)
-    }
-
-    return {
-      totalEvents: this.eventHistory.length,
-      registeredHandlers: this.handlers.size,
-      eventsByType: Object.fromEntries(typeCounts),
-      oldestEvent: this.eventHistory[0]?.timestamp,
-      newestEvent: this.eventHistory[this.eventHistory.length - 1]?.timestamp
-    }
-  }
-
-  /**
-   * Get registered handler names
-   */
-  getHandlerNames(): string[] {
-    return Array.from(this.handlers.keys())
-  }
-
-  /**
-   * Check if a handler is registered
-   */
-  hasHandler(name: string): boolean {
-    return this.handlers.has(name)
-  }
-}
+/**
+ * EventBus - Event-driven pub/sub system for orchestration
+ */
+
+import { EventEmitter } from 'events'
+import { randomUUID } from 'crypto'
+import type { Logger } from 'pino'
+import type {
+  Event,
+  EventType,
+  EventPriority,
+  EventHandler,
+  EventBusStats
+} from './types'
+
+export class EventBus extends EventEmitter {
+  private logger: Logger
+  private handlers: Map<string, EventHandler>
+  private eventHistory: Event[]
+  private maxHistorySize: number
+
+  constructor(logger: Logger, maxHistorySize: number = 1000) {
+    super()
+    this.logger = logger.child({ component: 'event-bus' })
+    this.handlers = new Map()
+    this.eventHistory = []
+    this.maxHistorySize = maxHistorySize
+  }
+
+  /**
+   * Register an event handler
+   */
+  registerHandler(handler: EventHandler): void {
+    this.handlers.set(handler.name, handler)
+
+    // Subscribe to each event type
+    for (const type of handler.types) {
+      this.on(type, async (event: Event) => {
+        try {
+          await handler.handle(event)
+        } catch (error) {
+          this.logger.error(
+            { error, event, handler: handler.name },
+            'Handler failed to process event'
+          )
+          this.emitEvent(
+            'system:error',
+            {
+              error: error instanceof Error ? error.message : String(error),
+              event,
+              handler: handler.name
+            },
+            'event-bus'
+          )
+        }
+      })
+    }
+
+    this.logger.info(
+      { handler: handler.name, types: handler.types },
+      'Handler registered'
+    )
+  }
+
+  /**
+   * Unregister an event handler
+   */
+  unregisterHandler(handlerName: string): void {
+    const handler = this.handlers.get(handlerName)
+    if (handler) {
+      // Remove all listeners for this handler's types
+      for (const type of handler.types) {
+        this.removeAllListeners(type)
+      }
+      this.handlers.delete(handlerName)
+      this.logger.info({ handler: handlerName }, 'Handler unregistered')
+    }
+  }
+
+  /**
+   * Emit an event
+   */
+  emitEvent(
+    type: EventType,
+    payload: Record<string, unknown>,
+    source: string,
+    priority: EventPriority = 'normal'
+  ): Event {
+    const event: Event = {
+      id: randomUUID(),
+      type,
+      priority,
+      timestamp: new Date(),
+      payload,
+      source
+    }
+
+    // Add to history
+    this.addToHistory(event)
+
+    // Log event
+    this.logger.debug(
+      { event: event.id, type, priority, source },
+      'Event emitted'
+    )
+
+    // Emit to handlers
+    this.emit(type, event)
+
+    return event
+  }
+
+  /**
+   * Add event to history
+   */
+  private addToHistory(event: Event): void {
+    this.eventHistory.push(event)
+
+    // Maintain max history size
+    if (this.eventHistory.length > this.maxHistorySize) {
+      this.eventHistory.shift()
+    }
+  }
+
+  /**
+   * Get event history
+   */
+  getHistory(
+    options: {
+      type?: EventType
+      source?: string
+      since?: Date
+      limit?: number
+    } = {}
+  ): Event[] {
+    let filtered = this.eventHistory
+
+    if (options.type) {
+      filtered = filtered.filter(e => e.type === options.type)
+    }
+
+    if (options.source) {
+      filtered = filtered.filter(e => e.source === options.source)
+    }
+
+    if (options.since) {
+      filtered = filtered.filter(e => e.timestamp >= options.since!)
+    }
+
+    if (options.limit) {
+      filtered = filtered.slice(-options.limit)
+    }
+
+    return filtered
+  }
+
+  /**
+   * Clear event history
+   */
+  clearHistory(): void {
+    this.eventHistory = []
+    this.logger.debug('Event history cleared')
+  }
+
+  /**
+   * Get statistics
+   */
+  getStats(): EventBusStats {
+    const typeCounts = new Map<EventType, number>()
+
+    for (const event of this.eventHistory) {
+      const count = typeCounts.get(event.type) || 0
+      typeCounts.set(event.type, count + 1)
+    }
+
+    return {
+      totalEvents: this.eventHistory.length,
+      registeredHandlers: this.handlers.size,
+      eventsByType: Object.fromEntries(typeCounts),
+      oldestEvent: this.eventHistory[0]?.timestamp,
+      newestEvent: this.eventHistory[this.eventHistory.length - 1]?.timestamp
+    }
+  }
+
+  /**
+   * Get registered handler names
+   */
+  getHandlerNames(): string[] {
+    return Array.from(this.handlers.keys())
+  }
+
+  /**
+   * Check if a handler is registered
+   */
+  hasHandler(name: string): boolean {
+    return this.handlers.has(name)
+  }
+}