claude-brain 0.14.2 → 0.14.4

package/src/orchestrator/index.ts

@@ -1,275 +1,275 @@
-/**
- * Orchestration Engine - Main Module
- * Phase 4: Event-driven coordination system for Claude Brain
- *
- * This module provides:
- * - Event-driven architecture for component communication
- * - Automatic file change handling from Obsidian vault
- * - Task extraction and tracking
- * - Automatic decision logging
- * - Operation coordination
- */
-
-import type { Logger } from 'pino'
-import type { VaultManager } from '@/vault'
-import type { MemoryManager } from '@/memory'
-import { EventBus } from './event-emitter'
-import { AgentCoordinator } from './coordinator'
-import { DecisionLogger } from './decision-logger'
-import type { OrchestratorStats } from './types'
-
-// Import handlers
-import {
-  TaskHandler,
-  StatusChangeHandler,
-  DecisionDetectionHandler,
-  ContextUpdateHandler
-} from './handlers'
-
-// Re-export all types and classes
-export * from './types'
-export { EventBus } from './event-emitter'
-export { EventQueue } from './event-queue'
-export { AgentCoordinator } from './coordinator'
-export { DecisionLogger, type DecisionEntry } from './decision-logger'
-export { TaskParser, type Task, type TaskStatus, type TaskPriority } from './task-parser'
-export * from './handlers'
-
-export interface OrchestratorConfig {
-  maxConcurrentOperations?: number
-  debounceMs?: number
-  maxHistorySize?: number
-}
-
-/**
- * Main Orchestrator class that coordinates all event-driven operations
- */
-export class Orchestrator {
-  readonly eventBus: EventBus
-  readonly coordinator: AgentCoordinator
-  readonly decisionLogger: DecisionLogger
-
-  private logger: Logger
-  private vault: VaultManager
-  private memory: MemoryManager
-  private config: OrchestratorConfig
-  private initialized: boolean = false
-
-  // Handler instances
-  private taskHandler: TaskHandler
-  private statusHandler: StatusChangeHandler
-  private decisionHandler: DecisionDetectionHandler
-  private contextHandler: ContextUpdateHandler
-
-  constructor(
-    logger: Logger,
-    vault: VaultManager,
-    memory: MemoryManager,
-    config: OrchestratorConfig = {}
-  ) {
-    this.logger = logger.child({ component: 'orchestrator' })
-    this.vault = vault
-    this.memory = memory
-    this.config = {
-      maxConcurrentOperations: config.maxConcurrentOperations ?? 5,
-      debounceMs: config.debounceMs ?? 5000,
-      maxHistorySize: config.maxHistorySize ?? 1000
-    }
-
-    // Initialize core components
-    this.eventBus = new EventBus(logger, this.config.maxHistorySize)
-    this.coordinator = new AgentCoordinator(
-      logger,
-      this.eventBus,
-      this.config.maxConcurrentOperations
-    )
-    this.decisionLogger = new DecisionLogger(
-      logger,
-      memory,
-      vault.writer
-    )
-
-    // Initialize handlers
-    this.taskHandler = new TaskHandler(logger, vault.reader)
-    this.statusHandler = new StatusChangeHandler(logger, vault.reader)
-    this.decisionHandler = new DecisionDetectionHandler(
-      logger,
-      vault.reader,
-      memory,
-      this.config.debounceMs
-    )
-    this.contextHandler = new ContextUpdateHandler(logger, vault.reader)
-
-    // Give handlers access to event bus for emitting events
-    this.taskHandler.setEventBus(this.eventBus)
-    this.statusHandler.setEventBus(this.eventBus)
-    this.decisionHandler.setEventBus(this.eventBus)
-    this.contextHandler.setEventBus(this.eventBus)
-  }
-
-  /**
-   * Initialize orchestrator and register handlers
-   */
-  async initialize(): Promise<void> {
-    if (this.initialized) {
-      this.logger.warn('Orchestrator already initialized')
-      return
-    }
-
-    try {
-      this.logger.info('Initializing orchestrator...')
-
-      // Register handlers
-      this.registerHandlers()
-
-      // Setup vault watcher integration
-      this.setupVaultWatcher()
-
-      // Emit system ready event
-      this.eventBus.emitEvent(
-        'system:ready',
-        { timestamp: new Date() },
-        'orchestrator'
-      )
-
-      this.initialized = true
-      this.logger.info('Orchestrator initialized')
-    } catch (error) {
-      this.logger.error({ error }, 'Failed to initialize orchestrator')
-      throw error
-    }
-  }
-
-  /**
-   * Register all event handlers
-   */
-  private registerHandlers(): void {
-    const handlers = [
-      this.taskHandler,
-      this.statusHandler,
-      this.decisionHandler,
-      this.contextHandler
-    ]
-
-    for (const handler of handlers) {
-      this.eventBus.registerHandler(handler)
-    }
-
-    this.logger.info({ count: handlers.length }, 'Handlers registered')
-  }
-
-  /**
-   * Setup vault watcher to emit file events
-   */
-  private setupVaultWatcher(): void {
-    // Handle file changes
-    this.vault.watcher.on('change', (event) => {
-      this.eventBus.emitEvent(
-        'file:modified',
-        { path: event.path, type: event.type },
-        'vault-watcher',
-        'normal'
-      )
-    })
-
-    // Handle new files
-    this.vault.watcher.on('created', (event) => {
-      this.eventBus.emitEvent(
-        'file:created',
-        { path: event.path, type: event.type },
-        'vault-watcher',
-        'normal'
-      )
-    })
-
-    // Handle deleted files
-    this.vault.watcher.on('deleted', (event) => {
-      this.eventBus.emitEvent(
-        'file:deleted',
-        { path: event.path, type: event.type },
-        'vault-watcher',
-        'normal'
-      )
-    })
-
-    this.logger.info('Vault watcher integrated')
-  }
-
-  /**
-   * Get orchestrator statistics
-   */
-  getStats(): OrchestratorStats {
-    return {
-      eventBus: this.eventBus.getStats(),
-      coordinator: this.coordinator.getStats()
-    }
-  }
-
-  /**
-   * Check if orchestrator is initialized
-   */
-  isInitialized(): boolean {
-    return this.initialized
-  }
-
-  /**
-   * Get the memory manager
-   */
-  getMemory(): MemoryManager {
-    return this.memory
-  }
-
-  /**
-   * Get the vault manager
-   */
-  getVault(): VaultManager {
-    return this.vault
-  }
-
-  /**
-   * Get handler instances for testing
-   */
-  getHandlers() {
-    return {
-      task: this.taskHandler,
-      status: this.statusHandler,
-      decision: this.decisionHandler,
-      context: this.contextHandler
-    }
-  }
-
-  /**
-   * Shutdown orchestrator
-   */
-  shutdown(): void {
-    this.logger.info('Shutting down orchestrator')
-
-    // Emit shutdown event
-    this.eventBus.emitEvent(
-      'system:shutdown',
-      { timestamp: new Date() },
-      'orchestrator'
-    )
-
-    // Stop coordinator
-    this.coordinator.stop()
-
-    // Remove all listeners
-    this.eventBus.removeAllListeners()
-
-    this.initialized = false
-    this.logger.info('Orchestrator shut down')
-  }
-}
-
-/**
- * Create an orchestrator instance
- */
-export function createOrchestrator(
-  logger: Logger,
-  vault: VaultManager,
-  memory: MemoryManager,
-  config?: OrchestratorConfig
-): Orchestrator {
-  return new Orchestrator(logger, vault, memory, config)
-}
+/**
+ * Orchestration Engine - Main Module
+ * Phase 4: Event-driven coordination system for Claude Brain
+ *
+ * This module provides:
+ * - Event-driven architecture for component communication
+ * - Automatic file change handling from Obsidian vault
+ * - Task extraction and tracking
+ * - Automatic decision logging
+ * - Operation coordination
+ */
+
+import type { Logger } from 'pino'
+import type { VaultManager } from '@/vault'
+import type { MemoryManager } from '@/memory'
+import { EventBus } from './event-emitter'
+import { AgentCoordinator } from './coordinator'
+import { DecisionLogger } from './decision-logger'
+import type { OrchestratorStats } from './types'
+
+// Import handlers
+import {
+  TaskHandler,
+  StatusChangeHandler,
+  DecisionDetectionHandler,
+  ContextUpdateHandler
+} from './handlers'
+
+// Re-export all types and classes
+export * from './types'
+export { EventBus } from './event-emitter'
+export { EventQueue } from './event-queue'
+export { AgentCoordinator } from './coordinator'
+export { DecisionLogger, type DecisionEntry } from './decision-logger'
+export { TaskParser, type Task, type TaskStatus, type TaskPriority } from './task-parser'
+export * from './handlers'
+
+export interface OrchestratorConfig {
+  maxConcurrentOperations?: number
+  debounceMs?: number
+  maxHistorySize?: number
+}
+
+/**
+ * Main Orchestrator class that coordinates all event-driven operations
+ */
+export class Orchestrator {
+  readonly eventBus: EventBus
+  readonly coordinator: AgentCoordinator
+  readonly decisionLogger: DecisionLogger
+
+  private logger: Logger
+  private vault: VaultManager
+  private memory: MemoryManager
+  private config: OrchestratorConfig
+  private initialized: boolean = false
+
+  // Handler instances
+  private taskHandler: TaskHandler
+  private statusHandler: StatusChangeHandler
+  private decisionHandler: DecisionDetectionHandler
+  private contextHandler: ContextUpdateHandler
+
+  constructor(
+    logger: Logger,
+    vault: VaultManager,
+    memory: MemoryManager,
+    config: OrchestratorConfig = {}
+  ) {
+    this.logger = logger.child({ component: 'orchestrator' })
+    this.vault = vault
+    this.memory = memory
+    this.config = {
+      maxConcurrentOperations: config.maxConcurrentOperations ?? 5,
+      debounceMs: config.debounceMs ?? 5000,
+      maxHistorySize: config.maxHistorySize ?? 1000
+    }
+
+    // Initialize core components
+    this.eventBus = new EventBus(logger, this.config.maxHistorySize)
+    this.coordinator = new AgentCoordinator(
+      logger,
+      this.eventBus,
+      this.config.maxConcurrentOperations
+    )
+    this.decisionLogger = new DecisionLogger(
+      logger,
+      memory,
+      vault.writer
+    )
+
+    // Initialize handlers
+    this.taskHandler = new TaskHandler(logger, vault.reader)
+    this.statusHandler = new StatusChangeHandler(logger, vault.reader)
+    this.decisionHandler = new DecisionDetectionHandler(
+      logger,
+      vault.reader,
+      memory,
+      this.config.debounceMs
+    )
+    this.contextHandler = new ContextUpdateHandler(logger, vault.reader)
+
+    // Give handlers access to event bus for emitting events
+    this.taskHandler.setEventBus(this.eventBus)
+    this.statusHandler.setEventBus(this.eventBus)
+    this.decisionHandler.setEventBus(this.eventBus)
+    this.contextHandler.setEventBus(this.eventBus)
+  }
+
+  /**
+   * Initialize orchestrator and register handlers
+   */
+  async initialize(): Promise<void> {
+    if (this.initialized) {
+      this.logger.warn('Orchestrator already initialized')
+      return
+    }
+
+    try {
+      this.logger.info('Initializing orchestrator...')
+
+      // Register handlers
+      this.registerHandlers()
+
+      // Setup vault watcher integration
+      this.setupVaultWatcher()
+
+      // Emit system ready event
+      this.eventBus.emitEvent(
+        'system:ready',
+        { timestamp: new Date() },
+        'orchestrator'
+      )
+
+      this.initialized = true
+      this.logger.info('Orchestrator initialized')
+    } catch (error) {
+      this.logger.error({ error }, 'Failed to initialize orchestrator')
+      throw error
+    }
+  }
+
+  /**
+   * Register all event handlers
+   */
+  private registerHandlers(): void {
+    const handlers = [
+      this.taskHandler,
+      this.statusHandler,
+      this.decisionHandler,
+      this.contextHandler
+    ]
+
+    for (const handler of handlers) {
+      this.eventBus.registerHandler(handler)
+    }
+
+    this.logger.info({ count: handlers.length }, 'Handlers registered')
+  }
+
+  /**
+   * Setup vault watcher to emit file events
+   */
+  private setupVaultWatcher(): void {
+    // Handle file changes
+    this.vault.watcher.on('change', (event) => {
+      this.eventBus.emitEvent(
+        'file:modified',
+        { path: event.path, type: event.type },
+        'vault-watcher',
+        'normal'
+      )
+    })
+
+    // Handle new files
+    this.vault.watcher.on('created', (event) => {
+      this.eventBus.emitEvent(
+        'file:created',
+        { path: event.path, type: event.type },
+        'vault-watcher',
+        'normal'
+      )
+    })
+
+    // Handle deleted files
+    this.vault.watcher.on('deleted', (event) => {
+      this.eventBus.emitEvent(
+        'file:deleted',
+        { path: event.path, type: event.type },
+        'vault-watcher',
+        'normal'
+      )
+    })
+
+    this.logger.info('Vault watcher integrated')
+  }
+
+  /**
+   * Get orchestrator statistics
+   */
+  getStats(): OrchestratorStats {
+    return {
+      eventBus: this.eventBus.getStats(),
+      coordinator: this.coordinator.getStats()
+    }
+  }
+
+  /**
+   * Check if orchestrator is initialized
+   */
+  isInitialized(): boolean {
+    return this.initialized
+  }
+
+  /**
+   * Get the memory manager
+   */
+  getMemory(): MemoryManager {
+    return this.memory
+  }
+
+  /**
+   * Get the vault manager
+   */
+  getVault(): VaultManager {
+    return this.vault
+  }
+
+  /**
+   * Get handler instances for testing
+   */
+  getHandlers() {
+    return {
+      task: this.taskHandler,
+      status: this.statusHandler,
+      decision: this.decisionHandler,
+      context: this.contextHandler
+    }
+  }
+
+  /**
+   * Shutdown orchestrator
+   */
+  shutdown(): void {
+    this.logger.info('Shutting down orchestrator')
+
+    // Emit shutdown event
+    this.eventBus.emitEvent(
+      'system:shutdown',
+      { timestamp: new Date() },
+      'orchestrator'
+    )
+
+    // Stop coordinator
+    this.coordinator.stop()
+
+    // Remove all listeners
+    this.eventBus.removeAllListeners()
+
+    this.initialized = false
+    this.logger.info('Orchestrator shut down')
+  }
+}
+
+/**
+ * Create an orchestrator instance
+ */
+export function createOrchestrator(
+  logger: Logger,
+  vault: VaultManager,
+  memory: MemoryManager,
+  config?: OrchestratorConfig
+): Orchestrator {
+  return new Orchestrator(logger, vault, memory, config)
+}