moflo 4.8.31 → 4.8.32

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

@@ -1,126 +0,0 @@
-/**
- * Event Store Persistence (ADR-007)
- *
- * Provides persistent storage for domain events using SQLite.
- * Supports event replay, snapshots, and projections.
- *
- * Key Features:
- * - Append-only event log
- * - Event versioning per aggregate
- * - Event filtering and queries
- * - Snapshot support for performance
- * - Event replay for projections
- * - Cross-platform SQLite (sql.js fallback)
- *
- * @module v3/shared/events/event-store
- */
-import { EventEmitter } from 'node:events';
-import { DomainEvent } from './domain-events.js';
-export interface EventStoreConfig {
-    /** Path to SQLite database file (:memory: for in-memory) */
-    databasePath: string;
-    /** Enable verbose logging */
-    verbose: boolean;
-    /** Auto-persist interval in milliseconds (0 = manual only) */
-    autoPersistInterval: number;
-    /** Maximum events before snapshot recommendation */
-    snapshotThreshold: number;
-    /** Path to sql.js WASM file (optional) */
-    wasmPath?: string;
-}
-export interface EventFilter {
-    /** Filter by aggregate IDs */
-    aggregateIds?: string[];
-    /** Filter by aggregate types */
-    aggregateTypes?: Array<'agent' | 'task' | 'memory' | 'swarm'>;
-    /** Filter by event types */
-    eventTypes?: string[];
-    /** Filter events after timestamp */
-    afterTimestamp?: number;
-    /** Filter events before timestamp */
-    beforeTimestamp?: number;
-    /** Filter by minimum version */
-    fromVersion?: number;
-    /** Limit number of results */
-    limit?: number;
-    /** Offset for pagination */
-    offset?: number;
-}
-export interface EventSnapshot {
-    /** Aggregate ID */
-    aggregateId: string;
-    /** Aggregate type */
-    aggregateType: 'agent' | 'task' | 'memory' | 'swarm';
-    /** Version at snapshot */
-    version: number;
-    /** Snapshot state */
-    state: Record<string, unknown>;
-    /** Timestamp when snapshot was created */
-    timestamp: number;
-}
-export interface EventStoreStats {
-    totalEvents: number;
-    eventsByType: Record<string, number>;
-    eventsByAggregate: Record<string, number>;
-    oldestEvent: number | null;
-    newestEvent: number | null;
-    snapshotCount: number;
-}
-export declare class EventStore extends EventEmitter {
-    private config;
-    private db;
-    private initialized;
-    private persistTimer;
-    private SQL;
-    private aggregateVersions;
-    constructor(config?: Partial<EventStoreConfig>);
-    /**
-     * Initialize the event store
-     */
-    initialize(): Promise<void>;
-    /**
-     * Shutdown the event store
-     */
-    shutdown(): Promise<void>;
-    /**
-     * Append a new event to the store
-     */
-    append(event: DomainEvent): Promise<void>;
-    /**
-     * Get events for a specific aggregate
-     */
-    getEvents(aggregateId: string, fromVersion?: number): Promise<DomainEvent[]>;
-    /**
-     * Get events by type
-     */
-    getEventsByType(type: string): Promise<DomainEvent[]>;
-    /**
-     * Query events with filters
-     */
-    query(filter: EventFilter): Promise<DomainEvent[]>;
-    /**
-     * Replay events from a specific version
-     */
-    replay(fromVersion?: number): AsyncIterable<DomainEvent>;
-    /**
-     * Save a snapshot for an aggregate
-     */
-    saveSnapshot(snapshot: EventSnapshot): Promise<void>;
-    /**
-     * Get snapshot for an aggregate
-     */
-    getSnapshot(aggregateId: string): Promise<EventSnapshot | null>;
-    /**
-     * Get event store statistics
-     */
-    getStats(): Promise<EventStoreStats>;
-    /**
-     * Persist to disk
-     */
-    persist(): Promise<void>;
-    private createSchema;
-    private loadAggregateVersions;
-    private rowToEvent;
-    private ensureInitialized;
-}
-//# sourceMappingURL=event-store.d.ts.map

package/src/@claude-flow/shared/dist/events/event-store.test.d.ts

