snow-flow 2.0.4 → 2.0.6

package/dist/coordination/shared-memory.js

@@ -0,0 +1,289 @@
+"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

@@ -0,0 +1,50 @@
+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