moflo 4.8.31 → 4.8.32

package/src/@claude-flow/shared/dist/core/config/validator.d.ts

@@ -1,92 +0,0 @@
-/**
- * V3 Configuration Validator
- * Validation logic using Zod schemas
- */
-import { z } from 'zod';
-import { type AgentConfig, type TaskConfig, type SwarmConfig, type MemoryConfig, type MCPServerConfig, type OrchestratorConfig, type SystemConfig } from './schema.js';
-/**
- * Validation result
- */
-export interface ValidationResult<T> {
-    success: boolean;
-    data?: T;
-    errors?: ValidationError[];
-}
-/**
- * Validation error
- */
-export interface ValidationError {
-    path: string;
-    message: string;
-    code: string;
-}
-/**
- * Validate agent configuration
- */
-export declare function validateAgentConfig(data: unknown): ValidationResult<AgentConfig>;
-/**
- * Validate task configuration
- */
-export declare function validateTaskConfig(data: unknown): ValidationResult<TaskConfig>;
-/**
- * Validate swarm configuration
- */
-export declare function validateSwarmConfig(data: unknown): ValidationResult<SwarmConfig>;
-/**
- * Validate memory configuration
- */
-export declare function validateMemoryConfig(data: unknown): ValidationResult<MemoryConfig>;
-/**
- * Validate MCP server configuration
- */
-export declare function validateMCPServerConfig(data: unknown): ValidationResult<MCPServerConfig>;
-/**
- * Validate orchestrator configuration
- */
-export declare function validateOrchestratorConfig(data: unknown): ValidationResult<OrchestratorConfig>;
-/**
- * Validate full system configuration
- */
-export declare function validateSystemConfig(data: unknown): ValidationResult<SystemConfig>;
-/**
- * Configuration validator class
- */
-export declare class ConfigValidator {
-    /**
-     * Validate and throw on error
-     */
-    static validateOrThrow<TInput, TOutput>(schema: z.ZodType<TOutput, z.ZodTypeDef, TInput>, data: unknown, configName: string): TOutput;
-    /**
-     * Validate agent config or throw
-     */
-    static validateAgentOrThrow(data: unknown): AgentConfig;
-    /**
-     * Validate task config or throw
-     */
-    static validateTaskOrThrow(data: unknown): TaskConfig;
-    /**
-     * Validate swarm config or throw
-     */
-    static validateSwarmOrThrow(data: unknown): SwarmConfig;
-    /**
-     * Validate memory config or throw
-     */
-    static validateMemoryOrThrow(data: unknown): MemoryConfig;
-    /**
-     * Validate MCP server config or throw
-     */
-    static validateMCPServerOrThrow(data: unknown): MCPServerConfig;
-    /**
-     * Validate orchestrator config or throw
-     */
-    static validateOrchestratorOrThrow(data: unknown): OrchestratorConfig;
-    /**
-     * Validate system config or throw
-     */
-    static validateSystemOrThrow(data: unknown): SystemConfig;
-    /**
-     * Check if data matches schema
-     */
-    static isValid<TInput, TOutput>(schema: z.ZodType<TOutput, z.ZodTypeDef, TInput>, data: unknown): boolean;
-}
-//# sourceMappingURL=validator.d.ts.map

package/src/@claude-flow/shared/dist/core/event-bus.d.ts

