moflo 4.0.0

package/v3/@claude-flow/shared/dist/core/interfaces/task.interface.d.ts

@@ -0,0 +1,185 @@
+/**
+ * V3 Task Interfaces
+ * Domain-Driven Design - Task Bounded Context
+ */
+/**
+ * Task priority levels
+ */
+export type TaskPriority = 'critical' | 'high' | 'medium' | 'low';
+/**
+ * Task status throughout its lifecycle
+ */
+export type TaskStatus = 'pending' | 'queued' | 'assigned' | 'running' | 'completed' | 'failed' | 'cancelled' | 'timeout';
+/**
+ * Core task entity
+ */
+export interface ITask {
+    readonly id: string;
+    readonly type: string;
+    readonly description: string;
+    readonly priority: number;
+    readonly createdAt: Date;
+    status: TaskStatus;
+    assignedAgent?: string;
+    startedAt?: Date;
+    completedAt?: Date;
+    timeout?: number;
+    input?: Record<string, unknown>;
+    output?: Record<string, unknown>;
+    error?: Error;
+    metadata?: {
+        requiredCapabilities?: string[];
+        retryCount?: number;
+        maxRetries?: number;
+        critical?: boolean;
+        parentTaskId?: string;
+        childTaskIds?: string[];
+        tags?: string[];
+        [key: string]: unknown;
+    };
+}
+/**
+ * Task creation parameters
+ */
+export interface ITaskCreate {
+    type: string;
+    description: string;
+    priority?: number;
+    timeout?: number;
+    assignedAgent?: string;
+    input?: Record<string, unknown>;
+    metadata?: ITask['metadata'];
+}
+/**
+ * Task result after completion
+ */
+export interface ITaskResult {
+    taskId: string;
+    success: boolean;
+    output?: Record<string, unknown>;
+    error?: Error;
+    duration: number;
+    agentId?: string;
+    metrics?: {
+        tokensUsed?: number;
+        memoryPeakMb?: number;
+        retryCount?: number;
+    };
+}
+/**
+ * Task queue interface for managing task ordering and processing
+ */
+export interface ITaskQueue {
+    /**
+     * Add a task to the queue
+     */
+    enqueue(task: ITask): Promise<void>;
+    /**
+     * Remove and return the highest priority task
+     */
+    dequeue(): Promise<ITask | undefined>;
+    /**
+     * Peek at the next task without removing it
+     */
+    peek(): Promise<ITask | undefined>;
+    /**
+     * Get the current queue size
+     */
+    size(): number;
+    /**
+     * Check if the queue is empty
+     */
+    isEmpty(): boolean;
+    /**
+     * Clear all tasks from the queue
+     */
+    clear(): Promise<void>;
+    /**
+     * Get all queued tasks (for inspection)
+     */
+    getAll(): Promise<ITask[]>;
+    /**
+     * Remove a specific task by ID
+     */
+    remove(taskId: string): Promise<boolean>;
+    /**
+     * Update task priority
+     */
+    updatePriority(taskId: string, priority: number): Promise<boolean>;
+}
+/**
+ * Task manager interface for lifecycle management
+ */
+export interface ITaskManager {
+    /**
+     * Create a new task
+     */
+    createTask(params: ITaskCreate): Promise<ITask>;
+    /**
+     * Get a task by ID
+     */
+    getTask(taskId: string): ITask | undefined;
+    /**
+     * Get all tasks matching optional filter
+     */
+    getTasks(filter?: Partial<Pick<ITask, 'status' | 'type' | 'assignedAgent'>>): ITask[];
+    /**
+     * Assign a task to an agent
+     */
+    assignTask(taskId: string, agentId: string): Promise<void>;
+    /**
+     * Start task execution
+     */
+    startTask(taskId: string): Promise<void>;
+    /**
+     * Complete a task with result
+     */
+    completeTask(taskId: string, result: ITaskResult): Promise<void>;
+    /**
+     * Fail a task with error
+     */
+    failTask(taskId: string, error: Error): Promise<void>;
+    /**
+     * Cancel a task
+     */
+    cancelTask(taskId: string, reason?: string): Promise<void>;
+    /**
+     * Retry a failed task
+     */
+    retryTask(taskId: string): Promise<void>;
+    /**
+     * Get task metrics
+     */
+    getMetrics(): TaskManagerMetrics;
+    /**
+     * Clean up old completed/failed tasks
+     */
+    cleanup(olderThan: Date): Promise<number>;
+}
+/**
+ * Task manager metrics
+ */
+export interface TaskManagerMetrics {
+    totalTasks: number;
+    pendingTasks: number;
+    runningTasks: number;
+    completedTasks: number;
+    failedTasks: number;
+    cancelledTasks: number;
+    avgDuration: number;
+    avgWaitTime: number;
+}
+/**
+ * Task assignment strategy interface
+ */
+export interface ITaskAssignmentStrategy {
+    /**
+     * Select the best agent for a task
+     */
+    selectAgent(task: ITask, availableAgents: string[]): Promise<string | undefined>;
+    /**
+     * Score an agent for a task (higher is better)
+     */
+    scoreAgent(task: ITask, agentId: string): Promise<number>;
+}
+//# sourceMappingURL=task.interface.d.ts.map

