claude-flow 3.25.6 → 3.26.1

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

@@ -1,185 +0,0 @@
-/**
- * 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

@@ -1,6 +0,0 @@
-/**
- * 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

@@ -1,35 +0,0 @@
-/**
- * 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

@@ -1,101 +0,0 @@
-/**
- * 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

@@ -1,60 +0,0 @@
-/**
- * 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

@@ -1,166 +0,0 @@
-/**
- * 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

@@ -1,46 +0,0 @@
-/**
- * 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

@@ -1,64 +0,0 @@
-/**
- * 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