snow-flow 3.0.8 → 3.0.10

package/dist/coordination/shared-memory.js

@@ -1,289 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SharedMemoryManager = void 0;
-const eventemitter3_1 = require("eventemitter3");
-const logger_1 = require("../utils/logger");
-class SharedMemoryManager extends eventemitter3_1.EventEmitter {
-    constructor(ttl = 3600000) {
-        super();
-        this.memory = new Map();
-        this.subscribers = new Map();
-        this.versionCounters = new Map();
-        this.accessLogs = new Map();
-        this.ttl = ttl;
-        // Start cleanup interval every 5 minutes
-        this.cleanupInterval = setInterval(() => {
-            this.cleanupExpiredEntries();
-        }, 300000);
-        logger_1.logger.info('🧠 Shared Memory Manager initialized', { ttl });
-    }
-    async store(key, value, notifySubscribers = true) {
-        try {
-            const version = this.getNextVersion(key);
-            const memoryValue = {
-                value,
-                timestamp: Date.now(),
-                version,
-                metadata: {
-                    size: this.calculateSize(value),
-                    type: typeof value,
-                    lastAccess: Date.now()
-                }
-            };
-            this.memory.set(key, memoryValue);
-            // Log access
-            this.logAccess(key, 'write', value);
-            logger_1.logger.debug('💾 Stored value in shared memory', {
-                key,
-                version,
-                size: memoryValue.metadata?.size
-            });
-            if (notifySubscribers) {
-                await this.notifySubscribers(key, value, version);
-            }
-            this.emit('memory:stored', { key, value, version });
-        }
-        catch (error) {
-            logger_1.logger.error('❌ Failed to store in shared memory', { key, error: error.message });
-            throw error;
-        }
-    }
-    async get(key) {
-        try {
-            const entry = this.memory.get(key);
-            if (!entry) {
-                logger_1.logger.debug('🔍 Key not found in shared memory', { key });
-                return undefined;
-            }
-            // Check if expired
-            if (this.isExpired(entry)) {
-                this.memory.delete(key);
-                logger_1.logger.debug('⏰ Expired entry removed from shared memory', { key });
-                return undefined;
-            }
-            // Update last access
-            entry.metadata = {
-                ...entry.metadata,
-                lastAccess: Date.now()
-            };
-            // Log access
-            this.logAccess(key, 'read', entry.value);
-            logger_1.logger.debug('📖 Retrieved value from shared memory', {
-                key,
-                version: entry.version
-            });
-            return entry.value;
-        }
-        catch (error) {
-            logger_1.logger.error('❌ Failed to get from shared memory', { key, error: error.message });
-            throw error;
-        }
-    }
-    async subscribe(key, agent, callback) {
-        try {
-            if (!this.subscribers.has(key)) {
-                this.subscribers.set(key, new Set());
-            }
-            const subscriber = { agent, callback };
-            this.subscribers.get(key).add(subscriber);
-            logger_1.logger.info('📡 Agent subscribed to memory key', {
-                agentId: agent.id,
-                key
-            });
-            this.emit('memory:subscribed', { agentId: agent.id, key });
-        }
-        catch (error) {
-            logger_1.logger.error('❌ Failed to subscribe to shared memory', { key, agentId: agent.id, error: error.message });
-            throw error;
-        }
-    }
-    async unsubscribe(key, agent) {
-        const subscribers = this.subscribers.get(key);
-        if (subscribers) {
-            const toRemove = Array.from(subscribers).find(sub => sub.agent.id === agent.id);
-            if (toRemove) {
-                subscribers.delete(toRemove);
-                logger_1.logger.info('📡 Agent unsubscribed from memory key', {
-                    agentId: agent.id,
-                    key
-                });
-            }
-        }
-    }
-    async getHistory(key, limit = 10) {
-        const accessLogs = this.accessLogs.get(key) || [];
-        return accessLogs
-            .filter(log => log.operation === 'write')
-            .slice(-limit)
-            .map(log => ({
-            value: log.value,
-            timestamp: log.timestamp,
-            version: log.version || 1,
-            metadata: log.metadata
-        }));
-    }
-    async getKeys(pattern) {
-        const keys = Array.from(this.memory.keys());
-        if (pattern) {
-            const regex = new RegExp(pattern);
-            return keys.filter(key => regex.test(key));
-        }
-        return keys;
-    }
-    async delete(key) {
-        try {
-            const existed = this.memory.has(key);
-            this.memory.delete(key);
-            this.subscribers.delete(key);
-            this.versionCounters.delete(key);
-            this.accessLogs.delete(key);
-            if (existed) {
-                logger_1.logger.info('🗑️ Deleted key from shared memory', { key });
-                this.emit('memory:deleted', { key });
-            }
-            return existed;
-        }
-        catch (error) {
-            logger_1.logger.error('❌ Failed to delete from shared memory', { key, error: error.message });
-            throw error;
-        }
-    }
-    async clear() {
-        try {
-            const keyCount = this.memory.size;
-            this.memory.clear();
-            this.subscribers.clear();
-            this.versionCounters.clear();
-            this.accessLogs.clear();
-            logger_1.logger.info('🧹 Cleared all shared memory', { deletedKeys: keyCount });
-            this.emit('memory:cleared', { deletedKeys: keyCount });
-        }
-        catch (error) {
-            logger_1.logger.error('❌ Failed to clear shared memory', { error: error.message });
-            throw error;
-        }
-    }
-    async getStats() {
-        const totalEntries = this.memory.size;
-        const totalSize = Array.from(this.memory.values())
-            .reduce((sum, entry) => sum + (entry.metadata?.size || 0), 0);
-        const subscriberCount = Array.from(this.subscribers.values())
-            .reduce((sum, subs) => sum + subs.size, 0);
-        const oldestEntry = Array.from(this.memory.values())
-            .reduce((oldest, entry) => !oldest || entry.timestamp < oldest.timestamp ? entry : oldest);
-        return {
-            totalEntries,
-            totalSize,
-            subscriberCount,
-            oldestEntryAge: oldestEntry ? Date.now() - oldestEntry.timestamp : 0,
-            averageEntrySize: totalEntries > 0 ? totalSize / totalEntries : 0
-        };
-    }
-    async compareAndSwap(key, expectedValue, newValue) {
-        try {
-            const currentEntry = this.memory.get(key);
-            if (!currentEntry) {
-                return false;
-            }
-            if (JSON.stringify(currentEntry.value) === JSON.stringify(expectedValue)) {
-                await this.store(key, newValue);
-                return true;
-            }
-            return false;
-        }
-        catch (error) {
-            logger_1.logger.error('❌ Compare and swap failed', { key, error: error.message });
-            return false;
-        }
-    }
-    async atomicUpdate(key, updateFunction) {
-        try {
-            const currentValue = await this.get(key);
-            const newValue = updateFunction(currentValue);
-            await this.store(key, newValue);
-            return newValue;
-        }
-        catch (error) {
-            logger_1.logger.error('❌ Atomic update failed', { key, error: error.message });
-            throw error;
-        }
-    }
-    getNextVersion(key) {
-        const current = this.versionCounters.get(key) || 0;
-        const next = current + 1;
-        this.versionCounters.set(key, next);
-        return next;
-    }
-    async notifySubscribers(key, value, version) {
-        const subscribers = this.subscribers.get(key);
-        if (!subscribers || subscribers.size === 0) {
-            return;
-        }
-        const notifications = Array.from(subscribers).map(async (sub) => {
-            try {
-                await sub.callback(key, value, version);
-            }
-            catch (error) {
-                logger_1.logger.error('❌ Subscriber notification failed', {
-                    agentId: sub.agent.id,
-                    key,
-                    error: error.message
-                });
-            }
-        });
-        await Promise.allSettled(notifications);
-    }
-    logAccess(key, operation, value) {
-        if (!this.accessLogs.has(key)) {
-            this.accessLogs.set(key, []);
-        }
-        const logs = this.accessLogs.get(key);
-        logs.push({
-            timestamp: Date.now(),
-            operation,
-            value: operation === 'write' ? value : undefined,
-            version: this.versionCounters.get(key),
-            metadata: {
-                size: this.calculateSize(value)
-            }
-        });
-        // Keep only last 100 access logs per key
-        if (logs.length > 100) {
-            logs.splice(0, logs.length - 100);
-        }
-    }
-    calculateSize(value) {
-        try {
-            return new Blob([JSON.stringify(value)]).size;
-        }
-        catch {
-            return 0;
-        }
-    }
-    isExpired(entry) {
-        return Date.now() - entry.timestamp > this.ttl;
-    }
-    cleanupExpiredEntries() {
-        const expiredKeys = [];
-        for (const [key, entry] of this.memory.entries()) {
-            if (this.isExpired(entry)) {
-                expiredKeys.push(key);
-            }
-        }
-        for (const key of expiredKeys) {
-            this.delete(key);
-        }
-        if (expiredKeys.length > 0) {
-            logger_1.logger.info('🧹 Cleaned up expired memory entries', { count: expiredKeys.length });
-        }
-    }
-    destroy() {
-        if (this.cleanupInterval) {
-            clearInterval(this.cleanupInterval);
-        }
-        this.clear();
-        this.removeAllListeners();
-    }
-}
-exports.SharedMemoryManager = SharedMemoryManager;
-//# sourceMappingURL=shared-memory.js.map