package/v3/@claude-flow/shared/dist/core/interfaces/task.interface.js

@@ -0,0 +1,6 @@
+/**
+ * V3 Task Interfaces
+ * Domain-Driven Design - Task Bounded Context
+ */
+export {};
+//# sourceMappingURL=task.interface.js.map

package/v3/@claude-flow/shared/dist/core/orchestrator/event-coordinator.d.ts

@@ -0,0 +1,35 @@
+/**
+ * V3 Event Coordinator
+ * Decomposed from orchestrator.ts - Event routing
+ * ~100 lines (target achieved)
+ */
+import type { IEvent, IEventBus, IEventHandler, IEventCoordinator } from '../interfaces/event.interface.js';
+/**
+ * Event coordinator implementation
+ */
+export declare class EventCoordinator implements IEventCoordinator {
+    private eventBus;
+    private handlers;
+    private initialized;
+    constructor(eventBus: IEventBus);
+    initialize(): Promise<void>;
+    shutdown(): Promise<void>;
+    route(event: IEvent): Promise<void>;
+    registerHandler(type: string, handler: IEventHandler): void;
+    unregisterHandler(type: string, handler: IEventHandler): void;
+    getEventBus(): IEventBus;
+    private registerSystemHandlers;
+    /**
+     * Get registered handler count for a type
+     */
+    getHandlerCount(type: string): number;
+    /**
+     * Get all registered event types
+     */
+    getRegisteredTypes(): string[];
+    /**
+     * Check if coordinator is initialized
+     */
+    isInitialized(): boolean;
+}
+//# sourceMappingURL=event-coordinator.d.ts.map

package/v3/@claude-flow/shared/dist/core/orchestrator/event-coordinator.js