@@ -1,8 +0,0 @@
-/**
- * Event Store Tests
- *
- * Comprehensive tests for the event sourcing implementation.
- * Tests event storage, retrieval, filtering, snapshots, and projections.
- */
-export {};
-//# sourceMappingURL=event-store.test.d.ts.map

package/src/@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/src/@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/src/@claude-flow/shared/dist/events/projections.d.ts

@@ -1,177 +0,0 @@
-/**
- * Event Projections for Read Models (ADR-007)
- *
- * Build read models from domain events using projections.
- * Projections listen to events and maintain queryable state.
- *
- * Implemented Projections:
- * - AgentStateProjection - Current state of all agents
- * - TaskHistoryProjection - Complete task execution history
- * - MemoryIndexProjection - Memory access patterns and index
- *
- * @module v3/shared/events/projections
- */
-import { EventEmitter } from 'node:events';
-import { DomainEvent } from './domain-events.js';
-import { EventStore } from './event-store.js';
-import { AgentId, TaskId, AgentStatus, TaskStatus } from '../types.js';
-export declare abstract class Projection extends EventEmitter {
-    protected eventStore: EventStore;
-    protected initialized: boolean;
-    constructor(eventStore: EventStore);
-    /**
-     * Initialize the projection by replaying events
-     */
-    initialize(): Promise<void>;
-    /**
-     * Handle a domain event
-     */
-    abstract handle(event: DomainEvent): Promise<void>;
-    /**
-     * Reset the projection state
-     */
-    abstract reset(): void;
-}
-export interface AgentProjectionState {
-    id: AgentId;
-    role: string;
-    domain: string;
-    status: AgentStatus;
-    currentTask: TaskId | null;
-    completedTasks: TaskId[];
-    failedTasks: TaskId[];
-    totalTaskDuration: number;
-    taskCount: number;
-    errorCount: number;
-    spawnedAt: number;
-    startedAt: number | null;
-    stoppedAt: number | null;
-    lastActivityAt: number;
-}
-export declare class AgentStateProjection extends Projection {
-    private agents;
-    /**
-     * Get state for a specific agent
-     */
-    getAgent(agentId: AgentId): AgentProjectionState | null;
-    /**
-     * Get all agents
-     */
-    getAllAgents(): AgentProjectionState[];
-    /**
-     * Get agents by status
-     */
-    getAgentsByStatus(status: AgentStatus): AgentProjectionState[];
-    /**
-     * Get agents by domain
-     */
-    getAgentsByDomain(domain: string): AgentProjectionState[];
-    /**
-     * Get active agent count
-     */
-    getActiveAgentCount(): number;
-    handle(event: DomainEvent): Promise<void>;
-    reset(): void;
-    private handleAgentSpawned;
-    private handleAgentStarted;
-    private handleAgentStopped;
-    private handleAgentFailed;
-    private handleAgentStatusChanged;
-    private handleAgentTaskAssigned;
-    private handleAgentTaskCompleted;
-}
-export interface TaskProjectionState {
-    id: TaskId;
-    type: string;
-    title: string;
-    status: TaskStatus;
-    priority: string;
-    assignedAgent: AgentId | null;
-    dependencies: TaskId[];
-    blockedBy: TaskId[];
-    createdAt: number;
-    startedAt: number | null;
-    completedAt: number | null;
-    failedAt: number | null;
-    duration: number | null;
-    result: unknown;
-    error: string | null;
-    retryCount: number;
-}
-export declare class TaskHistoryProjection extends Projection {
-    private tasks;
-    /**
-     * Get task by ID
-     */
-    getTask(taskId: TaskId): TaskProjectionState | null;
-    /**
-     * Get all tasks
-     */
-    getAllTasks(): TaskProjectionState[];
-    /**
-     * Get tasks by status
-     */
-    getTasksByStatus(status: TaskStatus): TaskProjectionState[];
-    /**
-     * Get tasks by agent
-     */
-    getTasksByAgent(agentId: AgentId): TaskProjectionState[];
-    /**
-     * Get completed task count
-     */
-    getCompletedTaskCount(): number;
-    /**
-     * Get average task duration
-     */
-    getAverageTaskDuration(): number;
-    handle(event: DomainEvent): Promise<void>;
-    reset(): void;
-    private handleTaskCreated;
-    private handleTaskQueued;
-    private handleTaskStarted;
-    private handleTaskCompleted;
-    private handleTaskFailed;
-    private handleTaskBlocked;
-}
-export interface MemoryProjectionState {
-    id: string;
-    namespace: string;
-    key: string;
-    type: string;
-    size: number;
-    accessCount: number;
-    storedAt: number;
-    lastAccessedAt: number;
-    deletedAt: number | null;
-    isDeleted: boolean;
-}
-export declare class MemoryIndexProjection extends Projection {
-    private memories;
-    /**
-     * Get memory by ID
-     */
-    getMemory(memoryId: string): MemoryProjectionState | null;
-    /**
-     * Get all active memories (not deleted)
-     */
-    getActiveMemories(): MemoryProjectionState[];
-    /**
-     * Get memories by namespace
-     */
-    getMemoriesByNamespace(namespace: string): MemoryProjectionState[];
-    /**
-     * Get most accessed memories
-     */
-    getMostAccessedMemories(limit?: number): MemoryProjectionState[];
-    /**
-     * Get total memory size by namespace
-     */
-    getTotalSizeByNamespace(namespace: string): number;
-    handle(event: DomainEvent): Promise<void>;
-    reset(): void;
-    private handleMemoryStored;
-    private handleMemoryRetrieved;
-    private handleMemoryDeleted;
-    private handleMemoryExpired;
-}
-//# sourceMappingURL=projections.d.ts.map

