moflo 4.8.31 → 4.8.32

package/src/@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/src/@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/src/@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/src/@claude-flow/shared/dist/core/orchestrator/lifecycle-manager.d.ts

@@ -1,56 +0,0 @@
-/**
- * V3 Lifecycle Manager
- * Decomposed from orchestrator.ts - Agent spawn/terminate
- * ~150 lines (target achieved)
- */
-import type { IAgent, IAgentConfig, IAgentLifecycleManager, IAgentPool, AgentStatus } from '../interfaces/agent.interface.js';
-import type { IEventBus } from '../interfaces/event.interface.js';
-/**
- * Agent pool implementation
- */
-export declare class AgentPool implements IAgentPool {
-    private agents;
-    add(agent: IAgent): void;
-    remove(agentId: string): boolean;
-    get(agentId: string): IAgent | undefined;
-    getAll(): IAgent[];
-    getByStatus(status: AgentStatus): IAgent[];
-    getByType(type: string): IAgent[];
-    getAvailable(): IAgent[];
-    size(): number;
-    hasCapacity(maxSize: number): boolean;
-    clear(): void;
-}
-/**
- * Lifecycle manager configuration
- */
-export interface LifecycleManagerConfig {
-    maxConcurrentAgents: number;
-    spawnTimeout: number;
-    terminateTimeout: number;
-    maxSpawnRetries: number;
-}
-/**
- * Lifecycle manager implementation
- */
-export declare class LifecycleManager implements IAgentLifecycleManager {
-    private eventBus;
-    private config;
-    private pool;
-    constructor(eventBus: IEventBus, config: LifecycleManagerConfig, pool?: IAgentPool);
-    spawn(config: IAgentConfig): Promise<IAgent>;
-    spawnBatch(configs: IAgentConfig[]): Promise<Map<string, IAgent>>;
-    terminate(agentId: string, reason?: string): Promise<void>;
-    terminateAll(reason?: string): Promise<void>;
-    restart(agentId: string): Promise<IAgent>;
-    updateConfig(agentId: string, config: Partial<IAgentConfig>): Promise<void>;
-    getAgent(agentId: string): IAgent | undefined;
-    getAllAgents(): IAgent[];
-    getActiveCount(): number;
-    checkHealth(agentId: string): Promise<IAgent['health']>;
-    /**
-     * Get agent pool
-     */
-    getPool(): IAgentPool;
-}
-//# sourceMappingURL=lifecycle-manager.d.ts.map

package/src/@claude-flow/shared/dist/core/orchestrator/session-manager.d.ts

@@ -1,83 +0,0 @@
-/**
- * V3 Session Manager
- * Decomposed from orchestrator.ts - Session handling
- * ~200 lines (target achieved)
- */
-import type { IAgentSession } from '../interfaces/agent.interface.js';
-import type { IEventBus } from '../interfaces/event.interface.js';
-import type { AgentProfile } from '../../types/agent.types.js';
-/**
- * Session persistence structure
- */
-export interface SessionPersistence {
-    sessions: Array<IAgentSession & {
-        profile: AgentProfile;
-    }>;
-    metrics: {
-        completedTasks: number;
-        failedTasks: number;
-        totalTaskDuration: number;
-    };
-    savedAt: Date;
-}
-/**
- * Session manager configuration
- */
-export interface SessionManagerConfig {
-    persistSessions: boolean;
-    dataDir: string;
-    sessionRetentionMs?: number;
-}
-/**
- * Session manager interface
- */
-export interface ISessionManager {
-    createSession(profile: AgentProfile, terminalId: string, memoryBankId: string): Promise<IAgentSession>;
-    getSession(sessionId: string): IAgentSession | undefined;
-    getActiveSessions(): IAgentSession[];
-    getSessionsByAgent(agentId: string): IAgentSession[];
-    terminateSession(sessionId: string): Promise<void>;
-    terminateAllSessions(): Promise<void>;
-    persistSessions(): Promise<void>;
-    restoreSessions(): Promise<SessionPersistence | null>;
-    removeSession(sessionId: string): void;
-    updateSessionActivity(sessionId: string): void;
-}
-/**
- * Session manager implementation
- */
-export declare class SessionManager implements ISessionManager {
-    private eventBus;
-    private config;
-    private sessions;
-    private sessionProfiles;
-    private persistencePath;
-    constructor(eventBus: IEventBus, config: SessionManagerConfig);
-    createSession(profile: AgentProfile, terminalId: string, memoryBankId: string): Promise<IAgentSession>;
-    getSession(sessionId: string): IAgentSession | undefined;
-    getActiveSessions(): IAgentSession[];
-    getSessionsByAgent(agentId: string): IAgentSession[];
-    terminateSession(sessionId: string): Promise<void>;
-    terminateAllSessions(): Promise<void>;
-    removeSession(sessionId: string): void;
-    updateSessionActivity(sessionId: string): void;
-    persistSessions(): Promise<void>;
-    restoreSessions(): Promise<SessionPersistence | null>;
-    /**
-     * Clean up old terminated sessions
-     */
-    cleanupTerminatedSessions(retentionMs?: number): Promise<number>;
-    /**
-     * Get session profile
-     */
-    getSessionProfile(sessionId: string): AgentProfile | undefined;
-    /**
-     * Get session count
-     */
-    getSessionCount(): number;
-    /**
-     * Get active session count
-     */
-    getActiveSessionCount(): number;
-}
-//# sourceMappingURL=session-manager.d.ts.map

