@agentic-qe/v3 3.0.0-alpha.6 → 3.0.0-alpha.8

package/src/workers/worker-manager.ts

@@ -1,424 +0,0 @@
-/**
- * Agentic QE v3 - Worker Manager Implementation
- * ADR-014: Background Workers for QE Monitoring
- *
- * Manages the lifecycle and scheduling of all background workers.
- * Provides centralized control for starting, stopping, and monitoring workers.
- */
-
-import {
-  Worker,
-  WorkerManager as IWorkerManager,
-  WorkerManagerHealth,
-  WorkerResult,
-  WorkerContext,
-  WorkerEventBus,
-  WorkerMemory,
-  WorkerLogger,
-  WorkerDomainAccess,
-  WorkerEvent,
-} from './interfaces';
-import { DomainName } from '../shared/types';
-
-/**
- * In-memory implementation of Worker Event Bus
- */
-class InMemoryWorkerEventBus implements WorkerEventBus {
-  private handlers: Array<(event: WorkerEvent) => void> = [];
-
-  async publish(event: WorkerEvent): Promise<void> {
-    for (const handler of this.handlers) {
-      try {
-        handler(event);
-      } catch {
-        // Ignore handler errors
-      }
-    }
-  }
-
-  subscribe(handler: (event: WorkerEvent) => void): () => void {
-    this.handlers.push(handler);
-    return () => {
-      const index = this.handlers.indexOf(handler);
-      if (index >= 0) {
-        this.handlers.splice(index, 1);
-      }
-    };
-  }
-}
-
-/**
- * In-memory implementation of Worker Memory
- */
-class InMemoryWorkerMemory implements WorkerMemory {
-  private store = new Map<string, unknown>();
-
-  async get<T>(key: string): Promise<T | undefined> {
-    return this.store.get(key) as T | undefined;
-  }
-
-  async set<T>(key: string, value: T): Promise<void> {
-    this.store.set(key, value);
-  }
-
-  async search(pattern: string): Promise<string[]> {
-    const regex = new RegExp(pattern.replace(/\*/g, '.*'));
-    return Array.from(this.store.keys()).filter((key) => regex.test(key));
-  }
-}
-
-/**
- * Console-based Worker Logger
- */
-class ConsoleWorkerLogger implements WorkerLogger {
-  constructor(private workerId: string) {}
-
-  private format(level: string, message: string, meta?: Record<string, unknown>): string {
-    const timestamp = new Date().toISOString();
-    const metaStr = meta ? ` ${JSON.stringify(meta)}` : '';
-    return `[${timestamp}] [${level}] [${this.workerId}] ${message}${metaStr}`;
-  }
-
-  debug(message: string, meta?: Record<string, unknown>): void {
-    if (process.env.DEBUG) {
-      console.debug(this.format('DEBUG', message, meta));
-    }
-  }
-
-  info(message: string, meta?: Record<string, unknown>): void {
-    console.info(this.format('INFO', message, meta));
-  }
-
-  warn(message: string, meta?: Record<string, unknown>): void {
-    console.warn(this.format('WARN', message, meta));
-  }
-
-  error(message: string, meta?: Record<string, unknown>): void {
-    console.error(this.format('ERROR', message, meta));
-  }
-}
-
-/**
- * Kernel-integrated Domain Access
- * Provides workers access to domain services via the kernel
- */
-class KernelWorkerDomainAccess implements WorkerDomainAccess {
-  constructor(
-    private readonly kernelGetter: () => KernelReference | undefined
-  ) {}
-
-  getDomainAPI<T>(domain: DomainName): T | undefined {
-    const kernel = this.kernelGetter();
-    if (!kernel) {
-      return undefined;
-    }
-    return kernel.getDomainAPI<T>(domain);
-  }
-
-  getDomainHealth(domain: DomainName): { status: string; errors: string[] } {
-    const kernel = this.kernelGetter();
-    if (!kernel) {
-      return { status: 'unknown', errors: ['Kernel not available'] };
-    }
-
-    const health = kernel.getHealth();
-    const domainHealth = health.domains[domain];
-
-    if (!domainHealth) {
-      return { status: 'unknown', errors: [`Domain ${domain} not found`] };
-    }
-
-    return {
-      status: domainHealth.status,
-      errors: domainHealth.errors || [],
-    };
-  }
-}
-
-/**
- * Reference interface for kernel (to avoid circular dependency)
- */
-interface KernelReference {
-  getDomainAPI<T>(domain: DomainName): T | undefined;
-  getHealth(): {
-    domains: Record<string, { status: string; errors?: string[] }>;
-  };
-}
-
-/**
- * Stub Domain Access (fallback when kernel not available)
- */
-class StubWorkerDomainAccess implements WorkerDomainAccess {
-  getDomainAPI<T>(_domain: DomainName): T | undefined {
-    return undefined;
-  }
-
-  getDomainHealth(_domain: DomainName): { status: string; errors: string[] } {
-    return { status: 'healthy', errors: [] };
-  }
-}
-
-/**
- * Worker Manager implementation
- */
-export class WorkerManagerImpl implements IWorkerManager {
-  private workers = new Map<string, Worker>();
-  private timers = new Map<string, NodeJS.Timeout>();
-  private abortControllers = new Map<string, AbortController>();
-  private eventBus: InMemoryWorkerEventBus;
-  private memory: InMemoryWorkerMemory;
-  private domainAccess: WorkerDomainAccess;
-  private running = false;
-  private kernelRef: KernelReference | undefined;
-
-  constructor(options?: {
-    eventBus?: WorkerEventBus;
-    memory?: WorkerMemory;
-    domainAccess?: WorkerDomainAccess;
-    kernel?: KernelReference;
-  }) {
-    this.eventBus = (options?.eventBus as InMemoryWorkerEventBus) ?? new InMemoryWorkerEventBus();
-    this.memory = (options?.memory as InMemoryWorkerMemory) ?? new InMemoryWorkerMemory();
-    this.kernelRef = options?.kernel;
-
-    // Use kernel-based domain access if kernel is provided, otherwise fall back
-    if (options?.domainAccess) {
-      this.domainAccess = options.domainAccess;
-    } else if (options?.kernel) {
-      this.domainAccess = new KernelWorkerDomainAccess(() => this.kernelRef);
-    } else {
-      this.domainAccess = new StubWorkerDomainAccess();
-    }
-  }
-
-  /**
-   * Set or update the kernel reference
-   * Allows late binding of kernel after construction
-   */
-  setKernel(kernel: KernelReference): void {
-    this.kernelRef = kernel;
-    // Update domain access to use kernel if not already custom
-    if (this.domainAccess instanceof StubWorkerDomainAccess) {
-      this.domainAccess = new KernelWorkerDomainAccess(() => this.kernelRef);
-    }
-  }
-
-  /**
-   * Register a worker
-   */
-  register(worker: Worker): void {
-    if (this.workers.has(worker.config.id)) {
-      throw new Error(`Worker ${worker.config.id} is already registered`);
-    }
-    this.workers.set(worker.config.id, worker);
-  }
-
-  /**
-   * Unregister a worker
-   */
-  unregister(workerId: string): void {
-    const worker = this.workers.get(workerId);
-    if (worker) {
-      this.stopWorker(workerId);
-      this.workers.delete(workerId);
-    }
-  }
-
-  /**
-   * Get a worker by ID
-   */
-  get(workerId: string): Worker | undefined {
-    return this.workers.get(workerId);
-  }
-
-  /**
-   * List all registered workers
-   */
-  list(): Worker[] {
-    return Array.from(this.workers.values());
-  }
-
-  /**
-   * Start all enabled workers
-   */
-  async startAll(): Promise<void> {
-    this.running = true;
-
-    for (const worker of Array.from(this.workers.values())) {
-      if (worker.config.enabled) {
-        await this.startWorker(worker);
-      }
-    }
-  }
-
-  /**
-   * Stop all workers
-   */
-  async stopAll(): Promise<void> {
-    this.running = false;
-
-    const stopPromises: Promise<void>[] = [];
-    for (const workerId of Array.from(this.workers.keys())) {
-      stopPromises.push(this.stopWorker(workerId));
-    }
-    await Promise.all(stopPromises);
-  }
-
-  /**
-   * Run a specific worker immediately
-   */
-  async runNow(workerId: string): Promise<WorkerResult> {
-    const worker = this.workers.get(workerId);
-    if (!worker) {
-      throw new Error(`Worker ${workerId} not found`);
-    }
-
-    // Cancel existing timer if any
-    const existingTimer = this.timers.get(workerId);
-    if (existingTimer) {
-      clearTimeout(existingTimer);
-    }
-
-    // Create a new abort controller for this execution
-    const abortController = new AbortController();
-    this.abortControllers.set(workerId, abortController);
-
-    const context = this.createContext(workerId, abortController.signal);
-    const result = await worker.execute(context);
-
-    // Reschedule if still running
-    if (this.running && worker.config.enabled && worker.status !== 'stopped') {
-      this.scheduleNextRun(worker);
-    }
-
-    return result;
-  }
-
-  /**
-   * Get manager health status
-   */
-  getHealth(): WorkerManagerHealth {
-    const workerHealths: Record<string, ReturnType<Worker['getHealth']>> = {};
-    let runningCount = 0;
-    let pausedCount = 0;
-    let errorCount = 0;
-    let totalHealthScore = 0;
-
-    for (const [id, worker] of Array.from(this.workers.entries())) {
-      const health = worker.getHealth();
-      workerHealths[id] = health;
-      totalHealthScore += health.healthScore;
-
-      switch (worker.status) {
-        case 'running':
-          runningCount++;
-          break;
-        case 'paused':
-          pausedCount++;
-          break;
-        case 'error':
-          errorCount++;
-          break;
-      }
-    }
-
-    const avgHealthScore =
-      this.workers.size > 0 ? Math.round(totalHealthScore / this.workers.size) : 100;
-
-    return {
-      totalWorkers: this.workers.size,
-      runningWorkers: runningCount,
-      pausedWorkers: pausedCount,
-      errorWorkers: errorCount,
-      healthScore: avgHealthScore,
-      workers: workerHealths,
-    };
-  }
-
-  /**
-   * Subscribe to worker events
-   */
-  onWorkerEvent(handler: (event: WorkerEvent) => void): () => void {
-    return this.eventBus.subscribe(handler);
-  }
-
-  // ============================================================================
-  // Private Methods
-  // ============================================================================
-
-  private async startWorker(worker: Worker): Promise<void> {
-    await worker.initialize();
-
-    // Create abort controller
-    const abortController = new AbortController();
-    this.abortControllers.set(worker.config.id, abortController);
-
-    // Run immediately
-    const context = this.createContext(worker.config.id, abortController.signal);
-    try {
-      await worker.execute(context);
-    } catch (error) {
-      console.error(`Worker ${worker.config.id} initial execution failed:`, error);
-    }
-
-    // Schedule next run
-    this.scheduleNextRun(worker);
-  }
-
-  private async stopWorker(workerId: string): Promise<void> {
-    // Clear timer
-    const timer = this.timers.get(workerId);
-    if (timer) {
-      clearTimeout(timer);
-      this.timers.delete(workerId);
-    }
-
-    // Abort any running execution
-    const abortController = this.abortControllers.get(workerId);
-    if (abortController) {
-      abortController.abort();
-      this.abortControllers.delete(workerId);
-    }
-
-    // Stop the worker
-    const worker = this.workers.get(workerId);
-    if (worker) {
-      await worker.stop();
-    }
-  }
-
-  private scheduleNextRun(worker: Worker): void {
-    const timer = setTimeout(async () => {
-      if (!this.running || worker.status === 'stopped' || worker.status === 'paused') {
-        return;
-      }
-
-      const abortController = new AbortController();
-      this.abortControllers.set(worker.config.id, abortController);
-
-      const context = this.createContext(worker.config.id, abortController.signal);
-      try {
-        await worker.execute(context);
-      } catch (error) {
-        console.error(`Worker ${worker.config.id} execution failed:`, error);
-      }
-
-      // Schedule next run (worker status is 'idle' | 'running' | 'error', not 'stopped')
-      if (this.running && worker.config.enabled && worker.status !== 'error') {
-        this.scheduleNextRun(worker);
-      }
-    }, worker.config.intervalMs);
-
-    this.timers.set(worker.config.id, timer);
-  }
-
-  private createContext(workerId: string, signal: AbortSignal): WorkerContext {
-    return {
-      eventBus: this.eventBus,
-      memory: this.memory,
-      logger: new ConsoleWorkerLogger(workerId),
-      domains: this.domainAccess,
-      signal,
-    };
-  }
-}