claude-brain 0.14.2 → 0.14.4

package/src/orchestrator/event-queue.ts

@@ -1,184 +1,184 @@
-/**
- * EventQueue - Priority-based event queue with retry support
- */
-
-import type { Logger } from 'pino'
-import type { Event, EventQueueItem, QueueStatus, EventPriority } from './types'
-
-const PRIORITY_ORDER: Record<EventPriority, number> = {
-  urgent: 0,
-  high: 1,
-  normal: 2,
-  low: 3
-}
-
-export class EventQueue {
-  private queue: EventQueueItem[]
-  private processing: boolean = false
-  private logger: Logger
-
-  constructor(logger: Logger) {
-    this.logger = logger.child({ component: 'event-queue' })
-    this.queue = []
-  }
-
-  /**
-   * Add event to queue with priority ordering
-   */
-  enqueue(event: Event, maxRetries: number = 3): void {
-    const item: EventQueueItem = {
-      event,
-      retries: 0,
-      maxRetries
-    }
-
-    // Insert based on priority
-    const insertIndex = this.queue.findIndex(
-      i => PRIORITY_ORDER[i.event.priority] > PRIORITY_ORDER[event.priority]
-    )
-
-    if (insertIndex === -1) {
-      this.queue.push(item)
-    } else {
-      this.queue.splice(insertIndex, 0, item)
-    }
-
-    this.logger.debug(
-      { eventId: event.id, priority: event.priority, queueSize: this.queue.length },
-      'Event enqueued'
-    )
-  }
-
-  /**
-   * Get next ready event from queue
-   */
-  dequeue(): EventQueueItem | undefined {
-    // Filter out items scheduled for future
-    const now = new Date()
-    const readyIndex = this.queue.findIndex(
-      item => !item.scheduledFor || item.scheduledFor <= now
-    )
-
-    if (readyIndex === -1) {
-      return undefined
-    }
-
-    return this.queue.splice(readyIndex, 1)[0]
-  }
-
-  /**
-   * Peek at next event without removing it
-   */
-  peek(): EventQueueItem | undefined {
-    const now = new Date()
-    return this.queue.find(item => !item.scheduledFor || item.scheduledFor <= now)
-  }
-
-  /**
-   * Reschedule failed event with exponential backoff
-   */
-  reschedule(item: EventQueueItem, delayMs: number): boolean {
-    item.retries++
-    item.scheduledFor = new Date(Date.now() + delayMs)
-
-    if (item.retries < item.maxRetries) {
-      // Add back to queue (at end, will be sorted by time)
-      this.queue.push(item)
-      this.logger.info(
-        { eventId: item.event.id, retries: item.retries, delayMs },
-        'Event rescheduled'
-      )
-      return true
-    } else {
-      this.logger.error(
-        { eventId: item.event.id, retries: item.retries },
-        'Event exceeded max retries'
-      )
-      return false
-    }
-  }
-
-  /**
-   * Get queue size
-   */
-  size(): number {
-    return this.queue.length
-  }
-
-  /**
-   * Get count of ready (not scheduled) items
-   */
-  readyCount(): number {
-    const now = new Date()
-    return this.queue.filter(item => !item.scheduledFor || item.scheduledFor <= now).length
-  }
-
-  /**
-   * Check if queue is empty
-   */
-  isEmpty(): boolean {
-    return this.queue.length === 0
-  }
-
-  /**
-   * Clear queue
-   */
-  clear(): void {
-    const previousSize = this.queue.length
-    this.queue = []
-    this.logger.debug({ previousSize }, 'Queue cleared')
-  }
-
-  /**
-   * Set processing state
-   */
-  setProcessing(value: boolean): void {
-    this.processing = value
-  }
-
-  /**
-   * Check if currently processing
-   */
-  isProcessing(): boolean {
-    return this.processing
-  }
-
-  /**
-   * Get queue status
-   */
-  getStatus(): QueueStatus {
-    return {
-      size: this.queue.length,
-      processing: this.processing,
-      events: this.queue.map(item => ({
-        id: item.event.id,
-        type: item.event.type,
-        priority: item.event.priority,
-        retries: item.retries,
-        scheduledFor: item.scheduledFor
-      }))
-    }
-  }
-
-  /**
-   * Get events by type
-   */
-  getEventsByType(type: Event['type']): EventQueueItem[] {
-    return this.queue.filter(item => item.event.type === type)
-  }
-
-  /**
-   * Remove events matching a predicate
-   */
-  removeWhere(predicate: (item: EventQueueItem) => boolean): number {
-    const initialLength = this.queue.length
-    this.queue = this.queue.filter(item => !predicate(item))
-    const removed = initialLength - this.queue.length
-
-    if (removed > 0) {
-      this.logger.debug({ removed }, 'Events removed from queue')
-    }
-
-    return removed
-  }
-}
+/**
+ * EventQueue - Priority-based event queue with retry support
+ */
+
+import type { Logger } from 'pino'
+import type { Event, EventQueueItem, QueueStatus, EventPriority } from './types'
+
+const PRIORITY_ORDER: Record<EventPriority, number> = {
+  urgent: 0,
+  high: 1,
+  normal: 2,
+  low: 3
+}
+
+export class EventQueue {
+  private queue: EventQueueItem[]
+  private processing: boolean = false
+  private logger: Logger
+
+  constructor(logger: Logger) {
+    this.logger = logger.child({ component: 'event-queue' })
+    this.queue = []
+  }
+
+  /**
+   * Add event to queue with priority ordering
+   */
+  enqueue(event: Event, maxRetries: number = 3): void {
+    const item: EventQueueItem = {
+      event,
+      retries: 0,
+      maxRetries
+    }
+
+    // Insert based on priority
+    const insertIndex = this.queue.findIndex(
+      i => PRIORITY_ORDER[i.event.priority] > PRIORITY_ORDER[event.priority]
+    )
+
+    if (insertIndex === -1) {
+      this.queue.push(item)
+    } else {
+      this.queue.splice(insertIndex, 0, item)
+    }
+
+    this.logger.debug(
+      { eventId: event.id, priority: event.priority, queueSize: this.queue.length },
+      'Event enqueued'
+    )
+  }
+
+  /**
+   * Get next ready event from queue
+   */
+  dequeue(): EventQueueItem | undefined {
+    // Filter out items scheduled for future
+    const now = new Date()
+    const readyIndex = this.queue.findIndex(
+      item => !item.scheduledFor || item.scheduledFor <= now
+    )
+
+    if (readyIndex === -1) {
+      return undefined
+    }
+
+    return this.queue.splice(readyIndex, 1)[0]
+  }
+
+  /**
+   * Peek at next event without removing it
+   */
+  peek(): EventQueueItem | undefined {
+    const now = new Date()
+    return this.queue.find(item => !item.scheduledFor || item.scheduledFor <= now)
+  }
+
+  /**
+   * Reschedule failed event with exponential backoff
+   */
+  reschedule(item: EventQueueItem, delayMs: number): boolean {
+    item.retries++
+    item.scheduledFor = new Date(Date.now() + delayMs)
+
+    if (item.retries < item.maxRetries) {
+      // Add back to queue (at end, will be sorted by time)
+      this.queue.push(item)
+      this.logger.info(
+        { eventId: item.event.id, retries: item.retries, delayMs },
+        'Event rescheduled'
+      )
+      return true
+    } else {
+      this.logger.error(
+        { eventId: item.event.id, retries: item.retries },
+        'Event exceeded max retries'
+      )
+      return false
+    }
+  }
+
+  /**
+   * Get queue size
+   */
+  size(): number {
+    return this.queue.length
+  }
+
+  /**
+   * Get count of ready (not scheduled) items
+   */
+  readyCount(): number {
+    const now = new Date()
+    return this.queue.filter(item => !item.scheduledFor || item.scheduledFor <= now).length
+  }
+
+  /**
+   * Check if queue is empty
+   */
+  isEmpty(): boolean {
+    return this.queue.length === 0
+  }
+
+  /**
+   * Clear queue
+   */
+  clear(): void {
+    const previousSize = this.queue.length
+    this.queue = []
+    this.logger.debug({ previousSize }, 'Queue cleared')
+  }
+
+  /**
+   * Set processing state
+   */
+  setProcessing(value: boolean): void {
+    this.processing = value
+  }
+
+  /**
+   * Check if currently processing
+   */
+  isProcessing(): boolean {
+    return this.processing
+  }
+
+  /**
+   * Get queue status
+   */
+  getStatus(): QueueStatus {
+    return {
+      size: this.queue.length,
+      processing: this.processing,
+      events: this.queue.map(item => ({
+        id: item.event.id,
+        type: item.event.type,
+        priority: item.event.priority,
+        retries: item.retries,
+        scheduledFor: item.scheduledFor
+      }))
+    }
+  }
+
+  /**
+   * Get events by type
+   */
+  getEventsByType(type: Event['type']): EventQueueItem[] {
+    return this.queue.filter(item => item.event.type === type)
+  }
+
+  /**
+   * Remove events matching a predicate
+   */
+  removeWhere(predicate: (item: EventQueueItem) => boolean): number {
+    const initialLength = this.queue.length
+    this.queue = this.queue.filter(item => !predicate(item))
+    const removed = initialLength - this.queue.length
+
+    if (removed > 0) {
+      this.logger.debug({ removed }, 'Events removed from queue')
+    }
+
+    return removed
+  }
+}