@@ -1,31 +0,0 @@
-/**
- * V3 Event Bus
- * Core event pub/sub implementation
- */
-import type { IEventBus, IEventCreate, IEventHandler, IEventSubscription, IEventFilter } from './interfaces/event.interface.js';
-/**
- * Event bus implementation
- */
-export declare class EventBus implements IEventBus {
-    private handlers;
-    private subscriptions;
-    private subscriptionId;
-    emit<T = unknown>(type: string, payload: T, options?: Partial<IEventCreate<T>>): void;
-    emitAsync<T = unknown>(type: string, payload: T, options?: Partial<IEventCreate<T>>): Promise<void>;
-    on<T = unknown>(type: string, handler: IEventHandler<T>): IEventSubscription;
-    subscribe<T = unknown>(filter: IEventFilter, handler: IEventHandler<T>): IEventSubscription;
-    once<T = unknown>(type: string, handler: IEventHandler<T>): IEventSubscription;
-    off(type: string, handler: IEventHandler): void;
-    removeAllListeners(type?: string): void;
-    listenerCount(type: string): number;
-    eventNames(): string[];
-    private createEvent;
-    private dispatchEvent;
-    private dispatchEventAsync;
-    private removeSubscription;
-}
-/**
- * Create a new event bus instance
- */
-export declare function createEventBus(): IEventBus;
-//# sourceMappingURL=event-bus.d.ts.map

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

@@ -1,15 +0,0 @@
-/**
- * V3 Core Module - Public API
- * Domain-Driven Design with Clean Architecture
- *
- * This module provides the core architecture for claude-flow v3:
- * - Decomposed orchestrator (task, session, health, lifecycle management)
- * - Event-driven architecture with event bus and coordinator
- * - Type-safe configuration with Zod validation
- * - Clean interfaces following DDD principles
- */
-export * from './interfaces/index.js';
-export { EventBus, createEventBus } from './event-bus.js';
-export * from './orchestrator/index.js';
-export * from './config/index.js';
-//# sourceMappingURL=index.d.ts.map

package/src/@claude-flow/shared/dist/core/interfaces/agent.interface.d.ts

