agentic-qe 1.8.4 → 1.9.1

package/dist/core/memory/SwarmMemoryManager.js

@@ -47,6 +47,8 @@ Object.defineProperty(exports, "Permission", { enumerable: true, get: function (
 Object.defineProperty(exports, "AccessControlError", { enumerable: true, get: function () { return AccessControl_1.AccessControlError; } });
 const AgentDBManager_1 = require("./AgentDBManager");
 const PatternCache_1 = require("./PatternCache");
+const memory_1 = require("../../telemetry/instrumentation/memory");
+const types_1 = require("../../types");
 /**
  * SwarmMemoryManager - Manages persistent memory for agent swarm coordination
  *
@@ -203,6 +205,18 @@ class SwarmMemoryManager {
         agent_id TEXT
       )
     `);
+        // Migration: Add agent_id column if it doesn't exist (for existing databases)
+        // SQLite doesn't support IF NOT EXISTS for columns, so check first
+        try {
+            const tableInfo = this.queryAll(`PRAGMA table_info(patterns)`);
+            const hasAgentId = tableInfo.some(col => col.name === 'agent_id');
+            if (!hasAgentId) {
+                await this.run(`ALTER TABLE patterns ADD COLUMN agent_id TEXT`);
+            }
+        }
+        catch (e) {
+            // Ignore errors - column might already exist
+        }
         // Create indexes for O(log n) pattern queries (Issue #57)
         await this.run(`
       CREATE INDEX IF NOT EXISTS idx_patterns_agent_confidence
@@ -401,6 +415,16 @@ class SwarmMemoryManager {
         await this.run(`CREATE INDEX IF NOT EXISTS idx_learning_metrics_agent ON learning_metrics(agent_id)`);
         this.initialized = true;
     }
+    /**
+     * Store a key-value pair in memory with OpenTelemetry instrumentation
+     *
+     * Automatically instruments the memory store operation with distributed tracing.
+     * Records namespace, key, value size, TTL, and operation performance metrics.
+     *
+     * @param key - Memory key
+     * @param value - Value to store (will be JSON serialized)
+     * @param options - Store options including partition, TTL, access control
+     */
     async store(key, value, options = {}) {
         // Auto-initialize if not initialized
         if (!this.initialized) {
@@ -412,44 +436,73 @@ class SwarmMemoryManager {
         const partition = options.partition || 'default';
         const owner = options.owner || 'system';
         const accessLevel = options.accessLevel || AccessControl_1.AccessLevel.PRIVATE;
-        const createdAt = Date.now();
-        const expiresAt = options.ttl ? createdAt + (options.ttl * 1000) : null;
-        const metadata = options.metadata ? JSON.stringify(options.metadata) : null;
-        // Check write permission if updating existing entry
-        const existing = await this.queryOne(`SELECT owner, access_level, team_id, swarm_id FROM memory_entries WHERE key = ? AND partition = ?`, [key, partition]);
-        if (existing && options.owner) {
-            // Verify write permission
-            const permCheck = this.accessControl.checkPermission({
-                agentId: options.owner,
-                resourceOwner: existing.owner,
-                accessLevel: existing.access_level,
-                permission: AccessControl_1.Permission.WRITE,
-                teamId: options.teamId,
-                resourceTeamId: existing.team_id,
-                swarmId: options.swarmId,
-                resourceSwarmId: existing.swarm_id
-            });
-            if (!permCheck.allowed) {
-                throw new AccessControl_1.AccessControlError(`Write denied: ${permCheck.reason}`);
+        const valueJson = JSON.stringify(value);
+        const valueSize = valueJson.length;
+        // Create instrumentation span
+        const { span, context: spanContext } = memory_1.memorySpanManager.startStoreSpan({
+            agentId: { id: owner, type: types_1.QEAgentType.FLEET_COMMANDER, created: new Date() },
+            namespace: partition,
+            key,
+            valueSize,
+            ttl: options.ttl,
+        });
+        const startTime = Date.now();
+        try {
+            const createdAt = Date.now();
+            const expiresAt = options.ttl ? createdAt + (options.ttl * 1000) : null;
+            const metadata = options.metadata ? JSON.stringify(options.metadata) : null;
+            // Check write permission if updating existing entry
+            const existing = await this.queryOne(`SELECT owner, access_level, team_id, swarm_id FROM memory_entries WHERE key = ? AND partition = ?`, [key, partition]);
+            if (existing && options.owner) {
+                // Verify write permission
+                const permCheck = this.accessControl.checkPermission({
+                    agentId: options.owner,
+                    resourceOwner: existing.owner,
+                    accessLevel: existing.access_level,
+                    permission: AccessControl_1.Permission.WRITE,
+                    teamId: options.teamId,
+                    resourceTeamId: existing.team_id,
+                    swarmId: options.swarmId,
+                    resourceSwarmId: existing.swarm_id
+                });
+                if (!permCheck.allowed) {
+                    throw new AccessControl_1.AccessControlError(`Write denied: ${permCheck.reason}`);
+                }
             }
+            await this.run(`INSERT OR REPLACE INTO memory_entries
+         (key, partition, value, metadata, created_at, expires_at, owner, access_level, team_id, swarm_id)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+                key,
+                partition,
+                valueJson,
+                metadata,
+                createdAt,
+                expiresAt,
+                owner,
+                accessLevel,
+                options.teamId || null,
+                options.swarmId || null
+            ]);
+            // Track modification for QUIC sync
+            const entryKey = `${partition}:${key}`;
+            this.lastModifiedTimestamps.set(entryKey, createdAt);
+            // Complete span successfully
+            const durationMs = Date.now() - startTime;
+            memory_1.memorySpanManager.completeStoreSpan(span, {
+                success: true,
+                durationMs,
+            });
+        }
+        catch (error) {
+            // Complete span with error
+            const durationMs = Date.now() - startTime;
+            memory_1.memorySpanManager.completeStoreSpan(span, {
+                success: false,
+                durationMs,
+                error: error,
+            });
+            throw error;
         }
-        await this.run(`INSERT OR REPLACE INTO memory_entries
-       (key, partition, value, metadata, created_at, expires_at, owner, access_level, team_id, swarm_id)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
-            key,
-            partition,
-            JSON.stringify(value),
-            metadata,
-            createdAt,
-            expiresAt,
-            owner,
-            accessLevel,
-            options.teamId || null,
-            options.swarmId || null
-        ]);
-        // Track modification for QUIC sync
-        const entryKey = `${partition}:${key}`;
-        this.lastModifiedTimestamps.set(entryKey, createdAt);
     }
     /**
      * Alias for store() method to maintain compatibility with MemoryStore interface
@@ -473,6 +526,16 @@ class SwarmMemoryManager {
         }
         return this.retrieve(key, options);
     }
+    /**
+     * Retrieve a value from memory with OpenTelemetry instrumentation
+     *
+     * Automatically instruments the memory retrieve operation with distributed tracing.
+     * Records namespace, key, whether the value was found, value size, and performance metrics.
+     *
+     * @param key - Memory key
+     * @param options - Retrieve options including partition, agentId for access control
+     * @returns Retrieved value or null if not found
+     */
     async retrieve(key, options = {}) {
         // Auto-initialize if not initialized
         if (!this.initialized) {
@@ -482,55 +545,35 @@ class SwarmMemoryManager {
             throw new Error('Memory manager not initialized. Call initialize() first.');
         }
         const partition = options.partition || 'default';
-        const now = Date.now();
-        let query = `SELECT value, owner, access_level, team_id, swarm_id
-                 FROM memory_entries WHERE key = ? AND partition = ?`;
-        const params = [key, partition];
-        if (!options.includeExpired) {
-            query += ` AND (expires_at IS NULL OR expires_at > ?)`;
-            params.push(now);
-        }
-        const row = await this.queryOne(query, params);
-        if (!row) {
-            return null;
-        }
-        // Check read permission if agentId provided
-        if (options.agentId) {
-            const permCheck = this.accessControl.checkPermission({
-                agentId: options.agentId,
-                resourceOwner: row.owner,
-                accessLevel: row.access_level,
-                permission: AccessControl_1.Permission.READ,
-                teamId: options.teamId,
-                resourceTeamId: row.team_id,
-                swarmId: options.swarmId,
-                resourceSwarmId: row.swarm_id,
-                isSystemAgent: options.isSystemAgent
-            });
-            if (!permCheck.allowed) {
-                throw new AccessControl_1.AccessControlError(`Read denied: ${permCheck.reason}`);
+        const agentId = options.agentId || 'system';
+        // Create instrumentation span
+        const { span, context: spanContext } = memory_1.memorySpanManager.startRetrieveSpan({
+            agentId: { id: agentId, type: types_1.QEAgentType.FLEET_COMMANDER, created: new Date() },
+            namespace: partition,
+            key,
+        });
+        const startTime = Date.now();
+        try {
+            const now = Date.now();
+            let query = `SELECT value, owner, access_level, team_id, swarm_id
+                   FROM memory_entries WHERE key = ? AND partition = ?`;
+            const params = [key, partition];
+            if (!options.includeExpired) {
+                query += ` AND (expires_at IS NULL OR expires_at > ?)`;
+                params.push(now);
             }
-        }
-        return JSON.parse(row.value);
-    }
-    async query(pattern, options = {}) {
-        if (!this.db) {
-            throw new Error('Memory manager not initialized');
-        }
-        const partition = options.partition || 'default';
-        const now = Date.now();
-        let query = `SELECT key, value, partition, created_at, expires_at, owner, access_level, team_id, swarm_id
-                 FROM memory_entries
-                 WHERE partition = ? AND key LIKE ?`;
-        const params = [partition, pattern];
-        if (!options.includeExpired) {
-            query += ` AND (expires_at IS NULL OR expires_at > ?)`;
-            params.push(now);
-        }
-        const rows = await this.queryAll(query, params);
-        // Filter by access control if agentId provided
-        const filteredRows = options.agentId
-            ? rows.filter((row) => {
+            const row = await this.queryOne(query, params);
+            if (!row) {
+                // Complete span - not found
+                const durationMs = Date.now() - startTime;
+                memory_1.memorySpanManager.completeRetrieveSpan(span, {
+                    found: false,
+                    durationMs,
+                });
+                return null;
+            }
+            // Check read permission if agentId provided
+            if (options.agentId) {
                 const permCheck = this.accessControl.checkPermission({
                     agentId: options.agentId,
                     resourceOwner: row.owner,
@@ -542,50 +585,178 @@ class SwarmMemoryManager {
                     resourceSwarmId: row.swarm_id,
                     isSystemAgent: options.isSystemAgent
                 });
-                return permCheck.allowed;
-            })
-            : rows;
-        return filteredRows.map((row) => ({
-            key: row.key,
-            value: JSON.parse(row.value),
-            partition: row.partition,
-            createdAt: row.created_at,
-            expiresAt: row.expires_at,
-            owner: row.owner,
-            accessLevel: row.access_level,
-            teamId: row.team_id,
-            swarmId: row.swarm_id
-        }));
+                if (!permCheck.allowed) {
+                    throw new AccessControl_1.AccessControlError(`Read denied: ${permCheck.reason}`);
+                }
+            }
+            const valueSize = row.value.length;
+            const parsedValue = JSON.parse(row.value);
+            // Complete span successfully
+            const durationMs = Date.now() - startTime;
+            memory_1.memorySpanManager.completeRetrieveSpan(span, {
+                found: true,
+                valueSize,
+                durationMs,
+            });
+            return parsedValue;
+        }
+        catch (error) {
+            // Complete span with error
+            const durationMs = Date.now() - startTime;
+            memory_1.memorySpanManager.completeRetrieveSpan(span, {
+                found: false,
+                durationMs,
+                error: error,
+            });
+            throw error;
+        }
+    }
+    /**
+     * Query/search memory entries by pattern with OpenTelemetry instrumentation
+     *
+     * Automatically instruments the memory search operation with distributed tracing.
+     * Records namespace, search pattern, result count, and performance metrics.
+     *
+     * @param pattern - SQL LIKE pattern for key matching
+     * @param options - Retrieve options including partition, agentId for access control
+     * @returns Array of matching memory entries
+     */
+    async query(pattern, options = {}) {
+        if (!this.db) {
+            throw new Error('Memory manager not initialized');
+        }
+        const partition = options.partition || 'default';
+        const agentId = options.agentId || 'system';
+        // Create instrumentation span
+        const { span, context: spanContext } = memory_1.memorySpanManager.startSearchSpan({
+            agentId: { id: agentId, type: types_1.QEAgentType.FLEET_COMMANDER, created: new Date() },
+            namespace: partition,
+            pattern,
+        });
+        const startTime = Date.now();
+        try {
+            const now = Date.now();
+            let query = `SELECT key, value, partition, created_at, expires_at, owner, access_level, team_id, swarm_id
+                   FROM memory_entries
+                   WHERE partition = ? AND key LIKE ?`;
+            const params = [partition, pattern];
+            if (!options.includeExpired) {
+                query += ` AND (expires_at IS NULL OR expires_at > ?)`;
+                params.push(now);
+            }
+            const rows = await this.queryAll(query, params);
+            // Filter by access control if agentId provided
+            const filteredRows = options.agentId
+                ? rows.filter((row) => {
+                    const permCheck = this.accessControl.checkPermission({
+                        agentId: options.agentId,
+                        resourceOwner: row.owner,
+                        accessLevel: row.access_level,
+                        permission: AccessControl_1.Permission.READ,
+                        teamId: options.teamId,
+                        resourceTeamId: row.team_id,
+                        swarmId: options.swarmId,
+                        resourceSwarmId: row.swarm_id,
+                        isSystemAgent: options.isSystemAgent
+                    });
+                    return permCheck.allowed;
+                })
+                : rows;
+            const results = filteredRows.map((row) => ({
+                key: row.key,
+                value: JSON.parse(row.value),
+                partition: row.partition,
+                createdAt: row.created_at,
+                expiresAt: row.expires_at,
+                owner: row.owner,
+                accessLevel: row.access_level,
+                teamId: row.team_id,
+                swarmId: row.swarm_id
+            }));
+            // Complete span successfully
+            const durationMs = Date.now() - startTime;
+            memory_1.memorySpanManager.completeSearchSpan(span, {
+                resultCount: results.length,
+                durationMs,
+            });
+            return results;
+        }
+        catch (error) {
+            // Complete span with error
+            const durationMs = Date.now() - startTime;
+            memory_1.memorySpanManager.completeSearchSpan(span, {
+                resultCount: 0,
+                durationMs,
+                error: error,
+            });
+            throw error;
+        }
     }
+    /**
+     * Delete a key from memory with OpenTelemetry instrumentation
+     *
+     * Automatically instruments the memory delete operation with distributed tracing.
+     * Records namespace, key, and operation performance metrics.
+     *
+     * @param key - Memory key to delete
+     * @param partition - Memory partition (namespace)
+     * @param options - Delete options including agentId for access control
+     */
     async delete(key, partition = 'default', options = {}) {
         if (!this.db) {
             throw new Error('Memory manager not initialized');
         }
-        // Check delete permission if agentId provided
-        if (options.agentId) {
-            const row = await this.queryOne(`SELECT owner, access_level, team_id, swarm_id FROM memory_entries WHERE key = ? AND partition = ?`, [key, partition]);
-            if (row) {
-                const permCheck = this.accessControl.checkPermission({
-                    agentId: options.agentId,
-                    resourceOwner: row.owner,
-                    accessLevel: row.access_level,
-                    permission: AccessControl_1.Permission.DELETE,
-                    teamId: options.teamId,
-                    resourceTeamId: row.team_id,
-                    swarmId: options.swarmId,
-                    resourceSwarmId: row.swarm_id,
-                    isSystemAgent: options.isSystemAgent
-                });
-                if (!permCheck.allowed) {
-                    throw new AccessControl_1.AccessControlError(`Delete denied: ${permCheck.reason}`);
+        const agentId = options.agentId || 'system';
+        // Create instrumentation span
+        const { span, context: spanContext } = memory_1.memorySpanManager.startDeleteSpan({
+            agentId: { id: agentId, type: types_1.QEAgentType.FLEET_COMMANDER, created: new Date() },
+            namespace: partition,
+            key,
+        });
+        const startTime = Date.now();
+        try {
+            // Check delete permission if agentId provided
+            if (options.agentId) {
+                const row = await this.queryOne(`SELECT owner, access_level, team_id, swarm_id FROM memory_entries WHERE key = ? AND partition = ?`, [key, partition]);
+                if (row) {
+                    const permCheck = this.accessControl.checkPermission({
+                        agentId: options.agentId,
+                        resourceOwner: row.owner,
+                        accessLevel: row.access_level,
+                        permission: AccessControl_1.Permission.DELETE,
+                        teamId: options.teamId,
+                        resourceTeamId: row.team_id,
+                        swarmId: options.swarmId,
+                        resourceSwarmId: row.swarm_id,
+                        isSystemAgent: options.isSystemAgent
+                    });
+                    if (!permCheck.allowed) {
+                        throw new AccessControl_1.AccessControlError(`Delete denied: ${permCheck.reason}`);
+                    }
                 }
             }
+            await this.run(`DELETE FROM memory_entries WHERE key = ? AND partition = ?`, [key, partition]);
+            // Clean up ACL if exists
+            const resourceId = `${partition}:${key}`;
+            await this.run(`DELETE FROM memory_acl WHERE resource_id = ?`, [resourceId]);
+            this.aclCache.delete(resourceId);
+            // Complete span successfully
+            const durationMs = Date.now() - startTime;
+            memory_1.memorySpanManager.completeDeleteSpan(span, {
+                success: true,
+                durationMs,
+            });
+        }
+        catch (error) {
+            // Complete span with error
+            const durationMs = Date.now() - startTime;
+            memory_1.memorySpanManager.completeDeleteSpan(span, {
+                success: false,
+                durationMs,
+                error: error,
+            });
+            throw error;
         }
-        await this.run(`DELETE FROM memory_entries WHERE key = ? AND partition = ?`, [key, partition]);
-        // Clean up ACL if exists
-        const resourceId = `${partition}:${key}`;
-        await this.run(`DELETE FROM memory_acl WHERE resource_id = ?`, [resourceId]);
-        this.aclCache.delete(resourceId);
     }
     async clear(partition = 'default') {
         if (!this.db) {