claude-flow 3.25.6 → 3.26.0

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

@@ -1,293 +0,0 @@
-/**
- * Event Store Tests
- *
- * Comprehensive tests for the event sourcing implementation.
- * Tests event storage, retrieval, filtering, snapshots, and projections.
- */
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { EventStore } from './event-store.js';
-import { AgentStateProjection, TaskHistoryProjection, MemoryIndexProjection } from './projections.js';
-import { createAgentSpawnedEvent, createAgentStartedEvent, createAgentTaskAssignedEvent, createAgentTaskCompletedEvent, createTaskCreatedEvent, createTaskStartedEvent, createTaskCompletedEvent, createMemoryStoredEvent, createMemoryRetrievedEvent, createMemoryDeletedEvent, } from './domain-events.js';
-describe('EventStore', () => {
-    let eventStore;
-    beforeEach(async () => {
-        eventStore = new EventStore({ databasePath: ':memory:', verbose: false });
-        await eventStore.initialize();
-    });
-    afterEach(async () => {
-        await eventStore.shutdown();
-    });
-    describe('Event Appending', () => {
-        it('should append events to the store', async () => {
-            const event = createAgentSpawnedEvent('agent-1', 'coder', 'core', ['coding', 'testing']);
-            await eventStore.append(event);
-            const events = await eventStore.getEvents('agent-1');
-            expect(events).toHaveLength(1);
-            expect(events[0].type).toBe('agent:spawned');
-            expect(events[0].version).toBe(1);
-        });
-        it('should increment version for each event', async () => {
-            const event1 = createAgentSpawnedEvent('agent-1', 'coder', 'core', []);
-            const event2 = createAgentStartedEvent('agent-1');
-            await eventStore.append(event1);
-            await eventStore.append(event2);
-            const events = await eventStore.getEvents('agent-1');
-            expect(events[0].version).toBe(1);
-            expect(events[1].version).toBe(2);
-        });
-        it('should maintain version per aggregate', async () => {
-            const agent1Event = createAgentSpawnedEvent('agent-1', 'coder', 'core', []);
-            const agent2Event = createAgentSpawnedEvent('agent-2', 'tester', 'quality', []);
-            await eventStore.append(agent1Event);
-            await eventStore.append(agent2Event);
-            const agent1Events = await eventStore.getEvents('agent-1');
-            const agent2Events = await eventStore.getEvents('agent-2');
-            expect(agent1Events[0].version).toBe(1);
-            expect(agent2Events[0].version).toBe(1);
-        });
-    });
-    describe('Event Retrieval', () => {
-        beforeEach(async () => {
-            // Setup: Create multiple events
-            await eventStore.append(createAgentSpawnedEvent('agent-1', 'coder', 'core', []));
-            await eventStore.append(createAgentStartedEvent('agent-1'));
-            await eventStore.append(createTaskCreatedEvent('task-1', 'implementation', 'Build feature', 'Description', 'high', []));
-            await eventStore.append(createTaskStartedEvent('task-1', 'agent-1'));
-        });
-        it('should retrieve events by aggregate ID', async () => {
-            const events = await eventStore.getEvents('agent-1');
-            expect(events).toHaveLength(2);
-            expect(events[0].type).toBe('agent:spawned');
-            expect(events[1].type).toBe('agent:started');
-        });
-        it('should retrieve events from specific version', async () => {
-            const events = await eventStore.getEvents('agent-1', 2);
-            expect(events).toHaveLength(1);
-            expect(events[0].type).toBe('agent:started');
-        });
-        it('should retrieve events by type', async () => {
-            const events = await eventStore.getEventsByType('task:created');
-            expect(events).toHaveLength(1);
-            expect(events[0].aggregateId).toBe('task-1');
-        });
-    });
-    describe('Event Filtering', () => {
-        beforeEach(async () => {
-            await eventStore.append(createAgentSpawnedEvent('agent-1', 'coder', 'core', []));
-            await eventStore.append(createAgentSpawnedEvent('agent-2', 'tester', 'quality', []));
-            await eventStore.append(createTaskCreatedEvent('task-1', 'implementation', 'Task 1', 'Desc', 'high', []));
-            await eventStore.append(createMemoryStoredEvent('mem-1', 'default', 'key1', 'semantic', 1024));
-        });
-        it('should filter by aggregate types', async () => {
-            const events = await eventStore.query({ aggregateTypes: ['agent'] });
-            expect(events).toHaveLength(2);
-            expect(events.every((e) => e.aggregateType === 'agent')).toBe(true);
-        });
-        it('should filter by event types', async () => {
-            const events = await eventStore.query({ eventTypes: ['agent:spawned'] });
-            expect(events).toHaveLength(2);
-            expect(events.every((e) => e.type === 'agent:spawned')).toBe(true);
-        });
-        it('should filter by aggregate IDs', async () => {
-            const events = await eventStore.query({ aggregateIds: ['agent-1', 'task-1'] });
-            expect(events).toHaveLength(2);
-        });
-        it('should support pagination', async () => {
-            const page1 = await eventStore.query({ limit: 2, offset: 0 });
-            const page2 = await eventStore.query({ limit: 2, offset: 2 });
-            expect(page1).toHaveLength(2);
-            expect(page2).toHaveLength(2);
-            expect(page1[0].id).not.toBe(page2[0].id);
-        });
-    });
-    describe('Event Replay', () => {
-        it('should replay all events', async () => {
-            await eventStore.append(createAgentSpawnedEvent('agent-1', 'coder', 'core', []));
-            await eventStore.append(createAgentStartedEvent('agent-1'));
-            await eventStore.append(createTaskCreatedEvent('task-1', 'implementation', 'Task', 'Desc', 'high', []));
-            const events = [];
-            for await (const event of eventStore.replay()) {
-                events.push(event);
-            }
-            expect(events).toHaveLength(3);
-        });
-        it('should replay from specific version', async () => {
-            await eventStore.append(createAgentSpawnedEvent('agent-1', 'coder', 'core', []));
-            await eventStore.append(createAgentStartedEvent('agent-1'));
-            await eventStore.append(createTaskCreatedEvent('task-1', 'implementation', 'Task', 'Desc', 'high', []));
-            const events = [];
-            for await (const event of eventStore.replay(2)) {
-                events.push(event);
-            }
-            expect(events.length).toBeGreaterThanOrEqual(2);
-        });
-    });
-    describe('Snapshots', () => {
-        it('should save snapshots', async () => {
-            const snapshot = {
-                aggregateId: 'agent-1',
-                aggregateType: 'agent',
-                version: 5,
-                state: { status: 'active', tasks: ['task-1'] },
-                timestamp: Date.now(),
-            };
-            await eventStore.saveSnapshot(snapshot);
-            const retrieved = await eventStore.getSnapshot('agent-1');
-            expect(retrieved).not.toBeNull();
-            expect(retrieved?.version).toBe(5);
-            expect(retrieved?.state).toEqual({ status: 'active', tasks: ['task-1'] });
-        });
-        it('should return latest snapshot', async () => {
-            const snapshot1 = {
-                aggregateId: 'agent-1',
-                aggregateType: 'agent',
-                version: 5,
-                state: { status: 'active' },
-                timestamp: Date.now(),
-            };
-            const snapshot2 = {
-                aggregateId: 'agent-1',
-                aggregateType: 'agent',
-                version: 10,
-                state: { status: 'completed' },
-                timestamp: Date.now(),
-            };
-            await eventStore.saveSnapshot(snapshot1);
-            await eventStore.saveSnapshot(snapshot2);
-            const retrieved = await eventStore.getSnapshot('agent-1');
-            expect(retrieved?.version).toBe(10);
-        });
-    });
-    describe('Statistics', () => {
-        it('should provide event store statistics', async () => {
-            await eventStore.append(createAgentSpawnedEvent('agent-1', 'coder', 'core', []));
-            await eventStore.append(createAgentSpawnedEvent('agent-2', 'tester', 'quality', []));
-            await eventStore.append(createTaskCreatedEvent('task-1', 'implementation', 'Task', 'Desc', 'high', []));
-            const stats = await eventStore.getStats();
-            expect(stats.totalEvents).toBe(3);
-            expect(stats.eventsByType['agent:spawned']).toBe(2);
-            expect(stats.eventsByType['task:created']).toBe(1);
-            expect(stats.eventsByAggregate['agent-1']).toBe(1);
-            expect(stats.eventsByAggregate['agent-2']).toBe(1);
-        });
-    });
-});
-describe('AgentStateProjection', () => {
-    let eventStore;
-    let projection;
-    beforeEach(async () => {
-        eventStore = new EventStore({ databasePath: ':memory:' });
-        await eventStore.initialize();
-        projection = new AgentStateProjection(eventStore);
-    });
-    afterEach(async () => {
-        await eventStore.shutdown();
-    });
-    it('should build agent state from events', async () => {
-        await eventStore.append(createAgentSpawnedEvent('agent-1', 'coder', 'core', ['coding']));
-        await eventStore.append(createAgentStartedEvent('agent-1'));
-        await projection.initialize();
-        const agent = projection.getAgent('agent-1');
-        expect(agent).not.toBeNull();
-        expect(agent?.role).toBe('coder');
-        expect(agent?.status).toBe('active');
-    });
-    it('should track task assignments', async () => {
-        await eventStore.append(createAgentSpawnedEvent('agent-1', 'coder', 'core', []));
-        await eventStore.append(createAgentTaskAssignedEvent('agent-1', 'task-1', Date.now()));
-        await projection.initialize();
-        const agent = projection.getAgent('agent-1');
-        expect(agent?.currentTask).toBe('task-1');
-    });
-    it('should track completed tasks', async () => {
-        await eventStore.append(createAgentSpawnedEvent('agent-1', 'coder', 'core', []));
-        await eventStore.append(createAgentTaskCompletedEvent('agent-1', 'task-1', { success: true }, Date.now(), 5000));
-        await projection.initialize();
-        const agent = projection.getAgent('agent-1');
-        expect(agent?.completedTasks).toContain('task-1');
-        expect(agent?.taskCount).toBe(1);
-    });
-    it('should filter agents by status', async () => {
-        await eventStore.append(createAgentSpawnedEvent('agent-1', 'coder', 'core', []));
-        await eventStore.append(createAgentSpawnedEvent('agent-2', 'tester', 'quality', []));
-        await eventStore.append(createAgentStartedEvent('agent-1'));
-        await projection.initialize();
-        const activeAgents = projection.getAgentsByStatus('active');
-        const idleAgents = projection.getAgentsByStatus('idle');
-        expect(activeAgents).toHaveLength(1);
-        expect(idleAgents).toHaveLength(1);
-    });
-});
-describe('TaskHistoryProjection', () => {
-    let eventStore;
-    let projection;
-    beforeEach(async () => {
-        eventStore = new EventStore({ databasePath: ':memory:' });
-        await eventStore.initialize();
-        projection = new TaskHistoryProjection(eventStore);
-    });
-    afterEach(async () => {
-        await eventStore.shutdown();
-    });
-    it('should build task history from events', async () => {
-        await eventStore.append(createTaskCreatedEvent('task-1', 'implementation', 'Build Feature', 'Description', 'high', []));
-        await eventStore.append(createTaskStartedEvent('task-1', 'agent-1'));
-        await eventStore.append(createTaskCompletedEvent('task-1', { success: true }, 5000));
-        await projection.initialize();
-        const task = projection.getTask('task-1');
-        expect(task).not.toBeNull();
-        expect(task?.title).toBe('Build Feature');
-        expect(task?.status).toBe('completed');
-        expect(task?.assignedAgent).toBe('agent-1');
-    });
-    it('should calculate average task duration', async () => {
-        await eventStore.append(createTaskCreatedEvent('task-1', 'implementation', 'Task 1', 'Desc', 'high', []));
-        await eventStore.append(createTaskCompletedEvent('task-1', { success: true }, 5000));
-        await eventStore.append(createTaskCreatedEvent('task-2', 'implementation', 'Task 2', 'Desc', 'high', []));
-        await eventStore.append(createTaskCompletedEvent('task-2', { success: true }, 3000));
-        await projection.initialize();
-        const avgDuration = projection.getAverageTaskDuration();
-        expect(avgDuration).toBe(4000);
-    });
-});
-describe('MemoryIndexProjection', () => {
-    let eventStore;
-    let projection;
-    beforeEach(async () => {
-        eventStore = new EventStore({ databasePath: ':memory:' });
-        await eventStore.initialize();
-        projection = new MemoryIndexProjection(eventStore);
-    });
-    afterEach(async () => {
-        await eventStore.shutdown();
-    });
-    it('should build memory index from events', async () => {
-        await eventStore.append(createMemoryStoredEvent('mem-1', 'default', 'key1', 'semantic', 1024));
-        await eventStore.append(createMemoryRetrievedEvent('mem-1', 'default', 'key1', 1));
-        await projection.initialize();
-        const memory = projection.getMemory('mem-1');
-        expect(memory).not.toBeNull();
-        expect(memory?.namespace).toBe('default');
-        expect(memory?.accessCount).toBe(1);
-    });
-    it('should track memory deletions', async () => {
-        await eventStore.append(createMemoryStoredEvent('mem-1', 'default', 'key1', 'semantic', 1024));
-        await eventStore.append(createMemoryDeletedEvent('mem-1', 'default', 'key1'));
-        await projection.initialize();
-        const memory = projection.getMemory('mem-1');
-        expect(memory?.isDeleted).toBe(true);
-        const activeMemories = projection.getActiveMemories();
-        expect(activeMemories).toHaveLength(0);
-    });
-    it('should calculate total size by namespace', async () => {
-        await eventStore.append(createMemoryStoredEvent('mem-1', 'ns1', 'key1', 'semantic', 1024));
-        await eventStore.append(createMemoryStoredEvent('mem-2', 'ns1', 'key2', 'semantic', 2048));
-        await eventStore.append(createMemoryStoredEvent('mem-3', 'ns2', 'key3', 'semantic', 512));
-        await projection.initialize();
-        const ns1Size = projection.getTotalSizeByNamespace('ns1');
-        const ns2Size = projection.getTotalSizeByNamespace('ns2');
-        expect(ns1Size).toBe(3072);
-        expect(ns2Size).toBe(512);
-    });
-});
-//# sourceMappingURL=event-store.test.js.map

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