@@ -1,200 +0,0 @@
-/**
- * V3 Agent Interfaces
- * Domain-Driven Design - Agent Lifecycle Bounded Context
- */
-/**
- * Agent status in the system
- */
-export type AgentStatus = 'spawning' | 'active' | 'idle' | 'busy' | 'error' | 'terminated';
-/**
- * Agent type classification
- */
-export type AgentType = 'coder' | 'reviewer' | 'tester' | 'researcher' | 'planner' | 'architect' | 'coordinator' | 'security' | 'performance' | 'custom';
-/**
- * Agent capability declaration
- */
-export interface IAgentCapability {
-    name: string;
-    level: 'basic' | 'intermediate' | 'advanced' | 'expert';
-    description?: string;
-}
-/**
- * Agent configuration for spawning
- */
-export interface IAgentConfig {
-    readonly id: string;
-    readonly name: string;
-    readonly type: AgentType | string;
-    capabilities: string[];
-    maxConcurrentTasks: number;
-    priority: number;
-    timeout?: number;
-    retryPolicy?: {
-        maxRetries: number;
-        backoffMs: number;
-        backoffMultiplier: number;
-    };
-    resources?: {
-        maxMemoryMb?: number;
-        maxCpuPercent?: number;
-    };
-    metadata?: Record<string, unknown>;
-}
-/**
- * Core agent entity
- */
-export interface IAgent {
-    readonly id: string;
-    readonly name: string;
-    readonly type: AgentType | string;
-    readonly config: IAgentConfig;
-    readonly createdAt: Date;
-    status: AgentStatus;
-    currentTaskCount: number;
-    lastActivity: Date;
-    sessionId?: string;
-    terminalId?: string;
-    memoryBankId?: string;
-    metrics?: {
-        tasksCompleted: number;
-        tasksFailed: number;
-        avgTaskDuration: number;
-        errorCount: number;
-        uptime: number;
-    };
-    health?: {
-        status: 'healthy' | 'degraded' | 'unhealthy';
-        lastCheck: Date;
-        issues?: string[];
-    };
-}
-/**
- * Agent session for tracking active work
- */
-export interface IAgentSession {
-    readonly id: string;
-    readonly agentId: string;
-    readonly startTime: Date;
-    status: 'active' | 'idle' | 'terminated';
-    terminalId: string;
-    memoryBankId: string;
-    lastActivity: Date;
-    endTime?: Date;
-    metadata?: Record<string, unknown>;
-}
-/**
- * Agent pool for managing multiple agents
- */
-export interface IAgentPool {
-    /**
-     * Add an agent to the pool
-     */
-    add(agent: IAgent): void;
-    /**
-     * Remove an agent from the pool
-     */
-    remove(agentId: string): boolean;
-    /**
-     * Get an agent by ID
-     */
-    get(agentId: string): IAgent | undefined;
-    /**
-     * Get all agents in the pool
-     */
-    getAll(): IAgent[];
-    /**
-     * Get agents by status
-     */
-    getByStatus(status: AgentStatus): IAgent[];
-    /**
-     * Get agents by type
-     */
-    getByType(type: AgentType | string): IAgent[];
-    /**
-     * Get available agents (can accept more tasks)
-     */
-    getAvailable(): IAgent[];
-    /**
-     * Get pool size
-     */
-    size(): number;
-    /**
-     * Check if pool has capacity
-     */
-    hasCapacity(maxSize: number): boolean;
-    /**
-     * Clear all agents
-     */
-    clear(): void;
-}
-/**
- * Agent lifecycle manager interface
- */
-export interface IAgentLifecycleManager {
-    /**
-     * Spawn a new agent
-     */
-    spawn(config: IAgentConfig): Promise<IAgent>;
-    /**
-     * Spawn multiple agents in parallel
-     */
-    spawnBatch(configs: IAgentConfig[]): Promise<Map<string, IAgent>>;
-    /**
-     * Terminate an agent
-     */
-    terminate(agentId: string, reason?: string): Promise<void>;
-    /**
-     * Terminate all agents
-     */
-    terminateAll(reason?: string): Promise<void>;
-    /**
-     * Restart an agent
-     */
-    restart(agentId: string): Promise<IAgent>;
-    /**
-     * Update agent configuration
-     */
-    updateConfig(agentId: string, config: Partial<IAgentConfig>): Promise<void>;
-    /**
-     * Get agent by ID
-     */
-    getAgent(agentId: string): IAgent | undefined;
-    /**
-     * Get all agents
-     */
-    getAllAgents(): IAgent[];
-    /**
-     * Get active agents count
-     */
-    getActiveCount(): number;
-    /**
-     * Check agent health
-     */
-    checkHealth(agentId: string): Promise<IAgent['health']>;
-}
-/**
- * Agent registry for type definitions
- */
-export interface IAgentRegistry {
-    /**
-     * Register an agent type with default config
-     */
-    register(type: string, defaultConfig: Partial<IAgentConfig>): void;
-    /**
-     * Unregister an agent type
-     */
-    unregister(type: string): boolean;
-    /**
-     * Get default config for a type
-     */
-    getDefaultConfig(type: string): Partial<IAgentConfig> | undefined;
-    /**
-     * Get all registered types
-     */
-    getRegisteredTypes(): string[];
-    /**
-     * Check if a type is registered
-     */
-    isRegistered(type: string): boolean;
-}
-//# sourceMappingURL=agent.interface.d.ts.map

package/src/@claude-flow/shared/dist/core/interfaces/coordinator.interface.d.ts