package/src/@claude-flow/shared/dist/events/rvf-event-log.d.ts

@@ -1,82 +0,0 @@
-/**
- * RVF Event Log (ADR-057 Phase 2)
- *
- * Pure-TypeScript append-only event log that stores events in a binary
- * file format. Replaces the sql.js-dependent EventStore with a zero-
- * dependency alternative.
- *
- * Binary format:
- *   File header:  4 bytes — magic "RVFL"
- *   Record:       4 bytes (uint32 BE payload length) + N bytes (JSON payload)
- *
- * In-memory indexes are rebuilt on initialize() by replaying the file.
- * Snapshots are stored in a separate `.snap.rvf` file using the same format.
- *
- * @module v3/shared/events/rvf-event-log
- */
-import { EventEmitter } from 'node:events';
-import type { DomainEvent } from './domain-events.js';
-import type { EventFilter, EventSnapshot, EventStoreStats } from './event-store.js';
-export interface RvfEventLogConfig {
-    /** Path to event log file */
-    logPath: string;
-    /** Enable verbose logging */
-    verbose?: boolean;
-    /** Maximum events before snapshot recommendation */
-    snapshotThreshold?: number;
-}
-export declare class RvfEventLog extends EventEmitter {
-    private config;
-    private initialized;
-    /**
-     * All events kept in insertion order.
-     * Rebuilt from the file on initialize().
-     */
-    private events;
-    /** Fast lookup: aggregateId -> indices into this.events */
-    private aggregateIndex;
-    /** Version tracking per aggregate */
-    private aggregateVersions;
-    /** Snapshots keyed by aggregateId (latest wins) */
-    private snapshots;
-    /** Path to the companion snapshot file */
-    private snapshotPath;
-    constructor(config?: Partial<RvfEventLogConfig>);
-    /** Create / open the log file and rebuild in-memory indexes. */
-    initialize(): Promise<void>;
-    /** Flush to disk and release resources. */
-    close(): Promise<void>;
-    /** Append a domain event to the log. */
-    append(event: DomainEvent): Promise<void>;
-    /** Save a snapshot for an aggregate. */
-    saveSnapshot(snapshot: EventSnapshot): Promise<void>;
-    /** Get events for a specific aggregate, optionally from a version. */
-    getEvents(aggregateId: string, fromVersion?: number): Promise<DomainEvent[]>;
-    /** Query events with an optional filter (matches EventStore.query API). */
-    getAllEvents(filter?: EventFilter): Promise<DomainEvent[]>;
-    /** Get latest snapshot for an aggregate. */
-    getSnapshot(aggregateId: string): Promise<EventSnapshot | null>;
-    /** Return event store statistics. */
-    getStats(): Promise<EventStoreStats>;
-    /**
-     * Flush to disk.
-     * For the append-only log this is a no-op because every append() call
-     * writes to disk synchronously. Provided for API compatibility with
-     * EventStore.
-     */
-    persist(): Promise<void>;
-    /**
-     * Replay an RVF file and invoke `handler` for every decoded record.
-     * Used both for events and snapshots.
-     */
-    private replayFile;
-    /** Append a single record to an RVF file. */
-    private appendRecord;
-    /** Add an event to the in-memory indexes. */
-    private indexEvent;
-    /** Ensure parent directory exists for a file path. */
-    private ensureDirectory;
-    /** Guard that throws if initialize() has not been called. */
-    private ensureInitialized;
-}
-//# sourceMappingURL=rvf-event-log.d.ts.map

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