@@ -1,10 +0,0 @@
-/**
- * Event Store Usage Example
- *
- * Demonstrates how to use the Event Sourcing system in V3 Claude Flow.
- *
- * Usage:
- *   npx tsx v3/@claude-flow/shared/src/events/example-usage.ts
- */
-export {};
-//# sourceMappingURL=example-usage.d.ts.map

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

@@ -1,193 +0,0 @@
-/**
- * Event Store Usage Example
- *
- * Demonstrates how to use the Event Sourcing system in V3 Claude Flow.
- *
- * Usage:
- *   npx tsx v3/@claude-flow/shared/src/events/example-usage.ts
- */
-import { EventStore } from './event-store.js';
-import { AgentStateProjection, TaskHistoryProjection, MemoryIndexProjection } from './projections.js';
-import { createAgentSpawnedEvent, createAgentStartedEvent, createAgentTaskAssignedEvent, createAgentTaskCompletedEvent, createTaskCreatedEvent, createTaskStartedEvent, createTaskCompletedEvent, createMemoryStoredEvent, createMemoryRetrievedEvent, createSwarmInitializedEvent, createSwarmScaledEvent, } from './domain-events.js';
-async function main() {
-    console.log('Event Sourcing Example - V3 Claude Flow\n');
-    // =========================================================================
-    // 1. Initialize Event Store
-    // =========================================================================
-    console.log('1. Initializing Event Store...');
-    const eventStore = new EventStore({
-        databasePath: './event-store-example.db',
-        verbose: true,
-        autoPersistInterval: 0, // Manual persist for demo
-    });
-    await eventStore.initialize();
-    console.log('   Event Store initialized\n');
-    // =========================================================================
-    // 2. Record Swarm Initialization Events
-    // =========================================================================
-    console.log('2. Recording Swarm Events...');
-    await eventStore.append(createSwarmInitializedEvent('hierarchical-mesh', 15, {
-        security: { strict: true },
-        memory: { backend: 'agentdb' },
-    }));
-    await eventStore.append(createSwarmScaledEvent(0, 5, 'Initial agent spawn'));
-    console.log('   Swarm events recorded\n');
-    // =========================================================================
-    // 3. Record Agent Lifecycle Events
-    // =========================================================================
-    console.log('3. Recording Agent Lifecycle Events...');
-    // Agent 1: Queen Coordinator
-    await eventStore.append(createAgentSpawnedEvent('agent-1', 'queen-coordinator', 'coordination', [
-        'orchestration',
-        'task-assignment',
-    ]));
-    await eventStore.append(createAgentStartedEvent('agent-1'));
-    // Agent 2: Security Architect
-    await eventStore.append(createAgentSpawnedEvent('agent-2', 'security-architect', 'security', [
-        'threat-modeling',
-        'security-design',
-    ]));
-    await eventStore.append(createAgentStartedEvent('agent-2'));
-    // Agent 3: Core Architect
-    await eventStore.append(createAgentSpawnedEvent('agent-3', 'core-architect', 'core', ['ddd-design', 'architecture']));
-    await eventStore.append(createAgentStartedEvent('agent-3'));
-    console.log('   Agent events recorded\n');
-    // =========================================================================
-    // 4. Record Task Execution Events
-    // =========================================================================
-    console.log('4. Recording Task Execution Events...');
-    // Task 1: Security Audit
-    await eventStore.append(createTaskCreatedEvent('task-1', 'security-audit', 'Audit CVE-1 (Command Injection)', 'Review and fix command injection vulnerability', 'critical', []));
-    await eventStore.append(createTaskStartedEvent('task-1', 'agent-2'));
-    await eventStore.append(createAgentTaskAssignedEvent('agent-2', 'task-1', Date.now()));
-    // Example: Async work gap between task start and completion
-    await new Promise((resolve) => setTimeout(resolve, 100));
-    await eventStore.append(createTaskCompletedEvent('task-1', { vulnerabilitiesFixed: 3, severity: 'high' }, 5234));
-    await eventStore.append(createAgentTaskCompletedEvent('agent-2', 'task-1', { success: true }, Date.now(), 5234));
-    // Task 2: DDD Architecture Design
-    await eventStore.append(createTaskCreatedEvent('task-2', 'architecture-design', 'Design V3 Domain Structure', 'Implement bounded contexts for V3', 'high', []));
-    await eventStore.append(createTaskStartedEvent('task-2', 'agent-3'));
-    await eventStore.append(createAgentTaskAssignedEvent('agent-3', 'task-2', Date.now()));
-    console.log('   Task events recorded\n');
-    // =========================================================================
-    // 5. Record Memory Operations Events
-    // =========================================================================
-    console.log('5. Recording Memory Operations Events...');
-    await eventStore.append(createMemoryStoredEvent('mem-1', 'agent-context', 'agent-2-state', 'episodic', 2048));
-    await eventStore.append(createMemoryStoredEvent('mem-2', 'task-results', 'task-1-result', 'semantic', 1024));
-    await eventStore.append(createMemoryRetrievedEvent('mem-1', 'agent-context', 'agent-2-state', 1));
-    await eventStore.append(createMemoryRetrievedEvent('mem-1', 'agent-context', 'agent-2-state', 2));
-    console.log('   Memory events recorded\n');
-    // =========================================================================
-    // 6. Query Events
-    // =========================================================================
-    console.log('6. Querying Events...\n');
-    const allAgentEvents = await eventStore.query({ aggregateTypes: ['agent'] });
-    console.log(`   Total agent events: ${allAgentEvents.length}`);
-    const allTaskEvents = await eventStore.query({ aggregateTypes: ['task'] });
-    console.log(`   Total task events: ${allTaskEvents.length}`);
-    const completedTaskEvents = await eventStore.getEventsByType('task:completed');
-    console.log(`   Completed task events: ${completedTaskEvents.length}`);
-    console.log();
-    // =========================================================================
-    // 7. Build Projections
-    // =========================================================================
-    console.log('7. Building Projections...\n');
-    // Agent State Projection
-    const agentProjection = new AgentStateProjection(eventStore);
-    await agentProjection.initialize();
-    console.log('   Agent State Projection:');
-    const allAgents = agentProjection.getAllAgents();
-    for (const agent of allAgents) {
-        console.log(`     - ${agent.id}: ${agent.role} (${agent.status})`);
-        console.log(`       Tasks completed: ${agent.completedTasks.length}`);
-        console.log(`       Avg duration: ${agent.taskCount > 0 ? agent.totalTaskDuration / agent.taskCount : 0}ms`);
-    }
-    const activeAgents = agentProjection.getActiveAgentCount();
-    console.log(`\n   Active agents: ${activeAgents}`);
-    // Task History Projection
-    const taskProjection = new TaskHistoryProjection(eventStore);
-    await taskProjection.initialize();
-    console.log('\n   Task History Projection:');
-    const allTasks = taskProjection.getAllTasks();
-    for (const task of allTasks) {
-        console.log(`     - ${task.id}: ${task.title} (${task.status})`);
-        console.log(`       Assigned to: ${task.assignedAgent || 'unassigned'}`);
-        console.log(`       Duration: ${task.duration || 'N/A'}ms`);
-    }
-    const avgTaskDuration = taskProjection.getAverageTaskDuration();
-    console.log(`\n   Average task duration: ${avgTaskDuration.toFixed(2)}ms`);
-    // Memory Index Projection
-    const memoryProjection = new MemoryIndexProjection(eventStore);
-    await memoryProjection.initialize();
-    console.log('\n   Memory Index Projection:');
-    const activeMemories = memoryProjection.getActiveMemories();
-    for (const memory of activeMemories) {
-        console.log(`     - ${memory.id}: ${memory.namespace}/${memory.key}`);
-        console.log(`       Size: ${memory.size} bytes, Accessed: ${memory.accessCount} times`);
-    }
-    const totalSize = activeMemories.reduce((sum, m) => sum + m.size, 0);
-    console.log(`\n   Total memory used: ${totalSize} bytes`);
-    // =========================================================================
-    // 8. Event Replay
-    // =========================================================================
-    console.log('\n8. Event Replay Example...\n');
-    let replayCount = 0;
-    for await (const event of eventStore.replay(0)) {
-        replayCount++;
-        if (replayCount <= 3) {
-            console.log(`   Replaying: ${event.type} (v${event.version})`);
-        }
-    }
-    console.log(`   Total events replayed: ${replayCount}`);
-    // =========================================================================
-    // 9. Snapshots
-    // =========================================================================
-    console.log('\n9. Snapshot Example...\n');
-    const agent2State = agentProjection.getAgent('agent-2');
-    if (agent2State) {
-        await eventStore.saveSnapshot({
-            aggregateId: 'agent-2',
-            aggregateType: 'agent',
-            version: 5,
-            state: agent2State,
-            timestamp: Date.now(),
-        });
-        console.log('   Snapshot saved for agent-2');
-        const snapshot = await eventStore.getSnapshot('agent-2');
-        console.log(`   Snapshot retrieved: version ${snapshot?.version}`);
-    }
-    // =========================================================================
-    // 10. Statistics
-    // =========================================================================
-    console.log('\n10. Event Store Statistics...\n');
-    const stats = await eventStore.getStats();
-    console.log(`   Total events: ${stats.totalEvents}`);
-    console.log(`   Events by type:`);
-    for (const [type, count] of Object.entries(stats.eventsByType)) {
-        console.log(`     - ${type}: ${count}`);
-    }
-    console.log(`\n   Events by aggregate:`);
-    const topAggregates = Object.entries(stats.eventsByAggregate)
-        .sort(([, a], [, b]) => b - a)
-        .slice(0, 5);
-    for (const [aggregate, count] of topAggregates) {
-        console.log(`     - ${aggregate}: ${count}`);
-    }
-    console.log(`\n   Snapshots: ${stats.snapshotCount}`);
-    // =========================================================================
-    // Cleanup
-    // =========================================================================
-    console.log('\n11. Persisting and Shutting Down...\n');
-    await eventStore.persist();
-    await eventStore.shutdown();
-    console.log('   Event Store shutdown complete');
-    console.log('\nExample completed successfully!');
-    console.log('Database saved to: ./event-store-example.db');
-}
-// Run the example
-main().catch((error) => {
-    console.error('Error running example:', error);
-    process.exit(1);
-});
-//# sourceMappingURL=example-usage.js.map

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

