snow-flow 3.0.9 → 3.0.10

package/dist/memory/memory-operations.js

@@ -1,691 +0,0 @@
-"use strict";
-/**
- * Snow-Flow Memory Operations
- * High-level operations for agent coordination and data management
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MemoryOperations = void 0;
-const uuid_1 = require("uuid");
-const logger_js_1 = require("../utils/logger.js");
-class MemoryOperations {
-    constructor(memory) {
-        this.memory = memory;
-        this.logger = new logger_js_1.Logger('MemoryOperations');
-    }
-    // ==================== Agent Coordination Operations ====================
-    /**
-     * Register a new agent in the coordination system
-     */
-    async registerAgent(session_id, agent_id, agent_type, assigned_tasks = []) {
-        try {
-            this.memory.run(`
-        INSERT OR REPLACE INTO agent_coordination 
-        (session_id, agent_id, agent_type, status, assigned_tasks, progress_percentage, last_activity)
-        VALUES (?, ?, ?, 'spawned', ?, 0, datetime('now'))
-      `, [session_id, agent_id, agent_type, JSON.stringify(assigned_tasks)]);
-            this.logger.info('Agent registered', { session_id, agent_id, agent_type });
-        }
-        catch (error) {
-            this.logger.error('Failed to register agent', error);
-            throw error;
-        }
-    }
-    /**
-     * Update agent status and progress
-     */
-    async updateAgentStatus(session_id, agent_id, updates) {
-        const setters = ["last_activity = datetime('now')"];
-        const params = [];
-        if (updates.status !== undefined) {
-            setters.push('status = ?');
-            params.push(updates.status);
-        }
-        if (updates.progress_percentage !== undefined) {
-            setters.push('progress_percentage = ?');
-            params.push(updates.progress_percentage);
-        }
-        if (updates.current_tool !== undefined) {
-            setters.push('current_tool = ?');
-            params.push(updates.current_tool);
-        }
-        if (updates.error_state !== undefined) {
-            setters.push('error_state = ?');
-            params.push(updates.error_state);
-        }
-        if (updates.assigned_tasks !== undefined) {
-            setters.push('assigned_tasks = ?');
-            params.push(updates.assigned_tasks);
-        }
-        params.push(session_id, agent_id);
-        try {
-            this.memory.run(`
-        UPDATE agent_coordination 
-        SET ${setters.join(', ')}
-        WHERE session_id = ? AND agent_id = ?
-      `, params);
-            this.logger.debug('Agent status updated', { session_id, agent_id, updates });
-        }
-        catch (error) {
-            this.logger.error('Failed to update agent status', error);
-            throw error;
-        }
-    }
-    /**
-     * Get all active agents for a session
-     */
-    async getActiveAgents(session_id) {
-        return this.memory.all(`
-      SELECT * FROM agent_coordination 
-      WHERE session_id = ? AND status IN ('spawned', 'active', 'blocked')
-      ORDER BY last_activity DESC
-    `, [session_id]);
-    }
-    /**
-     * Get agent coordination status
-     */
-    async getAgentStatus(session_id, agent_id) {
-        return this.memory.get(`
-      SELECT * FROM agent_coordination 
-      WHERE session_id = ? AND agent_id = ?
-    `, [session_id, agent_id]);
-    }
-    // ==================== ServiceNow Artifact Operations ====================
-    /**
-     * Store a ServiceNow artifact
-     */
-    async storeArtifact(artifact) {
-        try {
-            this.memory.run(`
-        INSERT OR REPLACE INTO servicenow_artifacts 
-        (sys_id, artifact_type, name, description, created_by_agent, session_id, 
-         deployment_status, update_set_id, dependencies, metadata)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-      `, [
-                artifact.sys_id,
-                artifact.artifact_type,
-                artifact.name,
-                artifact.description || null,
-                artifact.created_by_agent,
-                artifact.session_id,
-                artifact.deployment_status,
-                artifact.update_set_id || null,
-                artifact.dependencies || null,
-                artifact.metadata || null
-            ]);
-            this.logger.info('Artifact stored', {
-                sys_id: artifact.sys_id,
-                type: artifact.artifact_type,
-                name: artifact.name
-            });
-        }
-        catch (error) {
-            this.logger.error('Failed to store artifact', error);
-            throw error;
-        }
-    }
-    /**
-     * Update artifact deployment status
-     */
-    async updateArtifactStatus(sys_id, deployment_status) {
-        try {
-            this.memory.run(`
-        UPDATE servicenow_artifacts 
-        SET deployment_status = ?, updated_at = datetime('now')
-        WHERE sys_id = ?
-      `, [deployment_status, sys_id]);
-            this.logger.debug('Artifact status updated', { sys_id, deployment_status });
-        }
-        catch (error) {
-            this.logger.error('Failed to update artifact status', error);
-            throw error;
-        }
-    }
-    /**
-     * Search for artifacts
-     */
-    async searchArtifacts(options = {}) {
-        const conditions = [];
-        const params = [];
-        if (options.session_id) {
-            conditions.push('session_id = ?');
-            params.push(options.session_id);
-        }
-        if (options.artifact_type) {
-            conditions.push('artifact_type = ?');
-            params.push(options.artifact_type);
-        }
-        if (options.deployment_status) {
-            conditions.push('deployment_status = ?');
-            params.push(options.deployment_status);
-        }
-        if (options.created_by_agent) {
-            conditions.push('created_by_agent = ?');
-            params.push(options.created_by_agent);
-        }
-        const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
-        const limitClause = options.limit ? `LIMIT ${options.limit}` : '';
-        return this.memory.all(`
-      SELECT * FROM servicenow_artifacts 
-      ${whereClause}
-      ORDER BY updated_at DESC
-      ${limitClause}
-    `, params);
-    }
-    /**
-     * Get artifact by sys_id
-     */
-    async getArtifact(sys_id) {
-        return this.memory.get(`
-      SELECT * FROM servicenow_artifacts 
-      WHERE sys_id = ?
-    `, [sys_id]);
-    }
-    // ==================== Agent Message Operations ====================
-    /**
-     * Send a message between agents
-     */
-    async sendMessage(session_id, from_agent, to_agent, message_type, content, artifact_reference) {
-        const id = (0, uuid_1.v4)();
-        try {
-            this.memory.run(`
-        INSERT INTO agent_messages 
-        (id, session_id, from_agent, to_agent, message_type, content, artifact_reference, processed)
-        VALUES (?, ?, ?, ?, ?, ?, ?, 0)
-      `, [
-                id,
-                session_id,
-                from_agent,
-                to_agent,
-                message_type,
-                typeof content === 'string' ? content : JSON.stringify(content),
-                artifact_reference || null
-            ]);
-            this.logger.debug('Message sent', { id, from_agent, to_agent, message_type });
-            return id;
-        }
-        catch (error) {
-            this.logger.error('Failed to send message', error);
-            throw error;
-        }
-    }
-    /**
-     * Get unprocessed messages for an agent
-     */
-    async getUnprocessedMessages(to_agent, session_id) {
-        const conditions = ['to_agent = ?', 'processed = 0'];
-        const params = [to_agent];
-        if (session_id) {
-            conditions.push('session_id = ?');
-            params.push(session_id);
-        }
-        return this.memory.all(`
-      SELECT * FROM agent_messages 
-      WHERE ${conditions.join(' AND ')}
-      ORDER BY timestamp ASC
-    `, params);
-    }
-    /**
-     * Mark message as processed
-     */
-    async markMessageProcessed(message_id) {
-        try {
-            this.memory.run(`
-        UPDATE agent_messages 
-        SET processed = 1
-        WHERE id = ?
-      `, [message_id]);
-            this.logger.debug('Message marked as processed', { message_id });
-        }
-        catch (error) {
-            this.logger.error('Failed to mark message as processed', error);
-            throw error;
-        }
-    }
-    /**
-     * Search messages
-     */
-    async searchMessages(options = {}) {
-        const conditions = [];
-        const params = [];
-        if (options.session_id) {
-            conditions.push('session_id = ?');
-            params.push(options.session_id);
-        }
-        if (options.to_agent) {
-            conditions.push('to_agent = ?');
-            params.push(options.to_agent);
-        }
-        if (options.from_agent) {
-            conditions.push('from_agent = ?');
-            params.push(options.from_agent);
-        }
-        if (options.message_type) {
-            conditions.push('message_type = ?');
-            params.push(options.message_type);
-        }
-        if (options.processed !== undefined) {
-            conditions.push('processed = ?');
-            params.push(options.processed ? 1 : 0);
-        }
-        const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
-        const limitClause = options.limit ? `LIMIT ${options.limit}` : '';
-        return this.memory.all(`
-      SELECT * FROM agent_messages 
-      ${whereClause}
-      ORDER BY timestamp DESC
-      ${limitClause}
-    `, params);
-    }
-    // ==================== Shared Context Operations ====================
-    /**
-     * Create agent-specific namespaced key for memory isolation
-     * This prevents agents from overwriting each other's memory within the same session
-     */
-    createNamespacedKey(context_key, agent_id) {
-        // Use a delimiter that's unlikely to conflict with normal keys
-        return `${agent_id}::${context_key}`;
-    }
-    /**
-     * Parse namespaced key to extract original key and agent ID
-     */
-    parseNamespacedKey(namespaced_key) {
-        const parts = namespaced_key.split('::');
-        if (parts.length === 2) {
-            return { agent_id: parts[0], original_key: parts[1] };
-        }
-        return { agent_id: null, original_key: namespaced_key };
-    }
-    /**
-     * Store shared context with agent isolation
-     */
-    async setContext(session_id, context_key, context_value, created_by_agent, expires_at, access_permissions) {
-        try {
-            // CRITICAL FIX: Create agent-specific namespace for the context key
-            // This ensures agents don't overwrite each other's memory
-            const namespacedKey = this.createNamespacedKey(context_key, created_by_agent);
-            this.memory.run(`
-        INSERT OR REPLACE INTO shared_context 
-        (session_id, context_key, context_value, created_by_agent, expires_at, access_permissions)
-        VALUES (?, ?, ?, ?, ?, ?)
-      `, [
-                session_id,
-                namespacedKey,
-                typeof context_value === 'string' ? context_value : JSON.stringify(context_value),
-                created_by_agent,
-                expires_at ? expires_at.toISOString() : null,
-                access_permissions ? JSON.stringify(access_permissions) : null
-            ]);
-            this.logger.debug('Context stored with agent isolation', {
-                session_id,
-                original_key: context_key,
-                namespaced_key: namespacedKey,
-                created_by_agent
-            });
-        }
-        catch (error) {
-            this.logger.error('Failed to store context', error);
-            throw error;
-        }
-    }
-    /**
-     * Get shared context with agent isolation support
-     */
-    async getContext(session_id, context_key, requesting_agent) {
-        // CRITICAL FIX: Try to get agent-specific namespaced key first
-        let result = null;
-        if (requesting_agent) {
-            const namespacedKey = this.createNamespacedKey(context_key, requesting_agent);
-            result = this.memory.get(`
-        SELECT * FROM shared_context 
-        WHERE session_id = ? AND context_key = ?
-          AND (expires_at IS NULL OR expires_at > datetime('now'))
-      `, [session_id, namespacedKey]);
-            this.logger.debug('Attempting namespaced context retrieval', {
-                session_id,
-                original_key: context_key,
-                namespaced_key: namespacedKey,
-                requesting_agent,
-                found: !!result
-            });
-        }
-        // Fallback: Try to get the original key for backward compatibility or shared data
-        if (!result) {
-            result = this.memory.get(`
-        SELECT * FROM shared_context 
-        WHERE session_id = ? AND context_key = ?
-          AND (expires_at IS NULL OR expires_at > datetime('now'))
-      `, [session_id, context_key]);
-            this.logger.debug('Fallback context retrieval', {
-                session_id,
-                context_key,
-                found: !!result
-            });
-        }
-        if (result) {
-            try {
-                // Try to parse JSON values
-                if (result.context_value && (result.context_value.startsWith('{') || result.context_value.startsWith('['))) {
-                    result.context_value = JSON.parse(result.context_value);
-                }
-                if (result.access_permissions) {
-                    result.access_permissions = JSON.parse(result.access_permissions);
-                }
-            }
-            catch (e) {
-                // If parsing fails, return as-is
-                this.logger.warn('Failed to parse stored JSON context', { context_key, error: e });
-            }
-        }
-        return result;
-    }
-    /**
-     * Get all context for a session
-     */
-    async getSessionContext(session_id) {
-        const results = this.memory.all(`
-      SELECT * FROM shared_context 
-      WHERE session_id = ?
-        AND (expires_at IS NULL OR expires_at > datetime('now'))
-      ORDER BY updated_at DESC
-    `, [session_id]);
-        // Parse JSON values
-        return results.map(result => {
-            try {
-                if (result.context_value && (result.context_value.startsWith('{') || result.context_value.startsWith('['))) {
-                    result.context_value = JSON.parse(result.context_value);
-                }
-                if (result.access_permissions) {
-                    result.access_permissions = JSON.parse(result.access_permissions);
-                }
-            }
-            catch (e) {
-                // If parsing fails, return as-is
-            }
-            return result;
-        });
-    }
-    // ==================== Deployment History Operations ====================
-    /**
-     * Record deployment event
-     */
-    async recordDeployment(session_id, artifact_sys_id, deployment_type, agent_id, success, error_details, rollback_available = false) {
-        const id = (0, uuid_1.v4)();
-        try {
-            this.memory.run(`
-        INSERT INTO deployment_history 
-        (id, session_id, artifact_sys_id, deployment_type, success, agent_id, error_details, rollback_available)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-      `, [
-                id,
-                session_id,
-                artifact_sys_id,
-                deployment_type,
-                success ? 1 : 0,
-                agent_id,
-                error_details || null,
-                rollback_available ? 1 : 0
-            ]);
-            this.logger.info('Deployment recorded', {
-                id,
-                artifact_sys_id,
-                deployment_type,
-                success
-            });
-            return id;
-        }
-        catch (error) {
-            this.logger.error('Failed to record deployment', error);
-            throw error;
-        }
-    }
-    /**
-     * Get deployment history for an artifact
-     */
-    async getDeploymentHistory(artifact_sys_id) {
-        return this.memory.all(`
-      SELECT * FROM deployment_history 
-      WHERE artifact_sys_id = ?
-      ORDER BY deployment_time DESC
-    `, [artifact_sys_id]);
-    }
-    /**
-     * Get latest deployment for an artifact
-     */
-    async getLatestDeployment(artifact_sys_id) {
-        return this.memory.get(`
-      SELECT * FROM deployment_history 
-      WHERE artifact_sys_id = ?
-      ORDER BY deployment_time DESC
-      LIMIT 1
-    `, [artifact_sys_id]);
-    }
-    // ==================== Agent Dependency Operations ====================
-    /**
-     * Add agent dependency
-     */
-    async addDependency(session_id, agent_id, depends_on_agent, dependency_type, artifact_reference) {
-        try {
-            this.memory.run(`
-        INSERT OR REPLACE INTO agent_dependencies 
-        (session_id, agent_id, depends_on_agent, dependency_type, artifact_reference, status)
-        VALUES (?, ?, ?, ?, ?, 'pending')
-      `, [
-                session_id,
-                agent_id,
-                depends_on_agent,
-                dependency_type,
-                artifact_reference || null
-            ]);
-            this.logger.debug('Dependency added', {
-                session_id,
-                agent_id,
-                depends_on_agent,
-                dependency_type
-            });
-        }
-        catch (error) {
-            this.logger.error('Failed to add dependency', error);
-            throw error;
-        }
-    }
-    /**
-     * Mark dependency as satisfied
-     */
-    async satisfyDependency(session_id, agent_id, depends_on_agent) {
-        try {
-            this.memory.run(`
-        UPDATE agent_dependencies 
-        SET status = 'satisfied', satisfied_at = datetime('now')
-        WHERE session_id = ? AND agent_id = ? AND depends_on_agent = ?
-      `, [session_id, agent_id, depends_on_agent]);
-            this.logger.debug('Dependency satisfied', {
-                session_id,
-                agent_id,
-                depends_on_agent
-            });
-        }
-        catch (error) {
-            this.logger.error('Failed to satisfy dependency', error);
-            throw error;
-        }
-    }
-    /**
-     * Get pending dependencies for an agent
-     */
-    async getPendingDependencies(session_id, agent_id) {
-        return this.memory.all(`
-      SELECT * FROM agent_dependencies 
-      WHERE session_id = ? AND agent_id = ? AND status = 'pending'
-      ORDER BY created_at ASC
-    `, [session_id, agent_id]);
-    }
-    /**
-     * Check if all dependencies are satisfied
-     */
-    async checkDependenciesSatisfied(session_id, agent_id) {
-        const pending = this.memory.get(`
-      SELECT COUNT(*) as count FROM agent_dependencies 
-      WHERE session_id = ? AND agent_id = ? AND status = 'pending'
-    `, [session_id, agent_id]);
-        return pending?.count === 0;
-    }
-    // ==================== Performance Metric Operations ====================
-    /**
-     * Start performance tracking
-     */
-    startPerformanceTracking(session_id, agent_id, operation_name) {
-        return {
-            id: (0, uuid_1.v4)(),
-            startTime: Date.now()
-        };
-    }
-    /**
-     * Complete performance tracking
-     */
-    async completePerformanceTracking(tracking, session_id, agent_id, operation_name, success, error_message, metadata) {
-        const duration_ms = Date.now() - tracking.startTime;
-        try {
-            this.memory.run(`
-        INSERT INTO performance_metrics 
-        (id, session_id, agent_id, operation_name, duration_ms, success, error_message, metadata)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-      `, [
-                tracking.id,
-                session_id,
-                agent_id,
-                operation_name,
-                duration_ms,
-                success ? 1 : 0,
-                error_message || null,
-                metadata ? JSON.stringify(metadata) : null
-            ]);
-            this.logger.debug('Performance metric recorded', {
-                id: tracking.id,
-                operation_name,
-                duration_ms,
-                success
-            });
-        }
-        catch (error) {
-            this.logger.error('Failed to record performance metric', error);
-            throw error;
-        }
-    }
-    /**
-     * Query performance metrics
-     */
-    async queryPerformanceMetrics(query = {}) {
-        const conditions = [];
-        const params = [];
-        if (query.session_id) {
-            conditions.push('session_id = ?');
-            params.push(query.session_id);
-        }
-        if (query.agent_id) {
-            conditions.push('agent_id = ?');
-            params.push(query.agent_id);
-        }
-        if (query.operation_name) {
-            conditions.push('operation_name = ?');
-            params.push(query.operation_name);
-        }
-        if (query.success !== undefined) {
-            conditions.push('success = ?');
-            params.push(query.success ? 1 : 0);
-        }
-        if (query.start_time) {
-            conditions.push('timestamp >= ?');
-            params.push(query.start_time.toISOString());
-        }
-        if (query.end_time) {
-            conditions.push('timestamp <= ?');
-            params.push(query.end_time.toISOString());
-        }
-        const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
-        const limitClause = query.limit ? `LIMIT ${query.limit}` : '';
-        return this.memory.all(`
-      SELECT * FROM performance_metrics 
-      ${whereClause}
-      ORDER BY timestamp DESC
-      ${limitClause}
-    `, params);
-    }
-    /**
-     * Get average performance for an operation
-     */
-    async getAveragePerformance(operation_name, session_id) {
-        const conditions = ['operation_name = ?'];
-        const params = [operation_name];
-        if (session_id) {
-            conditions.push('session_id = ?');
-            params.push(session_id);
-        }
-        return this.memory.get(`
-      SELECT 
-        AVG(duration_ms) as avg_duration_ms,
-        AVG(CASE WHEN success = 1 THEN 1.0 ELSE 0.0 END) as success_rate,
-        COUNT(*) as total_operations
-      FROM performance_metrics 
-      WHERE ${conditions.join(' AND ')}
-    `, params);
-    }
-    // ==================== Session Management ====================
-    /**
-     * Get complete session state
-     */
-    async getSessionState(session_id) {
-        const agents = await this.getActiveAgents(session_id);
-        const artifacts = await this.searchArtifacts({ session_id });
-        const activeContext = await this.getSessionContext(session_id);
-        const pendingMessages = this.memory.get(`
-      SELECT COUNT(*) as count FROM agent_messages 
-      WHERE session_id = ? AND processed = 0
-    `, [session_id])?.count || 0;
-        const performanceSummary = this.memory.get(`
-      SELECT 
-        COUNT(*) as total_operations,
-        AVG(duration_ms) as avg_duration_ms,
-        MIN(duration_ms) as min_duration_ms,
-        MAX(duration_ms) as max_duration_ms,
-        AVG(CASE WHEN success = 1 THEN 1.0 ELSE 0.0 END) as success_rate
-      FROM performance_metrics 
-      WHERE session_id = ?
-    `, [session_id]);
-        return {
-            agents,
-            artifacts,
-            pendingMessages,
-            activeContext,
-            performanceSummary
-        };
-    }
-    /**
-     * Clean up session data
-     */
-    async cleanupSession(session_id) {
-        this.logger.info('Cleaning up session', { session_id });
-        this.memory.transaction(() => {
-            // Mark all agents as completed
-            this.memory.run(`
-        UPDATE agent_coordination 
-        SET status = 'completed' 
-        WHERE session_id = ? AND status IN ('spawned', 'active', 'blocked')
-      `, [session_id]);
-            // Mark all messages as processed
-            this.memory.run(`
-        UPDATE agent_messages 
-        SET processed = 1 
-        WHERE session_id = ? AND processed = 0
-      `, [session_id]);
-            // Mark all dependencies as satisfied or failed
-            this.memory.run(`
-        UPDATE agent_dependencies 
-        SET status = 'failed' 
-        WHERE session_id = ? AND status = 'pending'
-      `, [session_id]);
-        });
-        this.logger.info('Session cleanup completed', { session_id });
-    }
-}
-exports.MemoryOperations = MemoryOperations;
-//# sourceMappingURL=memory-operations.js.map