package/src/@claude-flow/shared/dist/core/orchestrator/task-manager.d.ts

@@ -1,49 +0,0 @@
-/**
- * V3 Task Manager
- * Decomposed from orchestrator.ts - Task lifecycle management
- * ~200 lines (target achieved)
- */
-import type { ITask, ITaskCreate, ITaskResult, ITaskManager, ITaskQueue, TaskManagerMetrics } from '../interfaces/task.interface.js';
-import type { IEventBus } from '../interfaces/event.interface.js';
-/**
- * Priority queue implementation for tasks
- */
-export declare class TaskQueue implements ITaskQueue {
-    private tasks;
-    enqueue(task: ITask): Promise<void>;
-    dequeue(): Promise<ITask | undefined>;
-    peek(): Promise<ITask | undefined>;
-    size(): number;
-    isEmpty(): boolean;
-    clear(): Promise<void>;
-    getAll(): Promise<ITask[]>;
-    remove(taskId: string): Promise<boolean>;
-    updatePriority(taskId: string, priority: number): Promise<boolean>;
-}
-/**
- * Task manager implementation
- */
-export declare class TaskManager implements ITaskManager {
-    private eventBus;
-    private tasks;
-    private queue;
-    private metrics;
-    constructor(eventBus: IEventBus, queue?: ITaskQueue);
-    createTask(params: ITaskCreate): Promise<ITask>;
-    getTask(taskId: string): ITask | undefined;
-    getTasks(filter?: Partial<Pick<ITask, 'status' | 'type' | 'assignedAgent'>>): ITask[];
-    assignTask(taskId: string, agentId: string): Promise<void>;
-    startTask(taskId: string): Promise<void>;
-    completeTask(taskId: string, result: ITaskResult): Promise<void>;
-    failTask(taskId: string, error: Error): Promise<void>;
-    cancelTask(taskId: string, reason?: string): Promise<void>;
-    retryTask(taskId: string): Promise<void>;
-    getMetrics(): TaskManagerMetrics;
-    cleanup(olderThan: Date): Promise<number>;
-    private isRetryable;
-    /**
-     * Get the task queue
-     */
-    getQueue(): ITaskQueue;
-}
-//# sourceMappingURL=task-manager.d.ts.map

package/src/@claude-flow/shared/dist/events/domain-events.d.ts

