moflo 4.8.31 → 4.8.32

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

@@ -1,224 +0,0 @@
-/**
- * V3 Event Interfaces
- * Domain-Driven Design - Event Sourcing Pattern (ADR-007)
- */
-/**
- * Event priority levels
- */
-export type EventPriority = 'critical' | 'high' | 'normal' | 'low';
-/**
- * Core event structure
- */
-export interface IEvent<T = unknown> {
-    readonly id: string;
-    readonly type: string;
-    readonly timestamp: Date;
-    readonly source: string;
-    payload: T;
-    priority?: EventPriority;
-    correlationId?: string;
-    causationId?: string;
-    metadata?: {
-        version?: number;
-        userId?: string;
-        sessionId?: string;
-        [key: string]: unknown;
-    };
-}
-/**
- * Event creation parameters
- */
-export interface IEventCreate<T = unknown> {
-    type: string;
-    payload: T;
-    source?: string;
-    priority?: EventPriority;
-    correlationId?: string;
-    causationId?: string;
-    metadata?: IEvent['metadata'];
-}
-/**
- * Event handler function type
- */
-export type IEventHandler<T = unknown> = (event: IEvent<T>) => void | Promise<void>;
-/**
- * Event filter for subscriptions
- */
-export interface IEventFilter {
-    types?: string[];
-    sources?: string[];
-    priority?: EventPriority[];
-    correlationId?: string;
-}
-/**
- * Event subscription handle
- */
-export interface IEventSubscription {
-    readonly id: string;
-    readonly filter: IEventFilter;
-    /**
-     * Unsubscribe from events
-     */
-    unsubscribe(): void;
-    /**
-     * Pause subscription
-     */
-    pause(): void;
-    /**
-     * Resume subscription
-     */
-    resume(): void;
-    /**
-     * Check if subscription is active
-     */
-    isActive(): boolean;
-}
-/**
- * Event bus interface for pub/sub communication
- */
-export interface IEventBus {
-    /**
-     * Emit an event to all subscribers
-     */
-    emit<T = unknown>(type: string, payload: T, options?: Partial<IEventCreate<T>>): void;
-    /**
-     * Emit an event and wait for all handlers
-     */
-    emitAsync<T = unknown>(type: string, payload: T, options?: Partial<IEventCreate<T>>): Promise<void>;
-    /**
-     * Subscribe to events matching a type pattern
-     */
-    on<T = unknown>(type: string, handler: IEventHandler<T>): IEventSubscription;
-    /**
-     * Subscribe to events with filter
-     */
-    subscribe<T = unknown>(filter: IEventFilter, handler: IEventHandler<T>): IEventSubscription;
-    /**
-     * Subscribe to a single event occurrence
-     */
-    once<T = unknown>(type: string, handler: IEventHandler<T>): IEventSubscription;
-    /**
-     * Remove a specific handler
-     */
-    off(type: string, handler: IEventHandler): void;
-    /**
-     * Remove all handlers for a type
-     */
-    removeAllListeners(type?: string): void;
-    /**
-     * Get count of listeners for a type
-     */
-    listenerCount(type: string): number;
-    /**
-     * Get all event types with active listeners
-     */
-    eventNames(): string[];
-}
-/**
- * System event types enumeration
- */
-export declare const SystemEventTypes: {
-    readonly SYSTEM_READY: "system:ready";
-    readonly SYSTEM_SHUTDOWN: "system:shutdown";
-    readonly SYSTEM_ERROR: "system:error";
-    readonly SYSTEM_HEALTHCHECK: "system:healthcheck";
-    readonly AGENT_SPAWNED: "agent:spawned";
-    readonly AGENT_TERMINATED: "agent:terminated";
-    readonly AGENT_ERROR: "agent:error";
-    readonly AGENT_IDLE: "agent:idle";
-    readonly AGENT_BUSY: "agent:busy";
-    readonly AGENT_HEALTH_CHANGED: "agent:health:changed";
-    readonly TASK_CREATED: "task:created";
-    readonly TASK_ASSIGNED: "task:assigned";
-    readonly TASK_STARTED: "task:started";
-    readonly TASK_COMPLETED: "task:completed";
-    readonly TASK_FAILED: "task:failed";
-    readonly TASK_CANCELLED: "task:cancelled";
-    readonly TASK_TIMEOUT: "task:timeout";
-    readonly TASK_RETRY: "task:retry";
-    readonly SESSION_CREATED: "session:created";
-    readonly SESSION_RESTORED: "session:restored";
-    readonly SESSION_TERMINATED: "session:terminated";
-    readonly SESSION_PERSISTED: "session:persisted";
-    readonly MEMORY_STORED: "memory:stored";
-    readonly MEMORY_RETRIEVED: "memory:retrieved";
-    readonly MEMORY_CLEARED: "memory:cleared";
-    readonly COORDINATION_STARTED: "coordination:started";
-    readonly COORDINATION_COMPLETED: "coordination:completed";
-    readonly DEADLOCK_DETECTED: "coordination:deadlock";
-    readonly METRICS_COLLECTED: "metrics:collected";
-};
-export type SystemEventType = typeof SystemEventTypes[keyof typeof SystemEventTypes];
-/**
- * Event store interface for event sourcing
- */
-export interface IEventStore {
-    /**
-     * Append an event to the store
-     */
-    append(event: IEvent): Promise<void>;
-    /**
-     * Get events by aggregate ID
-     */
-    getByAggregateId(aggregateId: string, fromVersion?: number): Promise<IEvent[]>;
-    /**
-     * Get events by type
-     */
-    getByType(type: string, options?: {
-        limit?: number;
-        offset?: number;
-    }): Promise<IEvent[]>;
-    /**
-     * Get events in time range
-     */
-    getByTimeRange(start: Date, end: Date): Promise<IEvent[]>;
-    /**
-     * Get events by correlation ID
-     */
-    getByCorrelationId(correlationId: string): Promise<IEvent[]>;
-    /**
-     * Get all events (paginated)
-     */
-    getAll(options?: {
-        limit?: number;
-        offset?: number;
-    }): Promise<IEvent[]>;
-    /**
-     * Get event count
-     */
-    count(filter?: IEventFilter): Promise<number>;
-    /**
-     * Clear old events
-     */
-    prune(olderThan: Date): Promise<number>;
-}
-/**
- * Event coordinator for routing and orchestration
- */
-export interface IEventCoordinator {
-    /**
-     * Initialize the coordinator
-     */
-    initialize(): Promise<void>;
-    /**
-     * Shutdown the coordinator
-     */
-    shutdown(): Promise<void>;
-    /**
-     * Route an event to appropriate handlers
-     */
-    route(event: IEvent): Promise<void>;
-    /**
-     * Register a handler for event routing
-     */
-    registerHandler(type: string, handler: IEventHandler): void;
-    /**
-     * Unregister a handler
-     */
-    unregisterHandler(type: string, handler: IEventHandler): void;
-    /**
-     * Get event bus instance
-     */
-    getEventBus(): IEventBus;
-}
-//# sourceMappingURL=event.interface.d.ts.map

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