@@ -1,101 +0,0 @@
-/**
- * State Reconstructor - ADR-007 Implementation
- *
- * Reconstructs aggregate state from event streams.
- * Implements event sourcing patterns for V3.
- *
- * @module v3/shared/events/state-reconstructor
- */
-import { EventStore } from './event-store.js';
-import type { DomainEvent } from './domain-events.js';
-/**
- * Aggregate root interface
- */
-export interface AggregateRoot {
-    id: string;
-    version: number;
-    apply(event: DomainEvent): void;
-    getState(): Record<string, unknown>;
-}
-/**
- * Reconstructor options
- */
-export interface ReconstructorOptions {
-    useSnapshots: boolean;
-    snapshotInterval: number;
-    maxEventsToReplay: number;
-}
-/**
- * State Reconstructor
- *
- * Reconstructs aggregate state from event history.
- * Supports snapshots for performance optimization.
- */
-export declare class StateReconstructor {
-    private readonly eventStore;
-    private readonly options;
-    constructor(eventStore: EventStore, options?: Partial<ReconstructorOptions>);
-    /**
-     * Reconstruct aggregate state from events
-     */
-    reconstruct<T extends AggregateRoot>(aggregateId: string, factory: (id: string) => T): Promise<T>;
-    /**
-     * Reconstruct state at a specific point in time
-     */
-    reconstructAtTime<T extends AggregateRoot>(aggregateId: string, factory: (id: string) => T, timestamp: Date): Promise<T>;
-    /**
-     * Reconstruct state at a specific version
-     */
-    reconstructAtVersion<T extends AggregateRoot>(aggregateId: string, factory: (id: string) => T, targetVersion: number): Promise<T>;
-    /**
-     * Apply snapshot to aggregate
-     */
-    private applySnapshot;
-    /**
-     * Create snapshot for aggregate
-     */
-    private createSnapshot;
-    /**
-     * Get aggregate type from instance
-     */
-    private getAggregateType;
-}
-/**
- * Agent Aggregate - Example implementation
- */
-export declare class AgentAggregate implements AggregateRoot {
-    id: string;
-    version: number;
-    private state;
-    constructor(id: string);
-    apply(event: DomainEvent): void;
-    getState(): Record<string, unknown>;
-    restoreFromSnapshot(snapshotState: unknown): void;
-    get name(): string;
-    get role(): string;
-    get status(): string;
-    get currentTask(): string | null;
-    get completedTasks(): string[];
-    get capabilities(): string[];
-}
-/**
- * Task Aggregate - Example implementation
- */
-export declare class TaskAggregate implements AggregateRoot {
-    id: string;
-    version: number;
-    private state;
-    constructor(id: string);
-    apply(event: DomainEvent): void;
-    getState(): Record<string, unknown>;
-    restoreFromSnapshot(snapshotState: unknown): void;
-    get title(): string;
-    get status(): string;
-    get assignedAgent(): string | null;
-    get result(): unknown;
-}
-/**
- * Factory function
- */
-export declare function createStateReconstructor(eventStore: EventStore, options?: Partial<ReconstructorOptions>): StateReconstructor;
-//# sourceMappingURL=state-reconstructor.d.ts.map

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