claude-flow 3.25.6 → 3.26.1

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

@@ -1,80 +0,0 @@
-/**
- * V3 Event Bus System
- * Event-driven communication for the 15-agent swarm
- *
- * Based on ADR-007 (Event Sourcing for State Changes)
- */
-import { EventType, EventHandler, SwarmEvent, AgentId } from './types.js';
-export interface IEventBus {
-    subscribe<T>(eventType: EventType, handler: EventHandler<T>): () => void;
-    subscribeAll(handler: EventHandler): () => void;
-    emit<T>(event: SwarmEvent<T>): Promise<void>;
-    emitSync<T>(event: SwarmEvent<T>): void;
-    getHistory(filter?: EventFilter): SwarmEvent[];
-    clear(): void;
-}
-export interface EventFilter {
-    types?: EventType[];
-    sources?: (AgentId | 'swarm')[];
-    since?: number;
-    until?: number;
-    limit?: number;
-}
-export interface IEventStore {
-    append(event: SwarmEvent): Promise<void>;
-    getEvents(aggregateId: string, fromVersion?: number): Promise<SwarmEvent[]>;
-    getAllEvents(filter?: EventFilter): Promise<SwarmEvent[]>;
-    getSnapshot(aggregateId: string): Promise<EventStoreSnapshot | null>;
-    saveSnapshot(snapshot: EventStoreSnapshot): Promise<void>;
-}
-export interface EventStoreSnapshot {
-    aggregateId: string;
-    version: number;
-    state: unknown;
-    timestamp: number;
-}
-export declare class EventBus implements IEventBus {
-    private handlers;
-    private history;
-    private maxHistorySize;
-    constructor(options?: {
-        maxHistorySize?: number;
-    });
-    subscribe<T>(eventType: EventType, handler: EventHandler<T>): () => void;
-    subscribeAll(handler: EventHandler): () => void;
-    emit<T>(event: SwarmEvent<T>): Promise<void>;
-    emitSync<T>(event: SwarmEvent<T>): void;
-    getHistory(filter?: EventFilter): SwarmEvent[];
-    clear(): void;
-    private addToHistory;
-    private safeExecute;
-}
-export declare class InMemoryEventStore implements IEventStore {
-    private events;
-    private allEvents;
-    private snapshots;
-    append(event: SwarmEvent): Promise<void>;
-    getEvents(aggregateId: string, fromVersion?: number): Promise<SwarmEvent[]>;
-    getAllEvents(filter?: EventFilter): Promise<SwarmEvent[]>;
-    getSnapshot(aggregateId: string): Promise<EventStoreSnapshot | null>;
-    saveSnapshot(snapshot: EventStoreSnapshot): Promise<void>;
-    private extractAggregateId;
-}
-export declare function createEvent<T>(type: EventType, source: AgentId | 'swarm', payload: T): SwarmEvent<T>;
-export declare function agentSpawnedEvent(agentId: AgentId, role: string): SwarmEvent;
-export declare function agentStatusChangedEvent(agentId: AgentId, previousStatus: string, newStatus: string): SwarmEvent;
-export declare function agentTaskAssignedEvent(agentId: AgentId, taskId: string): SwarmEvent;
-export declare function agentTaskCompletedEvent(agentId: AgentId, taskId: string, result: unknown): SwarmEvent;
-export declare function agentErrorEvent(agentId: AgentId, error: Error): SwarmEvent;
-export declare function taskCreatedEvent(taskId: string, type: string, title: string): SwarmEvent;
-export declare function taskQueuedEvent(taskId: string, priority: string): SwarmEvent;
-export declare function taskAssignedEvent(taskId: string, agentId: AgentId): SwarmEvent;
-export declare function taskStartedEvent(taskId: string, agentId: AgentId): SwarmEvent;
-export declare function taskCompletedEvent(taskId: string, result: unknown): SwarmEvent;
-export declare function taskFailedEvent(taskId: string, error: Error): SwarmEvent;
-export declare function taskBlockedEvent(taskId: string, blockedBy: string[]): SwarmEvent;
-export declare function swarmInitializedEvent(config: unknown): SwarmEvent;
-export declare function swarmPhaseChangedEvent(previousPhase: string, newPhase: string): SwarmEvent;
-export declare function swarmMilestoneReachedEvent(milestoneId: string, name: string): SwarmEvent;
-export declare function swarmErrorEvent(error: Error): SwarmEvent;
-//# sourceMappingURL=events.d.ts.map

package/v3/@claude-flow/shared/dist/events.js