@@ -1,21 +0,0 @@
-/**
- * Event Sourcing System (ADR-007)
- *
- * Complete event sourcing implementation for V3 Claude Flow:
- * - Domain events for all aggregates (agent, task, memory, swarm)
- * - Persistent event store with SQLite backend
- * - Projections for building read models
- * - Event replay and snapshots
- *
- * @module v3/shared/events
- */
-export type { DomainEvent, AllDomainEvents, AgentSpawnedEvent, AgentStartedEvent, AgentStoppedEvent, AgentFailedEvent, AgentStatusChangedEvent, AgentTaskAssignedEvent, AgentTaskCompletedEvent, TaskCreatedEvent, TaskStartedEvent, TaskCompletedEvent, TaskFailedEvent, TaskBlockedEvent, TaskQueuedEvent, MemoryStoredEvent, MemoryRetrievedEvent, MemoryDeletedEvent, MemoryExpiredEvent, SwarmInitializedEvent, SwarmScaledEvent, SwarmTerminatedEvent, SwarmPhaseChangedEvent, SwarmMilestoneReachedEvent, SwarmErrorEvent, } from './domain-events.js';
-export { createAgentSpawnedEvent, createAgentStartedEvent, createAgentStoppedEvent, createAgentFailedEvent, createTaskCreatedEvent, createTaskStartedEvent, createTaskCompletedEvent, createTaskFailedEvent, createMemoryStoredEvent, createMemoryRetrievedEvent, createMemoryDeletedEvent, createSwarmInitializedEvent, createSwarmScaledEvent, createSwarmTerminatedEvent, } from './domain-events.js';
-export { EventStore } from './event-store.js';
-export type { EventStoreConfig, EventFilter, EventSnapshot, EventStoreStats, } from './event-store.js';
-export { Projection, AgentStateProjection, TaskHistoryProjection, MemoryIndexProjection, } from './projections.js';
-export type { AgentProjectionState, TaskProjectionState, MemoryProjectionState, } from './projections.js';
-export { RvfEventLog } from './rvf-event-log.js';
-export type { RvfEventLogConfig } from './rvf-event-log.js';
-export { StateReconstructor, createStateReconstructor, AgentAggregate, TaskAggregate, type AggregateRoot, type ReconstructorOptions, } from './state-reconstructor.js';
-//# sourceMappingURL=index.d.ts.map

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