@@ -1,282 +0,0 @@
-/**
- * Domain Events for Event Sourcing (ADR-007)
- *
- * Defines all domain events for the V3 system:
- * - Agent lifecycle events (spawned, started, stopped, failed)
- * - Task execution events (created, started, completed, failed)
- * - Memory operations events (stored, retrieved, deleted)
- * - Swarm coordination events (initialized, scaled, terminated)
- *
- * @module v3/shared/events/domain-events
- */
-import { AgentId, TaskId } from '../types.js';
-export interface DomainEvent {
-    /** Unique event identifier */
-    id: string;
-    /** Event type discriminator */
-    type: string;
-    /** Aggregate ID (entity the event belongs to) */
-    aggregateId: string;
-    /** Aggregate type (agent, task, memory, swarm) */
-    aggregateType: 'agent' | 'task' | 'memory' | 'swarm';
-    /** Event version for ordering */
-    version: number;
-    /** Timestamp when event occurred */
-    timestamp: number;
-    /** Event source (agent or swarm system) */
-    source: AgentId | 'swarm';
-    /** Event payload data */
-    payload: Record<string, unknown>;
-    /** Optional metadata */
-    metadata?: Record<string, unknown>;
-    /** Optional causation ID (event that caused this event) */
-    causationId?: string;
-    /** Optional correlation ID (groups related events) */
-    correlationId?: string;
-}
-export interface AgentSpawnedEvent extends DomainEvent {
-    type: 'agent:spawned';
-    aggregateType: 'agent';
-    payload: {
-        agentId: AgentId;
-        role: string;
-        domain: string;
-        capabilities: string[];
-    };
-}
-export interface AgentStartedEvent extends DomainEvent {
-    type: 'agent:started';
-    aggregateType: 'agent';
-    payload: {
-        agentId: AgentId;
-        startedAt: number;
-    };
-}
-export interface AgentStoppedEvent extends DomainEvent {
-    type: 'agent:stopped';
-    aggregateType: 'agent';
-    payload: {
-        agentId: AgentId;
-        reason: string;
-        stoppedAt: number;
-    };
-}
-export interface AgentFailedEvent extends DomainEvent {
-    type: 'agent:failed';
-    aggregateType: 'agent';
-    payload: {
-        agentId: AgentId;
-        error: string;
-        stack?: string;
-        failedAt: number;
-    };
-}
-export interface AgentStatusChangedEvent extends DomainEvent {
-    type: 'agent:status-changed';
-    aggregateType: 'agent';
-    payload: {
-        agentId: AgentId;
-        previousStatus: string;
-        newStatus: string;
-    };
-}
-export interface AgentTaskAssignedEvent extends DomainEvent {
-    type: 'agent:task-assigned';
-    aggregateType: 'agent';
-    payload: {
-        agentId: AgentId;
-        taskId: TaskId;
-        assignedAt: number;
-    };
-}
-export interface AgentTaskCompletedEvent extends DomainEvent {
-    type: 'agent:task-completed';
-    aggregateType: 'agent';
-    payload: {
-        agentId: AgentId;
-        taskId: TaskId;
-        result: unknown;
-        completedAt: number;
-        duration: number;
-    };
-}
-export interface TaskCreatedEvent extends DomainEvent {
-    type: 'task:created';
-    aggregateType: 'task';
-    payload: {
-        taskId: TaskId;
-        taskType: string;
-        title: string;
-        description: string;
-        priority: string;
-        dependencies: TaskId[];
-        createdAt: number;
-    };
-}
-export interface TaskStartedEvent extends DomainEvent {
-    type: 'task:started';
-    aggregateType: 'task';
-    payload: {
-        taskId: TaskId;
-        agentId: AgentId;
-        startedAt: number;
-    };
-}
-export interface TaskCompletedEvent extends DomainEvent {
-    type: 'task:completed';
-    aggregateType: 'task';
-    payload: {
-        taskId: TaskId;
-        result: unknown;
-        completedAt: number;
-        duration: number;
-    };
-}
-export interface TaskFailedEvent extends DomainEvent {
-    type: 'task:failed';
-    aggregateType: 'task';
-    payload: {
-        taskId: TaskId;
-        error: string;
-        stack?: string;
-        failedAt: number;
-        retryCount: number;
-    };
-}
-export interface TaskBlockedEvent extends DomainEvent {
-    type: 'task:blocked';
-    aggregateType: 'task';
-    payload: {
-        taskId: TaskId;
-        blockedBy: TaskId[];
-        blockedAt: number;
-    };
-}
-export interface TaskQueuedEvent extends DomainEvent {
-    type: 'task:queued';
-    aggregateType: 'task';
-    payload: {
-        taskId: TaskId;
-        priority: string;
-        queuedAt: number;
-    };
-}
-export interface MemoryStoredEvent extends DomainEvent {
-    type: 'memory:stored';
-    aggregateType: 'memory';
-    payload: {
-        memoryId: string;
-        namespace: string;
-        key: string;
-        memoryType: string;
-        size: number;
-        storedAt: number;
-    };
-}
-export interface MemoryRetrievedEvent extends DomainEvent {
-    type: 'memory:retrieved';
-    aggregateType: 'memory';
-    payload: {
-        memoryId: string;
-        namespace: string;
-        key: string;
-        retrievedAt: number;
-        accessCount: number;
-    };
-}
-export interface MemoryDeletedEvent extends DomainEvent {
-    type: 'memory:deleted';
-    aggregateType: 'memory';
-    payload: {
-        memoryId: string;
-        namespace: string;
-        key: string;
-        deletedAt: number;
-    };
-}
-export interface MemoryExpiredEvent extends DomainEvent {
-    type: 'memory:expired';
-    aggregateType: 'memory';
-    payload: {
-        memoryId: string;
-        namespace: string;
-        key: string;
-        expiredAt: number;
-        expiresAt: number;
-    };
-}
-export interface SwarmInitializedEvent extends DomainEvent {
-    type: 'swarm:initialized';
-    aggregateType: 'swarm';
-    payload: {
-        topology: string;
-        maxAgents: number;
-        config: Record<string, unknown>;
-        initializedAt: number;
-    };
-}
-export interface SwarmScaledEvent extends DomainEvent {
-    type: 'swarm:scaled';
-    aggregateType: 'swarm';
-    payload: {
-        previousAgentCount: number;
-        newAgentCount: number;
-        scaledAt: number;
-        reason: string;
-    };
-}
-export interface SwarmTerminatedEvent extends DomainEvent {
-    type: 'swarm:terminated';
-    aggregateType: 'swarm';
-    payload: {
-        reason: string;
-        terminatedAt: number;
-        metrics: Record<string, unknown>;
-    };
-}
-export interface SwarmPhaseChangedEvent extends DomainEvent {
-    type: 'swarm:phase-changed';
-    aggregateType: 'swarm';
-    payload: {
-        previousPhase: string;
-        newPhase: string;
-        changedAt: number;
-    };
-}
-export interface SwarmMilestoneReachedEvent extends DomainEvent {
-    type: 'swarm:milestone-reached';
-    aggregateType: 'swarm';
-    payload: {
-        milestoneId: string;
-        name: string;
-        reachedAt: number;
-    };
-}
-export interface SwarmErrorEvent extends DomainEvent {
-    type: 'swarm:error';
-    aggregateType: 'swarm';
-    payload: {
-        error: string;
-        stack?: string;
-        context: Record<string, unknown>;
-        errorAt: number;
-    };
-}
-export type AllDomainEvents = AgentSpawnedEvent | AgentStartedEvent | AgentStoppedEvent | AgentFailedEvent | AgentStatusChangedEvent | AgentTaskAssignedEvent | AgentTaskCompletedEvent | TaskCreatedEvent | TaskStartedEvent | TaskCompletedEvent | TaskFailedEvent | TaskBlockedEvent | TaskQueuedEvent | MemoryStoredEvent | MemoryRetrievedEvent | MemoryDeletedEvent | MemoryExpiredEvent | SwarmInitializedEvent | SwarmScaledEvent | SwarmTerminatedEvent | SwarmPhaseChangedEvent | SwarmMilestoneReachedEvent | SwarmErrorEvent;
-export declare function createAgentSpawnedEvent(agentId: AgentId, role: string, domain: string, capabilities: string[]): AgentSpawnedEvent;
-export declare function createAgentStartedEvent(agentId: AgentId): AgentStartedEvent;
-export declare function createAgentStoppedEvent(agentId: AgentId, reason: string): AgentStoppedEvent;
-export declare function createAgentFailedEvent(agentId: AgentId, error: Error): AgentFailedEvent;
-export declare function createAgentTaskAssignedEvent(agentId: AgentId, taskId: TaskId, assignedAt?: number): AgentTaskAssignedEvent;
-export declare function createAgentTaskCompletedEvent(agentId: AgentId, taskId: TaskId, result: unknown, completedAt: number, duration: number): AgentTaskCompletedEvent;
-export declare function createTaskCreatedEvent(taskId: TaskId, taskType: string, title: string, description: string, priority: string, dependencies: TaskId[]): TaskCreatedEvent;
-export declare function createTaskStartedEvent(taskId: TaskId, agentId: AgentId): TaskStartedEvent;
-export declare function createTaskCompletedEvent(taskId: TaskId, result: unknown, duration: number): TaskCompletedEvent;
-export declare function createTaskFailedEvent(taskId: TaskId, error: Error, retryCount: number): TaskFailedEvent;
-export declare function createMemoryStoredEvent(memoryId: string, namespace: string, key: string, memoryType: string, size: number): MemoryStoredEvent;
-export declare function createMemoryRetrievedEvent(memoryId: string, namespace: string, key: string, accessCount: number): MemoryRetrievedEvent;
-export declare function createMemoryDeletedEvent(memoryId: string, namespace: string, key: string): MemoryDeletedEvent;
-export declare function createSwarmInitializedEvent(topology: string, maxAgents: number, config: Record<string, unknown>): SwarmInitializedEvent;
-export declare function createSwarmScaledEvent(previousAgentCount: number, newAgentCount: number, reason: string): SwarmScaledEvent;
-export declare function createSwarmTerminatedEvent(reason: string, metrics: Record<string, unknown>): SwarmTerminatedEvent;
-//# sourceMappingURL=domain-events.d.ts.map