package/dist/coordination/task-dependencies.d.ts

@@ -1,50 +0,0 @@
-import { EventEmitter } from 'eventemitter3';
-import { TaskNode, TaskRequirements, ExecutionPlan, CoordinationConfig } from './types';
-import { SnowAgent } from '../types/snow-flow.types';
-import { SharedMemoryManager } from './shared-memory';
-export declare class TaskDependencyGraph extends EventEmitter {
-    private nodes;
-    private edges;
-    private reverseEdges;
-    private sharedMemory;
-    private config;
-    private executionStartTime?;
-    constructor(sharedMemory: SharedMemoryManager, config: CoordinationConfig);
-    addTask(taskId: string, agent: SnowAgent, requirements: TaskRequirements, dependencies?: string[]): void;
-    getReadyTasks(): Promise<TaskNode[]>;
-    areDependenciesComplete(taskId: string): Promise<boolean>;
-    executeTask(taskId: string): Promise<any>;
-    private executeTaskWithRetry;
-    private executeAgentTask;
-    private simulateAgentExecution;
-    private scheduleRetry;
-    private handleTaskFailure;
-    private markDependentTasksAsSkipped;
-    getDependencyResults(taskId: string): Promise<Record<string, any>>;
-    topologicalSort(): Promise<string[][]>;
-    validateGraph(): Promise<void>;
-    generateExecutionPlan(): Promise<ExecutionPlan>;
-    private estimatePhaseDuration;
-    private findCriticalPath;
-    private getTopologicalLevels;
-    private findParallelizationOpportunities;
-    getTotalTasks(): number;
-    getCompletedTasks(): TaskNode[];
-    getFailedTasks(): TaskNode[];
-    getInProgressTasks(): TaskNode[];
-    getPendingTasks(): TaskNode[];
-    getTask(taskId: string): TaskNode | undefined;
-    getMaxParallelism(): number;
-    getComplexityScore(): number;
-    getExecutionStats(): Promise<ExecutionStats>;
-}
-interface ExecutionStats {
-    totalTasks: number;
-    completedTasks: number;
-    failedTasks: number;
-    inProgressTasks: number;
-    averageExecutionTime: number;
-    totalRetries: number;
-}
-export {};
-//# sourceMappingURL=task-dependencies.d.ts.map