@@ -1,22 +0,0 @@
-/**
- * Event Sourcing System (ADR-007)
- *
- * Complete event sourcing implementation for V3 Claude Flow:
- * - Domain events for all aggregates (agent, task, memory, swarm)
- * - Persistent event store with SQLite backend
- * - Projections for building read models
- * - Event replay and snapshots
- *
- * @module v3/shared/events
- */
-// Domain Event Factory Functions
-export { createAgentSpawnedEvent, createAgentStartedEvent, createAgentStoppedEvent, createAgentFailedEvent, createTaskCreatedEvent, createTaskStartedEvent, createTaskCompletedEvent, createTaskFailedEvent, createMemoryStoredEvent, createMemoryRetrievedEvent, createMemoryDeletedEvent, createSwarmInitializedEvent, createSwarmScaledEvent, createSwarmTerminatedEvent, } from './domain-events.js';
-// Event Store
-export { EventStore } from './event-store.js';
-// Projections
-export { Projection, AgentStateProjection, TaskHistoryProjection, MemoryIndexProjection, } from './projections.js';
-// RVF Event Log (ADR-057 — zero-dependency alternative to EventStore)
-export { RvfEventLog } from './rvf-event-log.js';
-// State Reconstruction (ADR-007)
-export { StateReconstructor, createStateReconstructor, AgentAggregate, TaskAggregate, } from './state-reconstructor.js';
-//# sourceMappingURL=index.js.map