package/src/orchestrator/handlers/base-handler.ts

@@ -1,70 +1,70 @@
-/**
- * BaseHandler - Abstract base class for event handlers
- */
-
-import type { Logger } from 'pino'
-import type { Event, EventHandler, EventType, EventPriority } from '../types'
-
-export abstract class BaseHandler implements EventHandler {
-  abstract name: string
-  abstract types: EventType[]
-  abstract priority: EventPriority
-
-  protected logger: Logger
-
-  constructor(logger: Logger) {
-    // Logger child will be created in subclasses after name is defined
-    this.logger = logger
-  }
-
-  /**
-   * Initialize logger with component name
-   * Call this in subclass constructor after setting name
-   */
-  protected initLogger(logger: Logger): void {
-    this.logger = logger.child({ component: this.name })
-  }
-
-  abstract handle(event: Event): Promise<void>
-
-  /**
-   * Log that we're handling an event
-   */
-  protected logHandling(event: Event): void {
-    this.logger.info(
-      { eventId: event.id, type: event.type },
-      'Handling event'
-    )
-  }
-
-  /**
-   * Log a successful handling
-   */
-  protected logSuccess(event: Event, details?: Record<string, unknown>): void {
-    this.logger.info(
-      { eventId: event.id, type: event.type, ...details },
-      'Event handled successfully'
-    )
-  }
-
-  /**
-   * Log a failed handling
-   */
-  protected logError(event: Event, error: unknown): void {
-    this.logger.error(
-      {
-        eventId: event.id,
-        type: event.type,
-        error: error instanceof Error ? error.message : String(error)
-      },
-      'Event handling failed'
-    )
-  }
-
-  /**
-   * Check if the event should be handled based on file path
-   */
-  protected shouldHandleFile(filePath: string, patterns: string[]): boolean {
-    return patterns.some(pattern => filePath.endsWith(pattern))
-  }
-}
+/**
+ * BaseHandler - Abstract base class for event handlers
+ */
+
+import type { Logger } from 'pino'
+import type { Event, EventHandler, EventType, EventPriority } from '../types'
+
+export abstract class BaseHandler implements EventHandler {
+  abstract name: string
+  abstract types: EventType[]
+  abstract priority: EventPriority
+
+  protected logger: Logger
+
+  constructor(logger: Logger) {
+    // Logger child will be created in subclasses after name is defined
+    this.logger = logger
+  }
+
+  /**
+   * Initialize logger with component name
+   * Call this in subclass constructor after setting name
+   */
+  protected initLogger(logger: Logger): void {
+    this.logger = logger.child({ component: this.name })
+  }
+
+  abstract handle(event: Event): Promise<void>
+
+  /**
+   * Log that we're handling an event
+   */
+  protected logHandling(event: Event): void {
+    this.logger.info(
+      { eventId: event.id, type: event.type },
+      'Handling event'
+    )
+  }
+
+  /**
+   * Log a successful handling
+   */
+  protected logSuccess(event: Event, details?: Record<string, unknown>): void {
+    this.logger.info(
+      { eventId: event.id, type: event.type, ...details },
+      'Event handled successfully'
+    )
+  }
+
+  /**
+   * Log a failed handling
+   */
+  protected logError(event: Event, error: unknown): void {
+    this.logger.error(
+      {
+        eventId: event.id,
+        type: event.type,
+        error: error instanceof Error ? error.message : String(error)
+      },
+      'Event handling failed'
+    )
+  }
+
+  /**
+   * Check if the event should be handled based on file path
+   */
+  protected shouldHandleFile(filePath: string, patterns: string[]): boolean {
+    return patterns.some(pattern => filePath.endsWith(pattern))
+  }
+}

