snow-flow 2.0.4 → 2.0.5

package/dist/memory/memory-client.js

@@ -0,0 +1,364 @@
+"use strict";
+/**
+ * Snow-Flow Memory Client
+ * Simple API for agents to interact with the memory system
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryClient = void 0;
+const logger_js_1 = require("../utils/logger.js");
+const swarm_memory_js_1 = require("./swarm-memory.js");
+const memory_operations_js_1 = require("./memory-operations.js");
+/**
+ * Singleton instance management
+ */
+let memoryInstance = null;
+let operationsInstance = null;
+class MemoryClient {
+    constructor(config = {}) {
+        this.logger = new logger_js_1.Logger('MemoryClient');
+        // Use singleton instances for memory and operations
+        if (!memoryInstance) {
+            memoryInstance = new swarm_memory_js_1.SwarmMemory(config);
+        }
+        if (!operationsInstance) {
+            operationsInstance = new memory_operations_js_1.MemoryOperations(memoryInstance);
+        }
+        this.memory = memoryInstance;
+        this.operations = operationsInstance;
+        // Set session and agent context
+        this.sessionId = config.sessionId || this.generateSessionId();
+        this.agentId = config.agentId || 'anonymous';
+        this.agentType = config.agentType || 'unknown';
+        this.logger.info('Memory client initialized', {
+            sessionId: this.sessionId,
+            agentId: this.agentId,
+            agentType: this.agentType
+        });
+    }
+    // ==================== Simple Context Storage ====================
+    /**
+     * Store data in shared context
+     */
+    async store(options) {
+        await this.operations.setContext(this.sessionId, options.key, options.value, this.agentId, options.expires, options.permissions);
+    }
+    /**
+     * Retrieve data from shared context with agent isolation
+     */
+    async retrieve(options) {
+        // CRITICAL FIX: Pass agent ID for proper memory isolation
+        const context = await this.operations.getContext(this.sessionId, options.key, this.agentId);
+        if (!context) {
+            return options.defaultValue !== undefined ? options.defaultValue : null;
+        }
+        return context.context_value;
+    }
+    /**
+     * Retrieve data from truly shared context (no agent isolation)
+     * Use this when agents need to access shared coordination data
+     */
+    async retrieveShared(options) {
+        // Try shared prefix first
+        const sharedKey = `__shared__::${options.key}`;
+        let context = await this.operations.getContext(this.sessionId, sharedKey);
+        // Fallback to original key for backward compatibility
+        if (!context) {
+            context = await this.operations.getContext(this.sessionId, options.key);
+        }
+        if (!context) {
+            return options.defaultValue !== undefined ? options.defaultValue : null;
+        }
+        return context.context_value;
+    }
+    /**
+     * Store data in truly shared context (no agent isolation)
+     * Use this when you want all agents to access the same data
+     */
+    async storeShared(options) {
+        // Use a special shared prefix to avoid conflicts with namespaced keys
+        const sharedKey = `__shared__::${options.key}`;
+        await this.operations.setContext(this.sessionId, sharedKey, options.value, this.agentId, // Still track who created it
+        options.expires, options.permissions);
+    }
+    /**
+     * Get all context for current session
+     */
+    async getSessionData() {
+        const contexts = await this.operations.getSessionContext(this.sessionId);
+        const data = {};
+        for (const context of contexts) {
+            data[context.context_key] = context.context_value;
+        }
+        return data;
+    }
+    // ==================== Agent Coordination ====================
+    /**
+     * Register current agent
+     */
+    async register(assignedTasks = []) {
+        await this.operations.registerAgent(this.sessionId, this.agentId, this.agentType, assignedTasks);
+    }
+    /**
+     * Update agent progress
+     */
+    async updateProgress(percentage, currentTool) {
+        await this.operations.updateAgentStatus(this.sessionId, this.agentId, {
+            status: 'active',
+            progress_percentage: percentage,
+            current_tool: currentTool
+        });
+    }
+    /**
+     * Mark agent as completed
+     */
+    async complete() {
+        await this.operations.updateAgentStatus(this.sessionId, this.agentId, {
+            status: 'completed',
+            progress_percentage: 100
+        });
+    }
+    /**
+     * Report agent error
+     */
+    async reportError(error) {
+        await this.operations.updateAgentStatus(this.sessionId, this.agentId, {
+            status: 'failed',
+            error_state: error
+        });
+    }
+    /**
+     * Check if agent should wait for dependencies
+     */
+    async checkDependencies() {
+        const satisfied = await this.operations.checkDependenciesSatisfied(this.sessionId, this.agentId);
+        if (!satisfied) {
+            await this.operations.updateAgentStatus(this.sessionId, this.agentId, {
+                status: 'blocked'
+            });
+        }
+        return satisfied;
+    }
+    // ==================== Artifact Management ====================
+    /**
+     * Store ServiceNow artifact information
+     */
+    async storeArtifact(artifact) {
+        await this.operations.storeArtifact({
+            sys_id: artifact.sys_id,
+            artifact_type: artifact.type,
+            name: artifact.name,
+            description: artifact.description,
+            created_by_agent: this.agentId,
+            session_id: this.sessionId,
+            deployment_status: artifact.status || 'created',
+            update_set_id: artifact.update_set_id,
+            dependencies: artifact.dependencies ? JSON.stringify(artifact.dependencies) : undefined,
+            metadata: artifact.metadata ? JSON.stringify(artifact.metadata) : undefined
+        });
+    }
+    /**
+     * Update artifact status
+     */
+    async updateArtifactStatus(sys_id, status) {
+        await this.operations.updateArtifactStatus(sys_id, status);
+    }
+    /**
+     * Find artifacts created in current session
+     */
+    async findSessionArtifacts(type) {
+        const artifacts = await this.operations.searchArtifacts({
+            session_id: this.sessionId,
+            artifact_type: type
+        });
+        return artifacts.map(a => ({
+            sys_id: a.sys_id,
+            type: a.artifact_type,
+            name: a.name,
+            description: a.description,
+            status: a.deployment_status,
+            update_set_id: a.update_set_id,
+            dependencies: a.dependencies ? JSON.parse(a.dependencies) : undefined,
+            metadata: a.metadata ? JSON.parse(a.metadata) : undefined
+        }));
+    }
+    // ==================== Agent Communication ====================
+    /**
+     * Send handoff to another agent
+     */
+    async handoff(handoff) {
+        await this.operations.sendMessage(this.sessionId, this.agentId, handoff.to_agent, 'handoff', handoff.data, handoff.artifact_reference);
+    }
+    /**
+     * Check for incoming handoffs
+     */
+    async checkHandoffs() {
+        const messages = await this.operations.getUnprocessedMessages(this.agentId, this.sessionId);
+        const handoffs = messages.filter(m => m.message_type === 'handoff');
+        const results = handoffs.map(h => ({
+            from: h.from_agent,
+            data: typeof h.content === 'string' ? JSON.parse(h.content) : h.content,
+            artifact_reference: h.artifact_reference
+        }));
+        // Mark messages as processed
+        for (const handoff of handoffs) {
+            await this.operations.markMessageProcessed(handoff.id);
+        }
+        return results;
+    }
+    /**
+     * Send status update
+     */
+    async sendStatus(status, details) {
+        await this.operations.sendMessage(this.sessionId, this.agentId, 'queen', // Always send status to Queen
+        'status_update', { status, details });
+    }
+    /**
+     * Report dependency ready
+     */
+    async reportDependencyReady(dependent_agent, artifact_reference) {
+        await this.operations.sendMessage(this.sessionId, this.agentId, dependent_agent, 'dependency_ready', { ready: true }, artifact_reference);
+        // Also update dependency status
+        await this.operations.satisfyDependency(this.sessionId, dependent_agent, this.agentId);
+    }
+    // ==================== Performance Tracking ====================
+    /**
+     * Start tracking an operation
+     */
+    trackOperation(operation) {
+        const tracking = this.operations.startPerformanceTracking(this.sessionId, this.agentId, operation);
+        return {
+            complete: async (success, error, metadata) => {
+                await this.operations.completePerformanceTracking(tracking, this.sessionId, this.agentId, operation, success, error, metadata);
+            }
+        };
+    }
+    /**
+     * Get average performance for an operation
+     */
+    async getPerformanceStats(operation) {
+        const stats = await this.operations.getAveragePerformance(operation, this.sessionId);
+        if (!stats)
+            return null;
+        return {
+            avgDuration: stats.avg_duration_ms,
+            successRate: stats.success_rate,
+            totalOperations: stats.total_operations
+        };
+    }
+    // ==================== Deployment Tracking ====================
+    /**
+     * Record successful deployment
+     */
+    async recordDeployment(artifact_sys_id, type, success = true, error) {
+        await this.operations.recordDeployment(this.sessionId, artifact_sys_id, type, this.agentId, success, error, type === 'create' || type === 'update' // Rollback available for create/update
+        );
+    }
+    /**
+     * Get deployment history for an artifact
+     */
+    async getDeploymentHistory(artifact_sys_id) {
+        const history = await this.operations.getDeploymentHistory(artifact_sys_id);
+        return history.map(h => ({
+            type: h.deployment_type,
+            success: h.success,
+            time: new Date(h.deployment_time),
+            agent: h.agent_id,
+            error: h.error_details
+        }));
+    }
+    // ==================== Session Management ====================
+    /**
+     * Get current session ID
+     */
+    getSessionId() {
+        return this.sessionId;
+    }
+    /**
+     * Get current agent ID
+     */
+    getAgentId() {
+        return this.agentId;
+    }
+    /**
+     * Get complete session state
+     */
+    async getSessionState() {
+        return this.operations.getSessionState(this.sessionId);
+    }
+    /**
+     * Clean up current session
+     */
+    async cleanup() {
+        await this.operations.cleanupSession(this.sessionId);
+    }
+    // ==================== Analytics ====================
+    /**
+     * Get memory statistics
+     */
+    getStats() {
+        return this.memory.getStats();
+    }
+    /**
+     * Run memory cleanup
+     */
+    async runCleanup() {
+        this.memory.cleanup();
+    }
+    // ==================== Raw Access ====================
+    /**
+     * Get direct access to operations (for advanced use cases)
+     */
+    getOperations() {
+        return this.operations;
+    }
+    /**
+     * Get direct access to database (for custom queries)
+     */
+    getDatabase() {
+        return this.memory;
+    }
+    // ==================== Static Methods ====================
+    /**
+     * Create a memory client for an agent
+     */
+    static forAgent(agentId, agentType, sessionId) {
+        return new MemoryClient({
+            agentId,
+            agentType,
+            sessionId
+        });
+    }
+    /**
+     * Create a memory client for a session
+     */
+    static forSession(sessionId) {
+        return new MemoryClient({ sessionId });
+    }
+    /**
+     * Close all connections (call when shutting down)
+     */
+    static shutdown() {
+        if (memoryInstance) {
+            memoryInstance.close();
+            memoryInstance = null;
+            operationsInstance = null;
+        }
+    }
+    // ==================== Private Methods ====================
+    generateSessionId() {
+        return `session_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+    }
+    /**
+     * COMPATIBILITY FIX: makeRequest method for phantom calls
+     * MemoryClient doesn't use HTTP requests, so this is a no-op fallback
+     */
+    async makeRequest(config) {
+        console.log('🔧 MemoryClient.makeRequest called with config:', config);
+        console.log('🔧 WARNING: MemoryClient does not support HTTP requests');
+        // Since MemoryClient doesn't do HTTP requests, we should throw an error
+        // to help identify which code is incorrectly trying to use this client for HTTP
+        throw new Error('🔧 MemoryClient does not support HTTP requests (makeRequest called incorrectly)');
+    }
+}
+exports.MemoryClient = MemoryClient;
+//# sourceMappingURL=memory-client.js.map

package/dist/memory/memory-manager.d.ts

@@ -0,0 +1,29 @@
+import { MemoryEntry } from '../types/index.js';
+export declare class MemoryManager {
+    private static instance;
+    private memoryDir;
+    private cache;
+    private initialized;
+    private constructor();
+    static getInstance(): MemoryManager;
+    initialize(): Promise<void>;
+    private loadCache;
+    store(key: string, value: any, namespace?: string, ttl?: number): Promise<void>;
+    get(key: string, namespace?: string): Promise<any>;
+    list(namespace?: string): Promise<MemoryEntry[]>;
+    search(pattern: string, namespace?: string): Promise<MemoryEntry[]>;
+    delete(key: string, namespace?: string): Promise<void>;
+    clear(namespace?: string): Promise<void>;
+    export(filePath: string, namespace?: string): Promise<void>;
+    import(filePath: string, overwrite?: boolean): Promise<void>;
+    stats(): Promise<{
+        totalEntries: number;
+        namespaces: string[];
+        totalSize: number;
+        oldestEntry?: Date;
+        newestEntry?: Date;
+    }>;
+    cleanup(): Promise<number>;
+}
+export declare const memoryManager: MemoryManager;
+//# sourceMappingURL=memory-manager.d.ts.map

package/dist/memory/memory-manager.js

@@ -0,0 +1,280 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memoryManager = exports.MemoryManager = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = require("path");
+const config_js_1 = require("../utils/config.js");
+const logger_js_1 = require("../utils/logger.js");
+class MemoryManager {
+    constructor() {
+        this.cache = new Map();
+        this.initialized = false;
+        const memoryConfig = config_js_1.configManager.get('memory');
+        this.memoryDir = memoryConfig?.storageDir || (0, path_1.join)(process.cwd(), '.snow-flow-memory');
+    }
+    static getInstance() {
+        if (!MemoryManager.instance) {
+            MemoryManager.instance = new MemoryManager();
+        }
+        return MemoryManager.instance;
+    }
+    // Initialize memory storage
+    async initialize() {
+        if (this.initialized)
+            return;
+        try {
+            await fs_extra_1.default.ensureDir(this.memoryDir);
+            await this.loadCache();
+            this.initialized = true;
+            logger_js_1.logger.debug(`Memory manager initialized at ${this.memoryDir}`);
+        }
+        catch (error) {
+            logger_js_1.logger.error('Failed to initialize memory manager', error);
+            throw error;
+        }
+    }
+    // Load memory entries into cache
+    async loadCache() {
+        try {
+            const files = await fs_extra_1.default.readdir(this.memoryDir);
+            for (const file of files) {
+                if (file.endsWith('.json')) {
+                    const filePath = (0, path_1.join)(this.memoryDir, file);
+                    const entry = await fs_extra_1.default.readJson(filePath);
+                    // Check if entry has expired
+                    if (entry.expiresAt && new Date(entry.expiresAt) < new Date()) {
+                        await fs_extra_1.default.remove(filePath);
+                        continue;
+                    }
+                    this.cache.set(entry.key, entry);
+                }
+            }
+            logger_js_1.logger.debug(`Loaded ${this.cache.size} memory entries`);
+        }
+        catch (error) {
+            logger_js_1.logger.error('Failed to load memory cache', error);
+        }
+    }
+    // Store data in memory
+    async store(key, value, namespace = 'default', ttl) {
+        await this.initialize();
+        const entry = {
+            key,
+            value,
+            namespace,
+            createdAt: new Date(),
+            expiresAt: ttl ? new Date(Date.now() + ttl) : undefined
+        };
+        // Save to cache
+        this.cache.set(key, entry);
+        // Persist to disk
+        const filename = `${namespace}_${key.replace(/[^a-zA-Z0-9-_]/g, '_')}.json`;
+        const filePath = (0, path_1.join)(this.memoryDir, filename);
+        try {
+            await fs_extra_1.default.writeJson(filePath, entry, { spaces: 2 });
+            logger_js_1.logger.success(`Stored memory entry: ${key}`);
+        }
+        catch (error) {
+            logger_js_1.logger.error(`Failed to store memory entry: ${key}`, error);
+            throw error;
+        }
+    }
+    // Retrieve data from memory
+    async get(key, namespace = 'default') {
+        await this.initialize();
+        // Check cache first
+        const entry = this.cache.get(key);
+        if (entry) {
+            // Check if expired
+            if (entry.expiresAt && new Date(entry.expiresAt) < new Date()) {
+                await this.delete(key, namespace);
+                return null;
+            }
+            if (entry.namespace === namespace) {
+                return entry.value;
+            }
+        }
+        // Try loading from disk if not in cache
+        const filename = `${namespace}_${key.replace(/[^a-zA-Z0-9-_]/g, '_')}.json`;
+        const filePath = (0, path_1.join)(this.memoryDir, filename);
+        try {
+            if (await fs_extra_1.default.pathExists(filePath)) {
+                const entry = await fs_extra_1.default.readJson(filePath);
+                // Check if expired
+                if (entry.expiresAt && new Date(entry.expiresAt) < new Date()) {
+                    await fs_extra_1.default.remove(filePath);
+                    return null;
+                }
+                // Update cache
+                this.cache.set(key, entry);
+                return entry.value;
+            }
+        }
+        catch (error) {
+            logger_js_1.logger.error(`Failed to retrieve memory entry: ${key}`, error);
+        }
+        return null;
+    }
+    // List all memory entries
+    async list(namespace) {
+        await this.initialize();
+        const entries = [];
+        for (const entry of this.cache.values()) {
+            // Skip expired entries
+            if (entry.expiresAt && new Date(entry.expiresAt) < new Date()) {
+                continue;
+            }
+            // Filter by namespace if provided
+            if (!namespace || entry.namespace === namespace) {
+                entries.push(entry);
+            }
+        }
+        return entries.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+    }
+    // Search memory entries
+    async search(pattern, namespace) {
+        await this.initialize();
+        const regex = new RegExp(pattern, 'i');
+        const entries = [];
+        for (const entry of this.cache.values()) {
+            // Skip expired entries
+            if (entry.expiresAt && new Date(entry.expiresAt) < new Date()) {
+                continue;
+            }
+            // Filter by namespace if provided
+            if (namespace && entry.namespace !== namespace) {
+                continue;
+            }
+            // Search in key and value
+            if (regex.test(entry.key) ||
+                regex.test(JSON.stringify(entry.value))) {
+                entries.push(entry);
+            }
+        }
+        return entries.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+    }
+    // Delete memory entry
+    async delete(key, namespace = 'default') {
+        await this.initialize();
+        // Remove from cache
+        this.cache.delete(key);
+        // Remove from disk
+        const filename = `${namespace}_${key.replace(/[^a-zA-Z0-9-_]/g, '_')}.json`;
+        const filePath = (0, path_1.join)(this.memoryDir, filename);
+        try {
+            await fs_extra_1.default.remove(filePath);
+            logger_js_1.logger.success(`Deleted memory entry: ${key}`);
+        }
+        catch (error) {
+            logger_js_1.logger.error(`Failed to delete memory entry: ${key}`, error);
+        }
+    }
+    // Clear all memory entries
+    async clear(namespace) {
+        await this.initialize();
+        if (namespace) {
+            // Clear specific namespace
+            const entries = await this.list(namespace);
+            for (const entry of entries) {
+                await this.delete(entry.key, namespace);
+            }
+        }
+        else {
+            // Clear all
+            this.cache.clear();
+            await fs_extra_1.default.emptyDir(this.memoryDir);
+            logger_js_1.logger.success('Cleared all memory entries');
+        }
+    }
+    // Export memory to file
+    async export(filePath, namespace) {
+        await this.initialize();
+        const entries = await this.list(namespace);
+        const exportData = {
+            exported: new Date().toISOString(),
+            namespace: namespace || 'all',
+            entries
+        };
+        try {
+            await fs_extra_1.default.writeJson(filePath, exportData, { spaces: 2 });
+            logger_js_1.logger.success(`Exported ${entries.length} memory entries to ${filePath}`);
+        }
+        catch (error) {
+            logger_js_1.logger.error('Failed to export memory', error);
+            throw error;
+        }
+    }
+    // Import memory from file
+    async import(filePath, overwrite = false) {
+        await this.initialize();
+        try {
+            const importData = await fs_extra_1.default.readJson(filePath);
+            if (!importData.entries || !Array.isArray(importData.entries)) {
+                throw new Error('Invalid import file format');
+            }
+            let imported = 0;
+            for (const entry of importData.entries) {
+                const existing = await this.get(entry.key, entry.namespace);
+                if (!existing || overwrite) {
+                    await this.store(entry.key, entry.value, entry.namespace, entry.ttl);
+                    imported++;
+                }
+            }
+            logger_js_1.logger.success(`Imported ${imported} memory entries from ${filePath}`);
+        }
+        catch (error) {
+            logger_js_1.logger.error('Failed to import memory', error);
+            throw error;
+        }
+    }
+    // Get memory statistics
+    async stats() {
+        await this.initialize();
+        const entries = await this.list();
+        const namespaces = [...new Set(entries.map(e => e.namespace))];
+        let totalSize = 0;
+        let oldestEntry;
+        let newestEntry;
+        for (const entry of entries) {
+            const size = JSON.stringify(entry).length;
+            totalSize += size;
+            const createdAt = new Date(entry.createdAt);
+            if (!oldestEntry || createdAt < oldestEntry) {
+                oldestEntry = createdAt;
+            }
+            if (!newestEntry || createdAt > newestEntry) {
+                newestEntry = createdAt;
+            }
+        }
+        return {
+            totalEntries: entries.length,
+            namespaces,
+            totalSize,
+            oldestEntry,
+            newestEntry
+        };
+    }
+    // Cleanup expired entries
+    async cleanup() {
+        await this.initialize();
+        let cleaned = 0;
+        const now = new Date();
+        for (const [key, entry] of this.cache.entries()) {
+            if (entry.expiresAt && new Date(entry.expiresAt) < now) {
+                await this.delete(key, entry.namespace);
+                cleaned++;
+            }
+        }
+        if (cleaned > 0) {
+            logger_js_1.logger.success(`Cleaned up ${cleaned} expired memory entries`);
+        }
+        return cleaned;
+    }
+}
+exports.MemoryManager = MemoryManager;
+// Export singleton instance
+exports.memoryManager = MemoryManager.getInstance();
+//# sourceMappingURL=memory-manager.js.map