@@ -1,310 +0,0 @@
-/**
- * V3 Coordinator Interfaces
- * Domain-Driven Design - Coordination Bounded Context
- * Aligned with ADR-003 (Single Coordination Engine)
- */
-import type { ITask, ITaskResult } from './task.interface.js';
-import type { IAgent, IAgentConfig } from './agent.interface.js';
-/**
- * Swarm topology types
- */
-export type SwarmTopology = 'hierarchical' | 'mesh' | 'ring' | 'star' | 'adaptive' | 'hierarchical-mesh';
-/**
- * Coordination status
- */
-export type CoordinationStatus = 'initializing' | 'ready' | 'coordinating' | 'degraded' | 'error' | 'shutdown';
-/**
- * Swarm configuration
- */
-export interface ISwarmConfig {
-    topology: SwarmTopology;
-    maxAgents: number;
-    autoScale?: {
-        enabled: boolean;
-        minAgents: number;
-        maxAgents: number;
-        scaleUpThreshold: number;
-        scaleDownThreshold: number;
-    };
-    coordination?: {
-        consensusRequired: boolean;
-        timeoutMs: number;
-        retryPolicy: {
-            maxRetries: number;
-            backoffMs: number;
-        };
-    };
-    communication?: {
-        protocol: 'events' | 'messages' | 'shared-memory';
-        batchSize: number;
-        flushIntervalMs: number;
-    };
-    metadata?: Record<string, unknown>;
-}
-/**
- * Swarm state
- */
-export interface ISwarmState {
-    readonly id: string;
-    readonly topology: SwarmTopology;
-    readonly createdAt: Date;
-    status: CoordinationStatus;
-    agentCount: number;
-    taskCount: number;
-    metrics?: {
-        throughput: number;
-        latencyMs: number;
-        successRate: number;
-        resourceUtilization: number;
-    };
-}
-/**
- * Coordinator interface - unified coordination engine
- */
-export interface ICoordinator {
-    /**
-     * Initialize the coordinator
-     */
-    initialize(): Promise<void>;
-    /**
-     * Shutdown the coordinator
-     */
-    shutdown(): Promise<void>;
-    /**
-     * Initialize a swarm with configuration
-     */
-    initializeSwarm(config: ISwarmConfig): Promise<ISwarmState>;
-    /**
-     * Get swarm state
-     */
-    getSwarmState(): ISwarmState | undefined;
-    /**
-     * Assign a task to an agent
-     */
-    assignTask(task: ITask, agentId: string): Promise<void>;
-    /**
-     * Get tasks assigned to an agent
-     */
-    getAgentTasks(agentId: string): Promise<ITask[]>;
-    /**
-     * Get task count for an agent
-     */
-    getAgentTaskCount(agentId: string): Promise<number>;
-    /**
-     * Cancel a task
-     */
-    cancelTask(taskId: string): Promise<void>;
-    /**
-     * Report task completion
-     */
-    reportTaskComplete(taskId: string, result: ITaskResult): Promise<void>;
-    /**
-     * Get coordination health status
-     */
-    getHealthStatus(): Promise<{
-        healthy: boolean;
-        error?: string;
-        metrics?: Record<string, number>;
-    }>;
-    /**
-     * Perform maintenance tasks
-     */
-    performMaintenance(): Promise<void>;
-}
-/**
- * Coordination manager interface - higher-level orchestration
- */
-export interface ICoordinationManager extends ICoordinator {
-    /**
-     * Register an agent with the coordinator
-     */
-    registerAgent(agent: IAgent): Promise<void>;
-    /**
-     * Unregister an agent
-     */
-    unregisterAgent(agentId: string): Promise<void>;
-    /**
-     * Get all registered agents
-     */
-    getRegisteredAgents(): IAgent[];
-    /**
-     * Request agent consensus on a decision
-     */
-    requestConsensus(topic: string, options: unknown[], timeout?: number): Promise<unknown>;
-    /**
-     * Broadcast message to all agents
-     */
-    broadcast(message: unknown): Promise<void>;
-    /**
-     * Send message to specific agent
-     */
-    sendToAgent(agentId: string, message: unknown): Promise<void>;
-    /**
-     * Acquire a distributed lock
-     */
-    acquireLock(resourceId: string, agentId: string, timeout?: number): Promise<boolean>;
-    /**
-     * Release a distributed lock
-     */
-    releaseLock(resourceId: string, agentId: string): Promise<void>;
-    /**
-     * Check for deadlocks
-     */
-    detectDeadlocks(): Promise<{
-        detected: boolean;
-        agents?: string[];
-        resources?: string[];
-    }>;
-}
-/**
- * Health status for components
- */
-export interface IHealthStatus {
-    status: 'healthy' | 'degraded' | 'unhealthy';
-    components: Record<string, IComponentHealth>;
-    timestamp: Date;
-}
-/**
- * Component health details
- */
-export interface IComponentHealth {
-    name: string;
-    status: 'healthy' | 'degraded' | 'unhealthy';
-    lastCheck: Date;
-    error?: string;
-    metrics?: Record<string, number>;
-}
-/**
- * Health monitor interface
- */
-export interface IHealthMonitor {
-    /**
-     * Start health monitoring
-     */
-    start(): void;
-    /**
-     * Stop health monitoring
-     */
-    stop(): void;
-    /**
-     * Get current health status
-     */
-    getStatus(): Promise<IHealthStatus>;
-    /**
-     * Register a health check
-     */
-    registerCheck(name: string, check: () => Promise<{
-        healthy: boolean;
-        error?: string;
-        metrics?: Record<string, number>;
-    }>): void;
-    /**
-     * Unregister a health check
-     */
-    unregisterCheck(name: string): void;
-    /**
-     * Get health history
-     */
-    getHistory(limit?: number): IHealthStatus[];
-    /**
-     * Subscribe to health changes
-     */
-    onHealthChange(callback: (status: IHealthStatus) => void): () => void;
-}
-/**
- * Metrics collector interface
- */
-export interface IMetricsCollector {
-    /**
-     * Start metrics collection
-     */
-    start(): void;
-    /**
-     * Stop metrics collection
-     */
-    stop(): void;
-    /**
-     * Record a metric value
-     */
-    record(name: string, value: number, tags?: Record<string, string>): void;
-    /**
-     * Increment a counter
-     */
-    increment(name: string, value?: number, tags?: Record<string, string>): void;
-    /**
-     * Record a timing
-     */
-    timing(name: string, durationMs: number, tags?: Record<string, string>): void;
-    /**
-     * Get current metrics
-     */
-    getMetrics(): Record<string, {
-        value: number;
-        count: number;
-        avg: number;
-        min: number;
-        max: number;
-    }>;
-    /**
-     * Reset all metrics
-     */
-    reset(): void;
-}
-/**
- * Orchestrator metrics structure
- */
-export interface IOrchestratorMetrics {
-    uptime: number;
-    totalAgents: number;
-    activeAgents: number;
-    totalTasks: number;
-    completedTasks: number;
-    failedTasks: number;
-    queuedTasks: number;
-    avgTaskDuration: number;
-    memoryUsage: NodeJS.MemoryUsage;
-    cpuUsage: NodeJS.CpuUsage;
-    timestamp: Date;
-}
-/**
- * Main orchestrator interface - facade for all orchestration capabilities
- */
-export interface IOrchestrator {
-    /**
-     * Initialize the orchestrator
-     */
-    initialize(): Promise<void>;
-    /**
-     * Shutdown the orchestrator
-     */
-    shutdown(): Promise<void>;
-    /**
-     * Get health status
-     */
-    getHealthStatus(): Promise<IHealthStatus>;
-    /**
-     * Get orchestrator metrics
-     */
-    getMetrics(): Promise<IOrchestratorMetrics>;
-    /**
-     * Spawn a new agent
-     */
-    spawnAgent(config: IAgentConfig): Promise<IAgent>;
-    /**
-     * Terminate an agent
-     */
-    terminateAgent(agentId: string, reason?: string): Promise<void>;
-    /**
-     * Submit a task
-     */
-    submitTask(task: ITask): Promise<ITaskResult>;
-    /**
-     * Get task by ID
-     */
-    getTask(taskId: string): Promise<ITask | undefined>;
-    /**
-     * Cancel a task
-     */
-    cancelTask(taskId: string): Promise<void>;
-}
-//# sourceMappingURL=coordinator.interface.d.ts.map