agentic-qe 2.5.5 → 2.5.6

package/dist/adapters/MemoryStoreAdapter.js

@@ -2,32 +2,27 @@
 /**
  * MemoryStoreAdapter - Bridges MemoryStore interface to SwarmMemoryManager
  *
- * This adapter provides type-safe compatibility between the MemoryStore interface
- * used by BaseAgent and the SwarmMemoryManager expected by VerificationHookManager.
+ * Issue #65: Updated to match synchronous API.
+ * Note: This adapter provides basic compatibility. For full functionality,
+ * use SwarmMemoryManager directly.
  *
- * Key Features:
- * - Runtime validation of MemoryStore compatibility
- * - Type-safe method delegation
- * - Clear error messages for incompatible implementations
- * - Full SwarmMemoryManager interface implementation
+ * BREAKING CHANGE: Methods now return sync values instead of Promises.
+ * The underlying MemoryStore operations are fire-and-forget for non-blocking calls.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MemoryStoreAdapter = void 0;
 /**
  * Adapter that wraps MemoryStore to provide ISwarmMemoryManager interface
+ * Issue #65: Now provides synchronous API with internal caching
  */
 class MemoryStoreAdapter {
     constructor(memoryStore) {
         this.memoryStore = memoryStore;
         this.initialized = false;
+        this.cache = new Map();
         this.validateCompatibility();
     }
-    /**
-     * Validates that MemoryStore has all required methods
-     * Throws clear error if incompatible
-     */
     validateCompatibility() {
-        // Check if memoryStore is null or undefined
         if (!this.memoryStore || typeof this.memoryStore !== 'object') {
             throw new Error('MemoryStoreAdapter requires a valid MemoryStore instance. ' +
                 `Received: ${this.memoryStore === null ? 'null' : typeof this.memoryStore}. ` +
@@ -45,91 +40,76 @@ class MemoryStoreAdapter {
                 `Cannot create VerificationHookManager with incompatible MemoryStore.`);
         }
     }
-    /**
-     * Initialize adapter (no-op, delegates to underlying MemoryStore)
-     */
     async initialize() {
         this.initialized = true;
     }
-    /**
-     * Store value with options
-     * Maps to MemoryStore.store() with TTL and partition support
-     */
     async store(key, value, options = {}) {
         const partition = options.partition || 'default';
         const namespacedKey = partition !== 'default' ? `${partition}:${key}` : key;
-        await this.memoryStore.store(namespacedKey, value, options.ttl);
+        // Cache locally for sync access
+        this.cache.set(namespacedKey, {
+            value,
+            expiresAt: options.ttl ? Date.now() + options.ttl * 1000 : undefined
+        });
+        // Fire-and-forget to underlying store
+        this.memoryStore.store(namespacedKey, value, options.ttl).catch(() => { });
     }
-    /**
-     * Retrieve value with options
-     * Maps to MemoryStore.retrieve() with partition support
-     */
     async retrieve(key, options = {}) {
         const partition = options.partition || 'default';
         const namespacedKey = partition !== 'default' ? `${partition}:${key}` : key;
+        // Check cache first
+        const cached = this.cache.get(namespacedKey);
+        if (cached) {
+            if (!cached.expiresAt || cached.expiresAt > Date.now()) {
+                return cached.value;
+            }
+            this.cache.delete(namespacedKey);
+        }
+        // Fallback to underlying store
         return await this.memoryStore.retrieve(namespacedKey);
     }
-    /**
-     * Query entries matching pattern
-     * Note: MemoryStore doesn't have native pattern matching,
-     * so this returns empty array as safe fallback
-     */
-    async query(_pattern, _options = {}) {
-        // MemoryStore doesn't support pattern queries
-        // Return empty array as safe fallback
+    query(_pattern, _options = {}) {
         return [];
     }
-    /**
-     * Delete entry
-     * Maps to MemoryStore.delete() with partition support
-     */
-    async delete(key, partition = 'default', _options = {}) {
+    delete(key, partition = 'default', _options = {}) {
         const namespacedKey = partition !== 'default' ? `${partition}:${key}` : key;
-        await this.memoryStore.delete(namespacedKey);
-    }
-    /**
-     * Clear partition
-     * Maps to MemoryStore.clear() with namespace support
-     */
-    async clear(partition = 'default') {
-        await this.memoryStore.clear(partition);
-    }
-    /**
-     * Post hint to blackboard
-     * Stores as regular entry with hint: prefix
-     */
-    async postHint(hint) {
-        await this.memoryStore.store(`hint:${hint.key}`, hint.value, hint.ttl);
-    }
-    /**
-     * Read hints matching pattern
-     * Returns empty array as MemoryStore doesn't support pattern matching
-     */
-    async readHints(_pattern) {
-        // MemoryStore doesn't support pattern queries
+        this.cache.delete(namespacedKey);
+        this.memoryStore.delete(namespacedKey).catch(() => { });
+    }
+    clear(partition = 'default') {
+        // Clear cache entries for partition
+        for (const key of this.cache.keys()) {
+            if (key.startsWith(`${partition}:`) || partition === 'default') {
+                this.cache.delete(key);
+            }
+        }
+        this.memoryStore.clear(partition).catch(() => { });
+    }
+    postHint(hint) {
+        const key = `hint:${hint.key}`;
+        this.cache.set(key, { value: hint.value, expiresAt: hint.ttl ? Date.now() + hint.ttl * 1000 : undefined });
+        this.memoryStore.store(key, hint.value, hint.ttl).catch(() => { });
+    }
+    readHints(_pattern) {
         return [];
     }
-    /**
-     * Clean expired entries
-     * No-op for basic MemoryStore (relies on TTL)
-     */
-    async cleanExpired() {
-        return 0;
+    cleanExpired() {
+        let cleaned = 0;
+        const now = Date.now();
+        for (const [key, entry] of this.cache.entries()) {
+            if (entry.expiresAt && entry.expiresAt < now) {
+                this.cache.delete(key);
+                cleaned++;
+            }
+        }
+        return cleaned;
     }
-    /**
-     * Close connection
-     * No-op for basic MemoryStore
-     */
-    async close() {
-        // No-op
+    close() {
+        this.cache.clear();
     }
-    /**
-     * Get memory statistics
-     * Returns basic stats structure
-     */
-    async stats() {
+    stats() {
         return {
-            totalEntries: 0,
+            totalEntries: this.cache.size,
             totalHints: 0,
             totalEvents: 0,
             totalWorkflows: 0,
@@ -147,74 +127,75 @@ class MemoryStoreAdapter {
             accessLevels: {}
         };
     }
-    // ============================================================================
-    // Table-specific methods (delegated with basic implementation)
-    // ============================================================================
-    async storeEvent(event) {
+    // Event operations
+    storeEvent(event) {
         const id = event.id || `event-${Date.now()}`;
-        await this.store(`events:${id}`, event, { partition: 'events', ttl: event.ttl });
+        this.cache.set(`events:${id}`, { value: event, expiresAt: event.ttl ? Date.now() + event.ttl * 1000 : undefined });
         return id;
     }
-    async queryEvents(_type) {
+    queryEvents(_type) {
         return [];
     }
-    async getEventsBySource(_source) {
+    getEventsBySource(_source) {
         return [];
     }
-    async storeWorkflowState(workflow) {
-        await this.store(`workflow:${workflow.id}`, workflow, { partition: 'workflow_state' });
+    // Workflow operations
+    storeWorkflowState(workflow) {
+        this.cache.set(`workflow:${workflow.id}`, { value: workflow });
     }
-    async getWorkflowState(id) {
-        const data = await this.retrieve(`workflow:${id}`, { partition: 'workflow_state' });
-        if (!data) {
+    getWorkflowState(id) {
+        const entry = this.cache.get(`workflow:${id}`);
+        if (!entry) {
             throw new Error(`Workflow state not found: ${id}`);
         }
-        return data;
+        return entry.value;
     }
-    async updateWorkflowState(id, updates) {
-        const current = await this.getWorkflowState(id);
-        await this.storeWorkflowState({ ...current, ...updates });
+    updateWorkflowState(id, updates) {
+        const current = this.getWorkflowState(id);
+        this.storeWorkflowState({ ...current, ...updates });
     }
-    async queryWorkflowsByStatus(_status) {
+    queryWorkflowsByStatus(_status) {
         return [];
     }
-    async storePattern(pattern) {
+    // Pattern operations
+    storePattern(pattern) {
         const id = pattern.id || `pattern-${Date.now()}`;
-        await this.store(`patterns:${id}`, pattern, { partition: 'patterns', ttl: pattern.ttl });
+        this.cache.set(`patterns:${id}`, { value: pattern, expiresAt: pattern.ttl ? Date.now() + pattern.ttl * 1000 : undefined });
         return id;
     }
-    async getPattern(patternName) {
-        const data = await this.retrieve(`patterns:${patternName}`, { partition: 'patterns' });
-        if (!data) {
+    getPattern(patternName) {
+        const entry = this.cache.get(`patterns:${patternName}`);
+        if (!entry) {
             throw new Error(`Pattern not found: ${patternName}`);
         }
-        return data;
+        return entry.value;
     }
-    async incrementPatternUsage(patternName) {
+    incrementPatternUsage(patternName) {
         try {
-            const pattern = await this.getPattern(patternName);
+            const pattern = this.getPattern(patternName);
             pattern.usageCount++;
-            await this.storePattern(pattern);
+            this.storePattern(pattern);
         }
         catch {
             // Pattern doesn't exist, ignore
         }
     }
-    async queryPatternsByConfidence(_threshold) {
+    queryPatternsByConfidence(_threshold) {
         return [];
     }
-    async createConsensusProposal(proposal) {
-        await this.store(`consensus:${proposal.id}`, proposal, { partition: 'consensus', ttl: proposal.ttl });
+    // Consensus operations
+    createConsensusProposal(proposal) {
+        this.cache.set(`consensus:${proposal.id}`, { value: proposal, expiresAt: proposal.ttl ? Date.now() + proposal.ttl * 1000 : undefined });
     }
-    async getConsensusProposal(id) {
-        const data = await this.retrieve(`consensus:${id}`, { partition: 'consensus' });
-        if (!data) {
+    getConsensusProposal(id) {
+        const entry = this.cache.get(`consensus:${id}`);
+        if (!entry) {
             throw new Error(`Consensus proposal not found: ${id}`);
         }
-        return data;
+        return entry.value;
     }
-    async voteOnConsensus(proposalId, agentId) {
-        const proposal = await this.getConsensusProposal(proposalId);
+    voteOnConsensus(proposalId, agentId) {
+        const proposal = this.getConsensusProposal(proposalId);
         if (!proposal.votes.includes(agentId)) {
             proposal.votes.push(agentId);
         }
@@ -222,135 +203,141 @@ class MemoryStoreAdapter {
         if (approved) {
             proposal.status = 'approved';
         }
-        await this.createConsensusProposal(proposal);
+        this.createConsensusProposal(proposal);
         return approved;
     }
-    async queryConsensusProposals(_status) {
+    queryConsensusProposals(_status) {
         return [];
     }
-    async storePerformanceMetric(metric) {
+    // Performance metrics
+    storePerformanceMetric(metric) {
         const id = metric.id || `metric-${Date.now()}`;
-        await this.store(`metrics:${id}`, metric, { partition: 'performance_metrics' });
+        this.cache.set(`metrics:${id}`, { value: metric });
         return id;
     }
-    async queryPerformanceMetrics(_metricName) {
+    queryPerformanceMetrics(_metricName) {
         return [];
     }
-    async getMetricsByAgent(_agentId) {
+    getMetricsByAgent(_agentId) {
         return [];
     }
-    async getAverageMetric(_metricName) {
+    getAverageMetric(_metricName) {
         return 0;
     }
-    async createArtifact(artifact) {
-        await this.store(`artifact:${artifact.id}`, artifact, { partition: 'artifacts' });
+    // Artifact operations
+    createArtifact(artifact) {
+        this.cache.set(`artifact:${artifact.id}`, { value: artifact });
     }
-    async getArtifact(id) {
-        const data = await this.retrieve(`artifact:${id}`, { partition: 'artifacts' });
-        if (!data) {
+    getArtifact(id) {
+        const entry = this.cache.get(`artifact:${id}`);
+        if (!entry) {
             throw new Error(`Artifact not found: ${id}`);
         }
-        return data;
+        return entry.value;
     }
-    async queryArtifactsByKind(_kind) {
+    queryArtifactsByKind(_kind) {
         return [];
     }
-    async queryArtifactsByTag(_tag) {
+    queryArtifactsByTag(_tag) {
         return [];
     }
-    async createSession(session) {
-        await this.store(`session:${session.id}`, session, { partition: 'sessions' });
+    // Session operations
+    createSession(session) {
+        this.cache.set(`session:${session.id}`, { value: session });
     }
-    async getSession(id) {
-        const data = await this.retrieve(`session:${id}`, { partition: 'sessions' });
-        if (!data) {
+    getSession(id) {
+        const entry = this.cache.get(`session:${id}`);
+        if (!entry) {
             throw new Error(`Session not found: ${id}`);
         }
-        return data;
+        return entry.value;
     }
-    async addSessionCheckpoint(sessionId, checkpoint) {
-        const session = await this.getSession(sessionId);
+    addSessionCheckpoint(sessionId, checkpoint) {
+        const session = this.getSession(sessionId);
         session.checkpoints.push(checkpoint);
-        await this.createSession(session);
+        this.createSession(session);
     }
-    async getLatestCheckpoint(sessionId) {
-        const session = await this.getSession(sessionId);
+    getLatestCheckpoint(sessionId) {
+        const session = this.getSession(sessionId);
         return session.checkpoints.length > 0
             ? session.checkpoints[session.checkpoints.length - 1]
             : undefined;
     }
-    async markSessionResumed(sessionId) {
-        const session = await this.getSession(sessionId);
+    markSessionResumed(sessionId) {
+        const session = this.getSession(sessionId);
         session.lastResumed = Date.now();
-        await this.createSession(session);
+        this.createSession(session);
     }
-    async registerAgent(agent) {
-        await this.store(`agent:${agent.id}`, agent, { partition: 'agent_registry' });
+    // Agent registry
+    registerAgent(agent) {
+        this.cache.set(`agent:${agent.id}`, { value: agent });
     }
-    async getAgent(id) {
-        const data = await this.retrieve(`agent:${id}`, { partition: 'agent_registry' });
-        if (!data) {
+    getAgent(id) {
+        const entry = this.cache.get(`agent:${id}`);
+        if (!entry) {
             throw new Error(`Agent not found: ${id}`);
         }
-        return data;
+        return entry.value;
     }
-    async updateAgentStatus(agentId, status) {
-        const agent = await this.getAgent(agentId);
+    updateAgentStatus(agentId, status) {
+        const agent = this.getAgent(agentId);
         agent.status = status;
         agent.updatedAt = Date.now();
-        await this.registerAgent(agent);
+        this.registerAgent(agent);
     }
-    async queryAgentsByStatus(_status) {
+    queryAgentsByStatus(_status) {
         return [];
     }
-    async updateAgentPerformance(agentId, performance) {
-        const agent = await this.getAgent(agentId);
+    updateAgentPerformance(agentId, performance) {
+        const agent = this.getAgent(agentId);
         agent.performance = performance;
         agent.updatedAt = Date.now();
-        await this.registerAgent(agent);
+        this.registerAgent(agent);
     }
-    async storeGOAPGoal(goal) {
-        await this.store(`goap_goal:${goal.id}`, goal, { partition: 'goap_goals' });
+    // GOAP operations
+    storeGOAPGoal(goal) {
+        this.cache.set(`goap_goal:${goal.id}`, { value: goal });
     }
-    async getGOAPGoal(id) {
-        const data = await this.retrieve(`goap_goal:${id}`, { partition: 'goap_goals' });
-        if (!data) {
+    getGOAPGoal(id) {
+        const entry = this.cache.get(`goap_goal:${id}`);
+        if (!entry) {
             throw new Error(`GOAP goal not found: ${id}`);
         }
-        return data;
+        return entry.value;
     }
-    async storeGOAPAction(action) {
-        await this.store(`goap_action:${action.id}`, action, { partition: 'goap_actions' });
+    storeGOAPAction(action) {
+        this.cache.set(`goap_action:${action.id}`, { value: action });
     }
-    async getGOAPAction(id) {
-        const data = await this.retrieve(`goap_action:${id}`, { partition: 'goap_actions' });
-        if (!data) {
+    getGOAPAction(id) {
+        const entry = this.cache.get(`goap_action:${id}`);
+        if (!entry) {
             throw new Error(`GOAP action not found: ${id}`);
         }
-        return data;
+        return entry.value;
     }
-    async storeGOAPPlan(plan) {
-        await this.store(`goap_plan:${plan.id}`, plan, { partition: 'goap_plans' });
+    storeGOAPPlan(plan) {
+        this.cache.set(`goap_plan:${plan.id}`, { value: plan });
     }
-    async getGOAPPlan(id) {
-        const data = await this.retrieve(`goap_plan:${id}`, { partition: 'goap_plans' });
-        if (!data) {
+    getGOAPPlan(id) {
+        const entry = this.cache.get(`goap_plan:${id}`);
+        if (!entry) {
             throw new Error(`GOAP plan not found: ${id}`);
         }
-        return data;
+        return entry.value;
     }
-    async storeOODACycle(cycle) {
-        await this.store(`ooda_cycle:${cycle.id}`, cycle, { partition: 'ooda_cycles' });
+    // OODA operations
+    storeOODACycle(cycle) {
+        this.cache.set(`ooda_cycle:${cycle.id}`, { value: cycle });
     }
-    async getOODACycle(id) {
-        const data = await this.retrieve(`ooda_cycle:${id}`, { partition: 'ooda_cycles' });
-        if (!data) {
+    getOODACycle(id) {
+        const entry = this.cache.get(`ooda_cycle:${id}`);
+        if (!entry) {
             throw new Error(`OODA cycle not found: ${id}`);
         }
-        return data;
+        return entry.value;
     }
-    async updateOODAPhase(cycleId, phase, data) {
-        const cycle = await this.getOODACycle(cycleId);
+    updateOODAPhase(cycleId, phase, data) {
+        const cycle = this.getOODACycle(cycleId);
         cycle.phase = phase;
         switch (phase) {
             case 'observe':
@@ -366,52 +353,53 @@ class MemoryStoreAdapter {
                 cycle.action = data;
                 break;
         }
-        await this.storeOODACycle(cycle);
+        this.storeOODACycle(cycle);
     }
-    async completeOODACycle(cycleId, result) {
-        const cycle = await this.getOODACycle(cycleId);
+    completeOODACycle(cycleId, result) {
+        const cycle = this.getOODACycle(cycleId);
         cycle.completed = true;
         cycle.result = result;
-        await this.storeOODACycle(cycle);
+        this.storeOODACycle(cycle);
     }
-    async queryOODACyclesByPhase(_phase) {
+    queryOODACyclesByPhase(_phase) {
         return [];
     }
-    // ACL methods (basic implementation)
-    async storeACL(acl) {
-        await this.store(`acl:${acl.resourceId}`, acl, { partition: 'acl' });
+    // ACL operations
+    storeACL(acl) {
+        this.cache.set(`acl:${acl.resourceId}`, { value: acl });
     }
-    async getACL(resourceId) {
-        return await this.retrieve(`acl:${resourceId}`, { partition: 'acl' });
+    getACL(resourceId) {
+        const entry = this.cache.get(`acl:${resourceId}`);
+        return entry?.value || null;
     }
-    async updateACL(resourceId, updates) {
-        const existing = await this.getACL(resourceId);
+    updateACL(resourceId, updates) {
+        const existing = this.getACL(resourceId);
         if (!existing) {
             throw new Error(`ACL not found for resource: ${resourceId}`);
         }
-        await this.storeACL({ ...existing, ...updates });
+        this.storeACL({ ...existing, ...updates });
     }
-    async grantPermission(resourceId, agentId, permissions) {
-        const acl = await this.getACL(resourceId);
+    grantPermission(resourceId, agentId, permissions) {
+        const acl = this.getACL(resourceId);
         if (!acl) {
             throw new Error(`ACL not found for resource: ${resourceId}`);
         }
         acl.grantedPermissions = acl.grantedPermissions || {};
         acl.grantedPermissions[agentId] = permissions;
-        await this.storeACL(acl);
+        this.storeACL(acl);
     }
-    async revokePermission(resourceId, agentId, _permissions) {
-        const acl = await this.getACL(resourceId);
+    revokePermission(resourceId, agentId, _permissions) {
+        const acl = this.getACL(resourceId);
         if (!acl) {
             throw new Error(`ACL not found for resource: ${resourceId}`);
         }
         if (acl.grantedPermissions && acl.grantedPermissions[agentId]) {
             delete acl.grantedPermissions[agentId];
         }
-        await this.storeACL(acl);
+        this.storeACL(acl);
     }
-    async blockAgent(resourceId, agentId) {
-        const acl = await this.getACL(resourceId);
+    blockAgent(resourceId, agentId) {
+        const acl = this.getACL(resourceId);
         if (!acl) {
             throw new Error(`ACL not found for resource: ${resourceId}`);
         }
@@ -419,41 +407,38 @@ class MemoryStoreAdapter {
         if (!acl.blockedAgents.includes(agentId)) {
             acl.blockedAgents.push(agentId);
         }
-        await this.storeACL(acl);
+        this.storeACL(acl);
     }
-    async unblockAgent(resourceId, agentId) {
-        const acl = await this.getACL(resourceId);
+    unblockAgent(resourceId, agentId) {
+        const acl = this.getACL(resourceId);
         if (!acl) {
             throw new Error(`ACL not found for resource: ${resourceId}`);
         }
         if (acl.blockedAgents) {
             acl.blockedAgents = acl.blockedAgents.filter((id) => id !== agentId);
         }
-        await this.storeACL(acl);
+        this.storeACL(acl);
     }
     getAccessControl() {
-        return null; // Not implemented in basic adapter
+        return null;
     }
-    // ============================================================================
-    // Learning Operations (no-op implementations for basic MemoryStore adapter)
-    // ============================================================================
-    async storeLearningExperience(_experience) {
-        // No-op: basic MemoryStore doesn't support learning operations
-        // Use SwarmMemoryManager directly for learning features
+    // Learning operations (no-op for basic adapter)
+    storeLearningExperience(_experience) {
+        // No-op: use SwarmMemoryManager directly for learning features
     }
-    async upsertQValue(_agentId, _stateKey, _actionKey, _qValue) {
-        // No-op: basic MemoryStore doesn't support learning operations
+    upsertQValue(_agentId, _stateKey, _actionKey, _qValue) {
+        // No-op
     }
-    async getAllQValues(_agentId) {
+    getAllQValues(_agentId) {
         return [];
     }
-    async getQValue(_agentId, _stateKey, _actionKey) {
+    getQValue(_agentId, _stateKey, _actionKey) {
         return null;
     }
-    async storeLearningSnapshot(_snapshot) {
-        // No-op: basic MemoryStore doesn't support learning operations
+    storeLearningSnapshot(_snapshot) {
+        // No-op
     }
-    async getLearningHistory(_agentId, _limit) {
+    getLearningHistory(_agentId, _limit) {
         return [];
     }
 }