@@ -1,249 +0,0 @@
-/**
- * V3 Event Bus System
- * Event-driven communication for the 15-agent swarm
- *
- * Based on ADR-007 (Event Sourcing for State Changes)
- */
-// =============================================================================
-// Event Bus Implementation
-// =============================================================================
-export class EventBus {
-    handlers = new Map();
-    history = [];
-    maxHistorySize;
-    constructor(options = {}) {
-        this.maxHistorySize = options.maxHistorySize ?? 10000;
-    }
-    subscribe(eventType, handler) {
-        if (!this.handlers.has(eventType)) {
-            this.handlers.set(eventType, new Set());
-        }
-        const handlers = this.handlers.get(eventType);
-        handlers.add(handler);
-        return () => {
-            handlers.delete(handler);
-        };
-    }
-    subscribeAll(handler) {
-        if (!this.handlers.has('*')) {
-            this.handlers.set('*', new Set());
-        }
-        const handlers = this.handlers.get('*');
-        handlers.add(handler);
-        return () => {
-            handlers.delete(handler);
-        };
-    }
-    async emit(event) {
-        this.addToHistory(event);
-        const typeHandlers = this.handlers.get(event.type) ?? new Set();
-        const allHandlers = this.handlers.get('*') ?? new Set();
-        const allPromises = [];
-        for (const handler of typeHandlers) {
-            allPromises.push(this.safeExecute(handler, event));
-        }
-        for (const handler of allHandlers) {
-            allPromises.push(this.safeExecute(handler, event));
-        }
-        await Promise.all(allPromises);
-    }
-    emitSync(event) {
-        this.addToHistory(event);
-        const typeHandlers = this.handlers.get(event.type) ?? new Set();
-        const allHandlers = this.handlers.get('*') ?? new Set();
-        for (const handler of typeHandlers) {
-            try {
-                const result = handler(event);
-                if (result instanceof Promise) {
-                    result.catch(err => console.error(`Event handler error: ${err}`));
-                }
-            }
-            catch (err) {
-                console.error(`Event handler error: ${err}`);
-            }
-        }
-        for (const handler of allHandlers) {
-            try {
-                const result = handler(event);
-                if (result instanceof Promise) {
-                    result.catch(err => console.error(`Event handler error: ${err}`));
-                }
-            }
-            catch (err) {
-                console.error(`Event handler error: ${err}`);
-            }
-        }
-    }
-    getHistory(filter) {
-        let events = [...this.history];
-        if (filter?.types?.length) {
-            events = events.filter(e => filter.types.includes(e.type));
-        }
-        if (filter?.sources?.length) {
-            events = events.filter(e => filter.sources.includes(e.source));
-        }
-        if (filter?.since) {
-            events = events.filter(e => e.timestamp >= filter.since);
-        }
-        if (filter?.until) {
-            events = events.filter(e => e.timestamp <= filter.until);
-        }
-        if (filter?.limit) {
-            events = events.slice(-filter.limit);
-        }
-        return events;
-    }
-    clear() {
-        this.history = [];
-    }
-    addToHistory(event) {
-        this.history.push(event);
-        if (this.history.length > this.maxHistorySize) {
-            this.history = this.history.slice(-Math.floor(this.maxHistorySize / 2));
-        }
-    }
-    async safeExecute(handler, event) {
-        try {
-            await handler(event);
-        }
-        catch (err) {
-            console.error(`Event handler error for ${event.type}: ${err}`);
-        }
-    }
-}
-// =============================================================================
-// In-Memory Event Store
-// =============================================================================
-export class InMemoryEventStore {
-    events = new Map();
-    allEvents = [];
-    snapshots = new Map();
-    async append(event) {
-        const aggregateId = this.extractAggregateId(event);
-        if (!this.events.has(aggregateId)) {
-            this.events.set(aggregateId, []);
-        }
-        this.events.get(aggregateId).push(event);
-        this.allEvents.push(event);
-    }
-    async getEvents(aggregateId, fromVersion) {
-        const events = this.events.get(aggregateId) ?? [];
-        if (fromVersion !== undefined) {
-            return events.slice(fromVersion);
-        }
-        return events;
-    }
-    async getAllEvents(filter) {
-        let events = [...this.allEvents];
-        if (filter?.types?.length) {
-            events = events.filter(e => filter.types.includes(e.type));
-        }
-        if (filter?.sources?.length) {
-            events = events.filter(e => filter.sources.includes(e.source));
-        }
-        if (filter?.since) {
-            events = events.filter(e => e.timestamp >= filter.since);
-        }
-        if (filter?.until) {
-            events = events.filter(e => e.timestamp <= filter.until);
-        }
-        if (filter?.limit) {
-            events = events.slice(-filter.limit);
-        }
-        return events;
-    }
-    async getSnapshot(aggregateId) {
-        return this.snapshots.get(aggregateId) ?? null;
-    }
-    async saveSnapshot(snapshot) {
-        this.snapshots.set(snapshot.aggregateId, snapshot);
-    }
-    extractAggregateId(event) {
-        if (event.source !== 'swarm') {
-            return event.source;
-        }
-        if (typeof event.payload === 'object' && event.payload !== null) {
-            const payload = event.payload;
-            if ('agentId' in payload)
-                return payload.agentId;
-            if ('taskId' in payload)
-                return payload.taskId;
-        }
-        return 'swarm';
-    }
-}
-// =============================================================================
-// Event Factory Functions
-// =============================================================================
-let eventCounter = 0;
-export function createEvent(type, source, payload) {
-    return {
-        id: `evt-${Date.now()}-${++eventCounter}`,
-        type,
-        timestamp: Date.now(),
-        source,
-        payload
-    };
-}
-// Agent Events
-export function agentSpawnedEvent(agentId, role) {
-    return createEvent('agent:spawned', 'swarm', { agentId, role });
-}
-export function agentStatusChangedEvent(agentId, previousStatus, newStatus) {
-    return createEvent('agent:status-changed', agentId, { previousStatus, newStatus });
-}
-export function agentTaskAssignedEvent(agentId, taskId) {
-    return createEvent('agent:task-assigned', 'swarm', { agentId, taskId });
-}
-export function agentTaskCompletedEvent(agentId, taskId, result) {
-    return createEvent('agent:task-completed', agentId, { taskId, result });
-}
-export function agentErrorEvent(agentId, error) {
-    return createEvent('agent:error', agentId, {
-        message: error.message,
-        stack: error.stack
-    });
-}
-// Task Events
-export function taskCreatedEvent(taskId, type, title) {
-    return createEvent('task:created', 'swarm', { taskId, type, title });
-}
-export function taskQueuedEvent(taskId, priority) {
-    return createEvent('task:queued', 'swarm', { taskId, priority });
-}
-export function taskAssignedEvent(taskId, agentId) {
-    return createEvent('task:assigned', 'swarm', { taskId, agentId });
-}
-export function taskStartedEvent(taskId, agentId) {
-    return createEvent('task:started', agentId, { taskId });
-}
-export function taskCompletedEvent(taskId, result) {
-    return createEvent('task:completed', 'swarm', { taskId, result });
-}
-export function taskFailedEvent(taskId, error) {
-    return createEvent('task:failed', 'swarm', {
-        taskId,
-        error: error.message,
-        stack: error.stack
-    });
-}
-export function taskBlockedEvent(taskId, blockedBy) {
-    return createEvent('task:blocked', 'swarm', { taskId, blockedBy });
-}
-// Swarm Events
-export function swarmInitializedEvent(config) {
-    return createEvent('swarm:initialized', 'swarm', { config });
-}
-export function swarmPhaseChangedEvent(previousPhase, newPhase) {
-    return createEvent('swarm:phase-changed', 'swarm', { previousPhase, newPhase });
-}
-export function swarmMilestoneReachedEvent(milestoneId, name) {
-    return createEvent('swarm:milestone-reached', 'swarm', { milestoneId, name });
-}
-export function swarmErrorEvent(error) {
-    return createEvent('swarm:error', 'swarm', {
-        message: error.message,
-        stack: error.stack
-    });
-}
-//# sourceMappingURL=events.js.map