@@ -0,0 +1,101 @@
+/**
+ * V3 Event Coordinator
+ * Decomposed from orchestrator.ts - Event routing
+ * ~100 lines (target achieved)
+ */
+import { SystemEventTypes } from '../interfaces/event.interface.js';
+/**
+ * Event coordinator implementation
+ */
+export class EventCoordinator {
+    eventBus;
+    handlers = new Map();
+    initialized = false;
+    constructor(eventBus) {
+        this.eventBus = eventBus;
+    }
+    async initialize() {
+        if (this.initialized) {
+            return;
+        }
+        // Register default system event handlers
+        this.registerSystemHandlers();
+        this.initialized = true;
+    }
+    async shutdown() {
+        // Clear all handlers
+        this.handlers.clear();
+        this.initialized = false;
+    }
+    async route(event) {
+        const handlers = this.handlers.get(event.type);
+        if (!handlers || handlers.size === 0) {
+            return;
+        }
+        const handlerPromises = Array.from(handlers).map(async (handler) => {
+            try {
+                await handler(event);
+            }
+            catch (error) {
+                // Log error but don't throw
+                console.error(`Error in event handler for ${event.type}:`, error);
+            }
+        });
+        await Promise.allSettled(handlerPromises);
+    }
+    registerHandler(type, handler) {
+        let handlers = this.handlers.get(type);
+        if (!handlers) {
+            handlers = new Set();
+            this.handlers.set(type, handlers);
+        }
+        handlers.add(handler);
+        // Also register with event bus
+        this.eventBus.on(type, handler);
+    }
+    unregisterHandler(type, handler) {
+        const handlers = this.handlers.get(type);
+        if (handlers) {
+            handlers.delete(handler);
+            if (handlers.size === 0) {
+                this.handlers.delete(type);
+            }
+        }
+        // Also unregister from event bus
+        this.eventBus.off(type, handler);
+    }
+    getEventBus() {
+        return this.eventBus;
+    }
+    registerSystemHandlers() {
+        // Error handling
+        this.eventBus.on(SystemEventTypes.SYSTEM_ERROR, (event) => {
+            const { error, component } = event.payload;
+            console.error(`System error in ${component}:`, error);
+        });
+        // Deadlock detection
+        this.eventBus.on(SystemEventTypes.DEADLOCK_DETECTED, (event) => {
+            const { agents, resources } = event.payload;
+            console.warn('Deadlock detected:', { agents, resources });
+        });
+    }
+    /**
+     * Get registered handler count for a type
+     */
+    getHandlerCount(type) {
+        return this.handlers.get(type)?.size ?? 0;
+    }
+    /**
+     * Get all registered event types
+     */
+    getRegisteredTypes() {
+        return Array.from(this.handlers.keys());
+    }
+    /**
+     * Check if coordinator is initialized
+     */
+    isInitialized() {
+        return this.initialized;
+    }
+}
+//# sourceMappingURL=event-coordinator.js.map

package/v3/@claude-flow/shared/dist/core/orchestrator/health-monitor.d.ts

@@ -0,0 +1,60 @@
+/**
+ * V3 Health Monitor
+ * Decomposed from orchestrator.ts - Agent health checks
+ * ~150 lines (target achieved)
+ */
+import type { IHealthMonitor, IHealthStatus, IComponentHealth } from '../interfaces/coordinator.interface.js';
+import type { IEventBus } from '../interfaces/event.interface.js';
+/**
+ * Health check function type
+ */
+export type HealthCheckFn = () => Promise<{
+    healthy: boolean;
+    error?: string;
+    metrics?: Record<string, number>;
+}>;
+/**
+ * Health monitor configuration
+ */
+export interface HealthMonitorConfig {
+    checkInterval: number;
+    historyLimit: number;
+    degradedThreshold: number;
+    unhealthyThreshold: number;
+}
+/**
+ * Health monitor implementation
+ */
+export declare class HealthMonitor implements IHealthMonitor {
+    private eventBus;
+    private config;
+    private checks;
+    private history;
+    private interval?;
+    private listeners;
+    private running;
+    constructor(eventBus: IEventBus, config?: HealthMonitorConfig);
+    start(): void;
+    stop(): void;
+    getStatus(): Promise<IHealthStatus>;
+    registerCheck(name: string, check: HealthCheckFn): void;
+    unregisterCheck(name: string): void;
+    getHistory(limit?: number): IHealthStatus[];
+    onHealthChange(callback: (status: IHealthStatus) => void): () => void;
+    private addToHistory;
+    private notifyListeners;
+    private timeout;
+    /**
+     * Get component health by name
+     */
+    getComponentHealth(name: string): Promise<IComponentHealth | undefined>;
+    /**
+     * Check if system is healthy
+     */
+    isHealthy(): Promise<boolean>;
+    /**
+     * Get registered check names
+     */
+    getRegisteredChecks(): string[];
+}
+//# sourceMappingURL=health-monitor.d.ts.map

package/v3/@claude-flow/shared/dist/core/orchestrator/health-monitor.js