package/src/orchestrator/handlers/context-handler.ts

@@ -1,73 +1,73 @@
-/**
- * ContextUpdateHandler - Handles context.md file changes and cache invalidation
- */
-
-import type { Logger } from 'pino'
-import type { Event, EventType, EventPriority } from '../types'
-import type { VaultReader } from '@/vault'
-import { BaseHandler } from './base-handler'
-import type { EventBus } from '../event-emitter'
-
-export class ContextUpdateHandler extends BaseHandler {
-  name = 'context-update-handler'
-  types: EventType[] = ['file:modified']
-  priority: EventPriority = 'low'
-
-  private vaultReader: VaultReader
-  private eventBus: EventBus | null = null
-
-  constructor(logger: Logger, vaultReader: VaultReader) {
-    super(logger)
-    this.initLogger(logger)
-    this.vaultReader = vaultReader
-  }
-
-  /**
-   * Set the event bus for emitting context events
-   */
-  setEventBus(eventBus: EventBus): void {
-    this.eventBus = eventBus
-  }
-
-  async handle(event: Event): Promise<void> {
-    this.logHandling(event)
-
-    const filePath = event.payload.path as string
-
-    // Only process context.md files
-    if (!this.shouldHandleFile(filePath, ['context.md'])) {
-      return
-    }
-
-    try {
-      // Invalidate cache for this file
-      this.vaultReader.invalidateCache(filePath)
-
-      this.logger.info(
-        { filePath },
-        'Project context updated, cache invalidated'
-      )
-
-      // Emit context update event if event bus is available
-      if (this.eventBus) {
-        // Try to extract project name from path
-        const projectMatch = filePath.match(/Projects[\/\\]([^\/\\]+)[\/\\]/)
-        const project = projectMatch ? projectMatch[1] : undefined
-
-        this.eventBus.emitEvent(
-          'project:updated',
-          {
-            type: 'context-update',
-            filePath,
-            project
-          },
-          this.name
-        )
-      }
-
-      this.logSuccess(event, { filePath })
-    } catch (error) {
-      this.logError(event, error)
-    }
-  }
-}
+/**
+ * ContextUpdateHandler - Handles context.md file changes and cache invalidation
+ */
+
+import type { Logger } from 'pino'
+import type { Event, EventType, EventPriority } from '../types'
+import type { VaultReader } from '@/vault'
+import { BaseHandler } from './base-handler'
+import type { EventBus } from '../event-emitter'
+
+export class ContextUpdateHandler extends BaseHandler {
+  name = 'context-update-handler'
+  types: EventType[] = ['file:modified']
+  priority: EventPriority = 'low'
+
+  private vaultReader: VaultReader
+  private eventBus: EventBus | null = null
+
+  constructor(logger: Logger, vaultReader: VaultReader) {
+    super(logger)
+    this.initLogger(logger)
+    this.vaultReader = vaultReader
+  }
+
+  /**
+   * Set the event bus for emitting context events
+   */
+  setEventBus(eventBus: EventBus): void {
+    this.eventBus = eventBus
+  }
+
+  async handle(event: Event): Promise<void> {
+    this.logHandling(event)
+
+    const filePath = event.payload.path as string
+
+    // Only process context.md files
+    if (!this.shouldHandleFile(filePath, ['context.md'])) {
+      return
+    }
+
+    try {
+      // Invalidate cache for this file
+      this.vaultReader.invalidateCache(filePath)
+
+      this.logger.info(
+        { filePath },
+        'Project context updated, cache invalidated'
+      )
+
+      // Emit context update event if event bus is available
+      if (this.eventBus) {
+        // Try to extract project name from path
+        const projectMatch = filePath.match(/Projects[\/\\]([^\/\\]+)[\/\\]/)
+        const project = projectMatch ? projectMatch[1] : undefined
+
+        this.eventBus.emitEvent(
+          'project:updated',
+          {
+            type: 'context-update',
+            filePath,
+            project
+          },
+          this.name
+        )
+      }
+
+      this.logSuccess(event, { filePath })
+    } catch (error) {
+      this.logError(event, error)
+    }
+  }
+}