package/v3/@claude-flow/shared/dist/hooks/example-usage.d.ts

@@ -1,42 +0,0 @@
-/**
- * V3 Hooks System - Example Usage
- *
- * Demonstrates practical use cases for the hooks system.
- *
- * @module v3/shared/hooks/example-usage
- */
-export declare function setupSecurityHooks(): {
-    registry: import("./registry.js").HookRegistry;
-    executor: import("./executor.js").HookExecutor;
-};
-export declare function setupLearningHooks(): {
-    registry: import("./registry.js").HookRegistry;
-    executor: import("./executor.js").HookExecutor;
-};
-export declare function setupPerformanceHooks(): {
-    registry: import("./registry.js").HookRegistry;
-    executor: import("./executor.js").HookExecutor;
-    performanceMetrics: Map<string, {
-        start: number;
-        end?: number;
-    }>;
-};
-export declare function setupFileValidationHooks(): {
-    registry: import("./registry.js").HookRegistry;
-    executor: import("./executor.js").HookExecutor;
-};
-export declare function setupSessionHooks(): {
-    registry: import("./registry.js").HookRegistry;
-    executor: import("./executor.js").HookExecutor;
-};
-export declare function setupErrorHooks(): {
-    registry: import("./registry.js").HookRegistry;
-    executor: import("./executor.js").HookExecutor;
-    errorLog: {
-        timestamp: Date;
-        error: Error;
-        context?: string;
-    }[];
-};
-export declare function runDemo(): Promise<void>;
-//# sourceMappingURL=example-usage.d.ts.map