claude-flow 3.25.6 → 3.26.0

package/v3/@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/v3/@claude-flow/shared/dist/events/projections.js

@@ -1,421 +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';
-// =============================================================================
-// Projection Base Class
-// =============================================================================
-export class Projection extends EventEmitter {
-    eventStore;
-    initialized = false;
-    constructor(eventStore) {
-        super();
-        this.eventStore = eventStore;
-    }
-    /**
-     * Initialize the projection by replaying events
-     */
-    async initialize() {
-        if (this.initialized)
-            return;
-        // Replay all events to build current state
-        for await (const event of this.eventStore.replay()) {
-            await this.handle(event);
-        }
-        this.initialized = true;
-        this.emit('initialized');
-    }
-}
-export class AgentStateProjection extends Projection {
-    agents = new Map();
-    /**
-     * Get state for a specific agent
-     */
-    getAgent(agentId) {
-        return this.agents.get(agentId) || null;
-    }
-    /**
-     * Get all agents
-     */
-    getAllAgents() {
-        return Array.from(this.agents.values());
-    }
-    /**
-     * Get agents by status
-     */
-    getAgentsByStatus(status) {
-        return this.getAllAgents().filter((agent) => agent.status === status);
-    }
-    /**
-     * Get agents by domain
-     */
-    getAgentsByDomain(domain) {
-        return this.getAllAgents().filter((agent) => agent.domain === domain);
-    }
-    /**
-     * Get active agent count
-     */
-    getActiveAgentCount() {
-        return this.getAgentsByStatus('active').length;
-    }
-    async handle(event) {
-        switch (event.type) {
-            case 'agent:spawned':
-                this.handleAgentSpawned(event);
-                break;
-            case 'agent:started':
-                this.handleAgentStarted(event);
-                break;
-            case 'agent:stopped':
-                this.handleAgentStopped(event);
-                break;
-            case 'agent:failed':
-                this.handleAgentFailed(event);
-                break;
-            case 'agent:status-changed':
-                this.handleAgentStatusChanged(event);
-                break;
-            case 'agent:task-assigned':
-                this.handleAgentTaskAssigned(event);
-                break;
-            case 'agent:task-completed':
-                this.handleAgentTaskCompleted(event);
-                break;
-        }
-    }
-    reset() {
-        this.agents.clear();
-        this.emit('reset');
-    }
-    handleAgentSpawned(event) {
-        const { agentId, role, domain } = event.payload;
-        this.agents.set(agentId, {
-            id: agentId,
-            role: role,
-            domain: domain,
-            status: 'idle',
-            currentTask: null,
-            completedTasks: [],
-            failedTasks: [],
-            totalTaskDuration: 0,
-            taskCount: 0,
-            errorCount: 0,
-            spawnedAt: event.timestamp,
-            startedAt: null,
-            stoppedAt: null,
-            lastActivityAt: event.timestamp,
-        });
-        this.emit('agent:spawned', { agentId });
-    }
-    handleAgentStarted(event) {
-        const { agentId } = event.payload;
-        const agent = this.agents.get(agentId);
-        if (agent) {
-            agent.status = 'active';
-            agent.startedAt = event.timestamp;
-            agent.lastActivityAt = event.timestamp;
-            this.emit('agent:started', { agentId });
-        }
-    }
-    handleAgentStopped(event) {
-        const { agentId } = event.payload;
-        const agent = this.agents.get(agentId);
-        if (agent) {
-            agent.status = 'completed';
-            agent.stoppedAt = event.timestamp;
-            agent.lastActivityAt = event.timestamp;
-            this.emit('agent:stopped', { agentId });
-        }
-    }
-    handleAgentFailed(event) {
-        const { agentId } = event.payload;
-        const agent = this.agents.get(agentId);
-        if (agent) {
-            agent.status = 'error';
-            agent.errorCount++;
-            agent.lastActivityAt = event.timestamp;
-            this.emit('agent:failed', { agentId });
-        }
-    }
-    handleAgentStatusChanged(event) {
-        const { agentId, newStatus } = event.payload;
-        const agent = this.agents.get(agentId);
-        if (agent) {
-            agent.status = newStatus;
-            agent.lastActivityAt = event.timestamp;
-            this.emit('agent:status-changed', { agentId, status: newStatus });
-        }
-    }
-    handleAgentTaskAssigned(event) {
-        const { agentId, taskId } = event.payload;
-        const agent = this.agents.get(agentId);
-        if (agent) {
-            agent.currentTask = taskId;
-            agent.status = 'active';
-            agent.lastActivityAt = event.timestamp;
-            this.emit('agent:task-assigned', { agentId, taskId });
-        }
-    }
-    handleAgentTaskCompleted(event) {
-        const { agentId, taskId, duration } = event.payload;
-        const agent = this.agents.get(agentId);
-        if (agent) {
-            agent.completedTasks.push(taskId);
-            agent.currentTask = null;
-            agent.taskCount++;
-            agent.totalTaskDuration += duration || 0;
-            agent.status = 'idle';
-            agent.lastActivityAt = event.timestamp;
-            this.emit('agent:task-completed', { agentId, taskId });
-        }
-    }
-}
-export class TaskHistoryProjection extends Projection {
-    tasks = new Map();
-    /**
-     * Get task by ID
-     */
-    getTask(taskId) {
-        return this.tasks.get(taskId) || null;
-    }
-    /**
-     * Get all tasks
-     */
-    getAllTasks() {
-        return Array.from(this.tasks.values());
-    }
-    /**
-     * Get tasks by status
-     */
-    getTasksByStatus(status) {
-        return this.getAllTasks().filter((task) => task.status === status);
-    }
-    /**
-     * Get tasks by agent
-     */
-    getTasksByAgent(agentId) {
-        return this.getAllTasks().filter((task) => task.assignedAgent === agentId);
-    }
-    /**
-     * Get completed task count
-     */
-    getCompletedTaskCount() {
-        return this.getTasksByStatus('completed').length;
-    }
-    /**
-     * Get average task duration
-     */
-    getAverageTaskDuration() {
-        const completed = this.getTasksByStatus('completed').filter((t) => t.duration !== null);
-        if (completed.length === 0)
-            return 0;
-        const total = completed.reduce((sum, task) => sum + (task.duration || 0), 0);
-        return total / completed.length;
-    }
-    async handle(event) {
-        switch (event.type) {
-            case 'task:created':
-                this.handleTaskCreated(event);
-                break;
-            case 'task:queued':
-                this.handleTaskQueued(event);
-                break;
-            case 'task:started':
-                this.handleTaskStarted(event);
-                break;
-            case 'task:completed':
-                this.handleTaskCompleted(event);
-                break;
-            case 'task:failed':
-                this.handleTaskFailed(event);
-                break;
-            case 'task:blocked':
-                this.handleTaskBlocked(event);
-                break;
-        }
-    }
-    reset() {
-        this.tasks.clear();
-        this.emit('reset');
-    }
-    handleTaskCreated(event) {
-        const { taskId, taskType, title, priority, dependencies } = event.payload;
-        this.tasks.set(taskId, {
-            id: taskId,
-            type: taskType,
-            title: title,
-            status: 'pending',
-            priority: priority,
-            assignedAgent: null,
-            dependencies: dependencies || [],
-            blockedBy: [],
-            createdAt: event.timestamp,
-            startedAt: null,
-            completedAt: null,
-            failedAt: null,
-            duration: null,
-            result: null,
-            error: null,
-            retryCount: 0,
-        });
-        this.emit('task:created', { taskId });
-    }
-    handleTaskQueued(event) {
-        const { taskId } = event.payload;
-        const task = this.tasks.get(taskId);
-        if (task) {
-            task.status = 'queued';
-            this.emit('task:queued', { taskId });
-        }
-    }
-    handleTaskStarted(event) {
-        const { taskId, agentId } = event.payload;
-        const task = this.tasks.get(taskId);
-        if (task) {
-            task.status = 'in-progress';
-            task.assignedAgent = agentId;
-            task.startedAt = event.timestamp;
-            this.emit('task:started', { taskId, agentId });
-        }
-    }
-    handleTaskCompleted(event) {
-        const { taskId, result, duration } = event.payload;
-        const task = this.tasks.get(taskId);
-        if (task) {
-            task.status = 'completed';
-            task.completedAt = event.timestamp;
-            task.duration = duration || (task.startedAt ? event.timestamp - task.startedAt : null);
-            task.result = result;
-            this.emit('task:completed', { taskId });
-        }
-    }
-    handleTaskFailed(event) {
-        const { taskId, error, retryCount } = event.payload;
-        const task = this.tasks.get(taskId);
-        if (task) {
-            task.status = 'failed';
-            task.failedAt = event.timestamp;
-            task.error = error;
-            task.retryCount = retryCount;
-            this.emit('task:failed', { taskId });
-        }
-    }
-    handleTaskBlocked(event) {
-        const { taskId, blockedBy } = event.payload;
-        const task = this.tasks.get(taskId);
-        if (task) {
-            task.status = 'blocked';
-            task.blockedBy = blockedBy;
-            this.emit('task:blocked', { taskId, blockedBy });
-        }
-    }
-}
-export class MemoryIndexProjection extends Projection {
-    memories = new Map();
-    /**
-     * Get memory by ID
-     */
-    getMemory(memoryId) {
-        return this.memories.get(memoryId) || null;
-    }
-    /**
-     * Get all active memories (not deleted)
-     */
-    getActiveMemories() {
-        return Array.from(this.memories.values()).filter((m) => !m.isDeleted);
-    }
-    /**
-     * Get memories by namespace
-     */
-    getMemoriesByNamespace(namespace) {
-        return this.getActiveMemories().filter((m) => m.namespace === namespace);
-    }
-    /**
-     * Get most accessed memories
-     */
-    getMostAccessedMemories(limit = 10) {
-        return this.getActiveMemories()
-            .sort((a, b) => b.accessCount - a.accessCount)
-            .slice(0, limit);
-    }
-    /**
-     * Get total memory size by namespace
-     */
-    getTotalSizeByNamespace(namespace) {
-        return this.getMemoriesByNamespace(namespace).reduce((sum, m) => sum + m.size, 0);
-    }
-    async handle(event) {
-        switch (event.type) {
-            case 'memory:stored':
-                this.handleMemoryStored(event);
-                break;
-            case 'memory:retrieved':
-                this.handleMemoryRetrieved(event);
-                break;
-            case 'memory:deleted':
-                this.handleMemoryDeleted(event);
-                break;
-            case 'memory:expired':
-                this.handleMemoryExpired(event);
-                break;
-        }
-    }
-    reset() {
-        this.memories.clear();
-        this.emit('reset');
-    }
-    handleMemoryStored(event) {
-        const { memoryId, namespace, key, memoryType, size } = event.payload;
-        this.memories.set(memoryId, {
-            id: memoryId,
-            namespace: namespace,
-            key: key,
-            type: memoryType,
-            size: size || 0,
-            accessCount: 0,
-            storedAt: event.timestamp,
-            lastAccessedAt: event.timestamp,
-            deletedAt: null,
-            isDeleted: false,
-        });
-        this.emit('memory:stored', { memoryId });
-    }
-    handleMemoryRetrieved(event) {
-        const { memoryId, accessCount } = event.payload;
-        const memory = this.memories.get(memoryId);
-        if (memory && !memory.isDeleted) {
-            memory.accessCount = accessCount;
-            memory.lastAccessedAt = event.timestamp;
-            this.emit('memory:retrieved', { memoryId });
-        }
-    }
-    handleMemoryDeleted(event) {
-        const { memoryId } = event.payload;
-        const memory = this.memories.get(memoryId);
-        if (memory) {
-            memory.isDeleted = true;
-            memory.deletedAt = event.timestamp;
-            this.emit('memory:deleted', { memoryId });
-        }
-    }
-    handleMemoryExpired(event) {
-        const { memoryId } = event.payload;
-        const memory = this.memories.get(memoryId);
-        if (memory) {
-            memory.isDeleted = true;
-            memory.deletedAt = event.timestamp;
-            this.emit('memory:expired', { memoryId });
-        }
-    }
-}
-//# sourceMappingURL=projections.js.map

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