@@ -1,10 +0,0 @@
-/**
- * V3 Core Interfaces - Public API
- * Domain-Driven Design with Clean Architecture
- */
-export * from './task.interface.js';
-export * from './agent.interface.js';
-export * from './event.interface.js';
-export * from './memory.interface.js';
-export * from './coordinator.interface.js';
-//# sourceMappingURL=index.d.ts.map

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

@@ -1,298 +0,0 @@
-/**
- * V3 Memory Interfaces
- * Domain-Driven Design - Memory Management Bounded Context
- * Aligned with ADR-006 (Unified Memory Service) and ADR-009 (Hybrid Memory Backend)
- */
-/**
- * Memory entry types
- */
-export type MemoryType = 'session' | 'persistent' | 'vector' | 'cache' | 'pattern';
-/**
- * Memory entry structure
- */
-export interface IMemoryEntry {
-    readonly id: string;
-    readonly key: string;
-    readonly type: MemoryType;
-    readonly createdAt: Date;
-    value: unknown;
-    updatedAt: Date;
-    expiresAt?: Date;
-    metadata?: {
-        source?: string;
-        agentId?: string;
-        sessionId?: string;
-        version?: number;
-        tags?: string[];
-        embedding?: number[];
-        [key: string]: unknown;
-    };
-}
-/**
- * Memory entry creation parameters
- */
-export interface IMemoryEntryCreate {
-    key: string;
-    value: unknown;
-    type?: MemoryType;
-    expiresAt?: Date;
-    ttlMs?: number;
-    metadata?: IMemoryEntry['metadata'];
-}
-/**
- * Vector search parameters
- */
-export interface IVectorSearchParams {
-    embedding: number[];
-    k?: number;
-    threshold?: number;
-    filter?: {
-        type?: MemoryType;
-        tags?: string[];
-        agentId?: string;
-    };
-}
-/**
- * Vector search result
- */
-export interface IVectorSearchResult {
-    entry: IMemoryEntry;
-    score: number;
-    distance: number;
-}
-/**
- * Memory backend interface for storage operations
- */
-export interface IMemoryBackend {
-    /**
-     * Initialize the backend
-     */
-    initialize(): Promise<void>;
-    /**
-     * Shutdown the backend
-     */
-    shutdown(): Promise<void>;
-    /**
-     * Store a memory entry
-     */
-    store(entry: IMemoryEntryCreate): Promise<IMemoryEntry>;
-    /**
-     * Retrieve a memory entry by key
-     */
-    retrieve(key: string): Promise<IMemoryEntry | undefined>;
-    /**
-     * Retrieve by ID
-     */
-    retrieveById(id: string): Promise<IMemoryEntry | undefined>;
-    /**
-     * Update a memory entry
-     */
-    update(key: string, value: unknown, metadata?: Partial<IMemoryEntry['metadata']>): Promise<IMemoryEntry | undefined>;
-    /**
-     * Delete a memory entry
-     */
-    delete(key: string): Promise<boolean>;
-    /**
-     * Check if a key exists
-     */
-    exists(key: string): Promise<boolean>;
-    /**
-     * List all keys matching a pattern
-     */
-    keys(pattern?: string): Promise<string[]>;
-    /**
-     * Get all entries matching filter
-     */
-    list(filter?: {
-        type?: MemoryType;
-        tags?: string[];
-    }): Promise<IMemoryEntry[]>;
-    /**
-     * Clear all entries
-     */
-    clear(): Promise<void>;
-    /**
-     * Get entry count
-     */
-    count(): Promise<number>;
-    /**
-     * Prune expired entries
-     */
-    prune(): Promise<number>;
-    /**
-     * Get health status
-     */
-    getHealthStatus(): Promise<{
-        healthy: boolean;
-        error?: string;
-        metrics?: Record<string, number>;
-    }>;
-}
-/**
- * Vector memory backend for similarity search
- */
-export interface IVectorMemoryBackend extends IMemoryBackend {
-    /**
-     * Store with embedding
-     */
-    storeVector(entry: IMemoryEntryCreate & {
-        embedding: number[];
-    }): Promise<IMemoryEntry>;
-    /**
-     * Search by vector similarity
-     */
-    search(params: IVectorSearchParams): Promise<IVectorSearchResult[]>;
-    /**
-     * Update embedding for an entry
-     */
-    updateEmbedding(key: string, embedding: number[]): Promise<boolean>;
-    /**
-     * Build or rebuild index
-     */
-    buildIndex(): Promise<void>;
-    /**
-     * Get index statistics
-     */
-    getIndexStats(): Promise<{
-        vectorCount: number;
-        dimensions: number;
-        indexType: string;
-        memoryUsageMb: number;
-    }>;
-}
-/**
- * Memory bank for agent-specific storage
- */
-export interface IMemoryBank {
-    readonly id: string;
-    readonly agentId: string;
-    readonly createdAt: Date;
-    /**
-     * Store in bank
-     */
-    store(key: string, value: unknown, options?: Partial<IMemoryEntryCreate>): Promise<IMemoryEntry>;
-    /**
-     * Retrieve from bank
-     */
-    retrieve(key: string): Promise<IMemoryEntry | undefined>;
-    /**
-     * Delete from bank
-     */
-    delete(key: string): Promise<boolean>;
-    /**
-     * List all entries in bank
-     */
-    list(): Promise<IMemoryEntry[]>;
-    /**
-     * Clear all entries in bank
-     */
-    clear(): Promise<void>;
-    /**
-     * Get bank size
-     */
-    size(): Promise<number>;
-    /**
-     * Close the bank
-     */
-    close(): Promise<void>;
-}
-/**
- * Memory manager interface
- */
-export interface IMemoryManager {
-    /**
-     * Initialize the manager
-     */
-    initialize(): Promise<void>;
-    /**
-     * Shutdown the manager
-     */
-    shutdown(): Promise<void>;
-    /**
-     * Create a memory bank for an agent
-     */
-    createBank(agentId: string): Promise<string>;
-    /**
-     * Get a memory bank
-     */
-    getBank(bankId: string): IMemoryBank | undefined;
-    /**
-     * Close a memory bank
-     */
-    closeBank(bankId: string): Promise<void>;
-    /**
-     * Store in global memory
-     */
-    store(entry: IMemoryEntryCreate): Promise<IMemoryEntry>;
-    /**
-     * Retrieve from global memory
-     */
-    retrieve(key: string): Promise<IMemoryEntry | undefined>;
-    /**
-     * Search vectors (if vector backend available)
-     */
-    searchVectors?(params: IVectorSearchParams): Promise<IVectorSearchResult[]>;
-    /**
-     * Perform maintenance
-     */
-    performMaintenance(): Promise<void>;
-    /**
-     * Get health status
-     */
-    getHealthStatus(): Promise<{
-        healthy: boolean;
-        error?: string;
-        metrics?: Record<string, number>;
-    }>;
-    /**
-     * Get memory usage statistics
-     */
-    getStats(): Promise<{
-        totalEntries: number;
-        memoryUsageMb: number;
-        banksCount: number;
-        cacheHitRate?: number;
-    }>;
-}
-/**
- * Pattern storage for ReasoningBank integration
- */
-export interface IPatternStorage {
-    /**
-     * Store a learned pattern
-     */
-    storePattern(pattern: {
-        sessionId: string;
-        task: string;
-        input: string;
-        output: string;
-        reward: number;
-        success: boolean;
-        critique?: string;
-        tokensUsed?: number;
-        latencyMs?: number;
-    }): Promise<void>;
-    /**
-     * Search for similar patterns
-     */
-    searchPatterns(params: {
-        task: string;
-        k?: number;
-        minReward?: number;
-        onlyFailures?: boolean;
-    }): Promise<Array<{
-        task: string;
-        reward: number;
-        critique: string;
-        output: string;
-    }>>;
-    /**
-     * Get pattern statistics
-     */
-    getPatternStats(): Promise<{
-        totalPatterns: number;
-        avgReward: number;
-        successRate: number;
-    }>;
-}
-//# sourceMappingURL=memory.interface.d.ts.map

package/src/@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