@@ -0,0 +1,166 @@
+/**
+ * V3 Health Monitor
+ * Decomposed from orchestrator.ts - Agent health checks
+ * ~150 lines (target achieved)
+ */
+import { SystemEventTypes } from '../interfaces/event.interface.js';
+/**
+ * Health monitor implementation
+ */
+export class HealthMonitor {
+    eventBus;
+    config;
+    checks = new Map();
+    history = [];
+    interval;
+    listeners = [];
+    running = false;
+    constructor(eventBus, config = {
+        checkInterval: 30000,
+        historyLimit: 100,
+        degradedThreshold: 1,
+        unhealthyThreshold: 2,
+    }) {
+        this.eventBus = eventBus;
+        this.config = config;
+    }
+    start() {
+        if (this.running) {
+            return;
+        }
+        this.running = true;
+        this.interval = setInterval(async () => {
+            const status = await this.getStatus();
+            this.addToHistory(status);
+            this.notifyListeners(status);
+            this.eventBus.emit(SystemEventTypes.SYSTEM_HEALTHCHECK, { status });
+        }, this.config.checkInterval);
+    }
+    stop() {
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = undefined;
+        }
+        this.running = false;
+    }
+    async getStatus() {
+        const components = {};
+        let unhealthyCount = 0;
+        let degradedCount = 0;
+        const checkPromises = Array.from(this.checks.entries()).map(async ([name, check]) => {
+            try {
+                const result = await Promise.race([
+                    check(),
+                    this.timeout(5000, 'Health check timeout'),
+                ]);
+                const health = {
+                    name,
+                    status: result.healthy ? 'healthy' : 'unhealthy',
+                    lastCheck: new Date(),
+                    error: result.error,
+                    metrics: result.metrics,
+                };
+                return { name, health };
+            }
+            catch (error) {
+                return {
+                    name,
+                    health: {
+                        name,
+                        status: 'unhealthy',
+                        lastCheck: new Date(),
+                        error: error instanceof Error ? error.message : 'Unknown error',
+                    },
+                };
+            }
+        });
+        const results = await Promise.allSettled(checkPromises);
+        for (const result of results) {
+            if (result.status === 'fulfilled') {
+                const { name, health } = result.value;
+                components[name] = health;
+                if (health.status === 'unhealthy') {
+                    unhealthyCount++;
+                }
+                else if (health.status === 'degraded') {
+                    degradedCount++;
+                }
+            }
+        }
+        let overallStatus = 'healthy';
+        if (unhealthyCount >= this.config.unhealthyThreshold) {
+            overallStatus = 'unhealthy';
+        }
+        else if (unhealthyCount > 0 ||
+            degradedCount >= this.config.degradedThreshold) {
+            overallStatus = 'degraded';
+        }
+        return {
+            status: overallStatus,
+            components,
+            timestamp: new Date(),
+        };
+    }
+    registerCheck(name, check) {
+        this.checks.set(name, check);
+    }
+    unregisterCheck(name) {
+        this.checks.delete(name);
+    }
+    getHistory(limit) {
+        const count = limit ?? this.config.historyLimit;
+        return this.history.slice(-count);
+    }
+    onHealthChange(callback) {
+        this.listeners.push(callback);
+        return () => {
+            const index = this.listeners.indexOf(callback);
+            if (index !== -1) {
+                this.listeners.splice(index, 1);
+            }
+        };
+    }
+    addToHistory(status) {
+        this.history.push(status);
+        // Trim history to limit
+        if (this.history.length > this.config.historyLimit) {
+            this.history = this.history.slice(-this.config.historyLimit);
+        }
+    }
+    notifyListeners(status) {
+        for (const listener of this.listeners) {
+            try {
+                listener(status);
+            }
+            catch {
+                // Ignore listener errors
+            }
+        }
+    }
+    timeout(ms, message) {
+        return new Promise((_, reject) => {
+            setTimeout(() => reject(new Error(message)), ms);
+        });
+    }
+    /**
+     * Get component health by name
+     */
+    async getComponentHealth(name) {
+        const status = await this.getStatus();
+        return status.components[name];
+    }
+    /**
+     * Check if system is healthy
+     */
+    async isHealthy() {
+        const status = await this.getStatus();
+        return status.status === 'healthy';
+    }
+    /**
+     * Get registered check names
+     */
+    getRegisteredChecks() {
+        return Array.from(this.checks.keys());
+    }
+}
+//# sourceMappingURL=health-monitor.js.map

package/v3/@claude-flow/shared/dist/core/orchestrator/index.d.ts

