snow-flow 3.0.9 → 3.0.10

package/dist/memory/memory-client.js

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

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

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