@@ -0,0 +1,46 @@
+/**
+ * V3 Orchestrator Facade
+ * Unified interface to decomposed orchestrator components
+ * ~50 lines (target achieved)
+ */
+import { TaskManager } from './task-manager.js';
+import { SessionManager, type SessionManagerConfig } from './session-manager.js';
+import { HealthMonitor, type HealthMonitorConfig } from './health-monitor.js';
+import { LifecycleManager, type LifecycleManagerConfig } from './lifecycle-manager.js';
+import { EventCoordinator } from './event-coordinator.js';
+import { EventBus } from '../event-bus.js';
+export * from './task-manager.js';
+export * from './session-manager.js';
+export * from './health-monitor.js';
+export * from './lifecycle-manager.js';
+export * from './event-coordinator.js';
+/**
+ * Orchestrator facade configuration
+ * (Note: For schema-validated config, use OrchestratorConfig from config/schema.ts)
+ */
+export interface OrchestratorFacadeConfig {
+    session: SessionManagerConfig;
+    health: HealthMonitorConfig;
+    lifecycle: LifecycleManagerConfig;
+}
+/**
+ * Default orchestrator facade configuration
+ */
+export declare const defaultOrchestratorFacadeConfig: OrchestratorFacadeConfig;
+/**
+ * Create orchestrator components
+ */
+export declare function createOrchestrator(config?: Partial<OrchestratorFacadeConfig>): {
+    eventBus: EventBus;
+    taskManager: TaskManager;
+    sessionManager: SessionManager;
+    healthMonitor: HealthMonitor;
+    lifecycleManager: LifecycleManager;
+    eventCoordinator: EventCoordinator;
+    config: OrchestratorFacadeConfig;
+};
+/**
+ * Orchestrator type for facade
+ */
+export type OrchestratorComponents = ReturnType<typeof createOrchestrator>;
+//# sourceMappingURL=index.d.ts.map

package/v3/@claude-flow/shared/dist/core/orchestrator/index.js

@@ -0,0 +1,64 @@
+/**
+ * V3 Orchestrator Facade
+ * Unified interface to decomposed orchestrator components
+ * ~50 lines (target achieved)
+ */
+import { TaskManager } from './task-manager.js';
+import { SessionManager } from './session-manager.js';
+import { HealthMonitor } from './health-monitor.js';
+import { LifecycleManager } from './lifecycle-manager.js';
+import { EventCoordinator } from './event-coordinator.js';
+import { EventBus } from '../event-bus.js';
+export * from './task-manager.js';
+export * from './session-manager.js';
+export * from './health-monitor.js';
+export * from './lifecycle-manager.js';
+export * from './event-coordinator.js';
+/**
+ * Default orchestrator facade configuration
+ */
+export const defaultOrchestratorFacadeConfig = {
+    session: {
+        persistSessions: true,
+        dataDir: './data',
+        sessionRetentionMs: 3600000,
+    },
+    health: {
+        checkInterval: 30000,
+        historyLimit: 100,
+        degradedThreshold: 1,
+        unhealthyThreshold: 2,
+    },
+    lifecycle: {
+        maxConcurrentAgents: 20,
+        spawnTimeout: 30000,
+        terminateTimeout: 10000,
+        maxSpawnRetries: 3,
+    },
+};
+/**
+ * Create orchestrator components
+ */
+export function createOrchestrator(config = {}) {
+    const mergedConfig = {
+        session: { ...defaultOrchestratorFacadeConfig.session, ...config.session },
+        health: { ...defaultOrchestratorFacadeConfig.health, ...config.health },
+        lifecycle: { ...defaultOrchestratorFacadeConfig.lifecycle, ...config.lifecycle },
+    };
+    const eventBus = new EventBus();
+    const taskManager = new TaskManager(eventBus);
+    const sessionManager = new SessionManager(eventBus, mergedConfig.session);
+    const healthMonitor = new HealthMonitor(eventBus, mergedConfig.health);
+    const lifecycleManager = new LifecycleManager(eventBus, mergedConfig.lifecycle);
+    const eventCoordinator = new EventCoordinator(eventBus);
+    return {
+        eventBus,
+        taskManager,
+        sessionManager,
+        healthMonitor,
+        lifecycleManager,
+        eventCoordinator,
+        config: mergedConfig,
+    };
+}
+//# sourceMappingURL=index.js.map