agentic-qe 1.9.3 → 2.0.0

package/dist/core/memory/UnifiedMemoryCoordinator.js

@@ -0,0 +1,986 @@
+"use strict";
+/**
+ * UnifiedMemoryCoordinator - Single interface for all memory systems
+ *
+ * Integrates:
+ * - SwarmMemoryManager (cross-agent coordination with SQLite)
+ * - AgentDBService (vector database operations)
+ * - RuVectorPatternStore (high-performance pattern storage)
+ *
+ * Features:
+ * - Automatic SQLite ↔ JSON fallback
+ * - Memory health monitoring
+ * - Unified namespace management
+ * - Cross-system synchronization
+ * - Transparent backend switching
+ * - Metrics collection
+ *
+ * @module core/memory/UnifiedMemoryCoordinator
+ * @version 1.0.0
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NamespacedCoordinator = exports.UnifiedMemoryCoordinator = void 0;
+exports.createUnifiedMemoryCoordinator = createUnifiedMemoryCoordinator;
+const Logger_1 = require("../../utils/Logger");
+const SwarmMemoryManager_1 = require("./SwarmMemoryManager");
+const AgentDBService_1 = require("./AgentDBService");
+const RuVectorPatternStore_1 = require("./RuVectorPatternStore");
+const RuVectorPatternStore_2 = require("./RuVectorPatternStore");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs-extra"));
+/**
+ * UnifiedMemoryCoordinator - Unified interface for all memory systems
+ */
+class UnifiedMemoryCoordinator {
+    constructor(config = {}) {
+        this.logger = Logger_1.Logger.getInstance();
+        this.config = {
+            preferredBackend: config.preferredBackend ?? 'auto',
+            enableFallback: config.enableFallback ?? true,
+            syncInterval: config.syncInterval ?? 60000, // 1 minute
+            healthCheckInterval: config.healthCheckInterval ?? 30000, // 30 seconds
+            maxRetries: config.maxRetries ?? 3,
+            namespace: config.namespace ?? 'default',
+            dbPaths: config.dbPaths ?? {},
+            enableVectorOps: config.enableVectorOps ?? true,
+            vectorDimension: config.vectorDimension ?? 384,
+        };
+        this.jsonStore = new Map();
+        this.healthStatus = new Map();
+        this.syncInProgress = false;
+        this.activeBackend = 'json'; // Start with fallback
+        this.fallbackChain = [];
+        this.metrics = {
+            totalOperations: 0,
+            operationsByBackend: new Map(),
+            averageLatency: 0,
+            failoverCount: 0,
+            cacheHitRate: 0,
+            syncCount: 0,
+            errorCount: 0,
+        };
+    }
+    /**
+     * Initialize the memory coordinator
+     */
+    async initialize() {
+        this.logger.info('Initializing UnifiedMemoryCoordinator...');
+        try {
+            // Detect available backends
+            const availableBackends = await this.detectAvailableBackends();
+            this.logger.info('Available backends:', availableBackends);
+            // Initialize SwarmMemoryManager (always available)
+            await this.initializeSwarmMemory();
+            // Initialize AgentDB if available
+            if (availableBackends.includes('agentdb')) {
+                await this.initializeAgentDB();
+            }
+            // Initialize RuVector if available
+            if (availableBackends.includes('vector') && this.config.enableVectorOps) {
+                await this.initializeVectorStore();
+            }
+            // Select optimal backend
+            this.activeBackend = await this.selectOptimalBackend();
+            this.logger.info(`Active backend: ${this.activeBackend}`);
+            // Build fallback chain
+            this.fallbackChain = this.buildFallbackChain(this.activeBackend);
+            this.logger.info('Fallback chain:', this.fallbackChain);
+            // Start health monitoring
+            this.startHealthMonitoring();
+            // Start periodic sync
+            if (this.config.syncInterval > 0) {
+                this.startPeriodicSync();
+            }
+            this.logger.info('UnifiedMemoryCoordinator initialized successfully');
+        }
+        catch (error) {
+            this.logger.error('Failed to initialize UnifiedMemoryCoordinator:', error);
+            throw error;
+        }
+    }
+    /**
+     * Detect available backends
+     */
+    async detectAvailableBackends() {
+        const backends = [];
+        // SQLite is always available via SwarmMemoryManager
+        backends.push('sqlite');
+        // Check AgentDB
+        try {
+            require('agentdb');
+            backends.push('agentdb');
+        }
+        catch {
+            this.logger.debug('AgentDB not available');
+        }
+        // Check RuVector
+        if ((0, RuVectorPatternStore_2.isRuVectorAvailable)()) {
+            backends.push('vector');
+        }
+        else {
+            this.logger.debug('RuVector not available');
+        }
+        // JSON is always available as fallback
+        backends.push('json');
+        return backends;
+    }
+    /**
+     * Initialize SwarmMemoryManager
+     */
+    async initializeSwarmMemory() {
+        try {
+            const dbPath = this.config.dbPaths?.swarm ??
+                path.join(process.cwd(), '.agentic-qe', 'memory.db');
+            await fs.ensureDir(path.dirname(dbPath));
+            this.swarmMemory = new SwarmMemoryManager_1.SwarmMemoryManager(dbPath);
+            await this.swarmMemory.initialize();
+            this.updateHealthStatus('sqlite', {
+                backend: 'sqlite',
+                status: 'healthy',
+                latency: 0,
+                lastCheck: new Date(),
+                errorCount: 0,
+                details: { dbPath },
+            });
+            this.logger.debug('SwarmMemoryManager initialized');
+        }
+        catch (error) {
+            this.logger.error('Failed to initialize SwarmMemoryManager:', error);
+            this.updateHealthStatus('sqlite', {
+                backend: 'sqlite',
+                status: 'failed',
+                latency: 0,
+                lastCheck: new Date(),
+                errorCount: 1,
+                details: { error: String(error) },
+            });
+            throw error;
+        }
+    }
+    /**
+     * Initialize AgentDB
+     */
+    async initializeAgentDB() {
+        try {
+            const dbPath = this.config.dbPaths?.agentdb ??
+                path.join(process.cwd(), '.agentic-qe', 'agentdb.db');
+            this.agentDB = new AgentDBService_1.AgentDBService({
+                dbPath,
+                embeddingDim: this.config.vectorDimension,
+                enableHNSW: true,
+                enableCache: true,
+            });
+            await this.agentDB.initialize();
+            this.updateHealthStatus('agentdb', {
+                backend: 'agentdb',
+                status: 'healthy',
+                latency: 0,
+                lastCheck: new Date(),
+                errorCount: 0,
+                details: { dbPath },
+            });
+            this.logger.debug('AgentDB initialized');
+        }
+        catch (error) {
+            this.logger.error('Failed to initialize AgentDB:', error);
+            this.updateHealthStatus('agentdb', {
+                backend: 'agentdb',
+                status: 'failed',
+                latency: 0,
+                lastCheck: new Date(),
+                errorCount: 1,
+                details: { error: String(error) },
+            });
+        }
+    }
+    /**
+     * Initialize RuVector store
+     */
+    async initializeVectorStore() {
+        try {
+            const dbPath = this.config.dbPaths?.ruvector ??
+                path.join(process.cwd(), '.agentic-qe', 'vectors.db');
+            this.vectorStore = new RuVectorPatternStore_1.RuVectorPatternStore({
+                dimension: this.config.vectorDimension,
+                metric: 'cosine',
+                storagePath: dbPath,
+                autoPersist: true,
+                enableMetrics: true,
+            });
+            await this.vectorStore.initialize();
+            this.updateHealthStatus('vector', {
+                backend: 'vector',
+                status: 'healthy',
+                latency: 0,
+                lastCheck: new Date(),
+                errorCount: 0,
+                details: { dbPath },
+            });
+            this.logger.debug('RuVector store initialized');
+        }
+        catch (error) {
+            this.logger.error('Failed to initialize RuVector store:', error);
+            this.updateHealthStatus('vector', {
+                backend: 'vector',
+                status: 'failed',
+                latency: 0,
+                lastCheck: new Date(),
+                errorCount: 1,
+                details: { error: String(error) },
+            });
+        }
+    }
+    /**
+     * Select optimal backend
+     */
+    async selectOptimalBackend() {
+        if (this.config.preferredBackend !== 'auto') {
+            const health = this.healthStatus.get(this.config.preferredBackend);
+            if (health && health.status === 'healthy') {
+                return this.config.preferredBackend;
+            }
+        }
+        // Auto-select based on health and capabilities
+        const priorities = ['sqlite', 'agentdb', 'vector', 'json'];
+        for (const backend of priorities) {
+            const health = this.healthStatus.get(backend);
+            if (health && health.status === 'healthy') {
+                return backend;
+            }
+        }
+        // Fallback to JSON
+        return 'json';
+    }
+    /**
+     * Build fallback chain
+     */
+    buildFallbackChain(primary) {
+        const chain = [primary];
+        const alternatives = ['sqlite', 'agentdb', 'vector', 'json'];
+        for (const backend of alternatives) {
+            if (backend !== primary) {
+                const health = this.healthStatus.get(backend);
+                if (health && health.status !== 'failed') {
+                    chain.push(backend);
+                }
+            }
+        }
+        // Always have JSON as final fallback
+        if (!chain.includes('json')) {
+            chain.push('json');
+        }
+        return chain;
+    }
+    /**
+     * Store a key-value pair
+     */
+    async store(key, value, ttl) {
+        const startTime = Date.now();
+        const fullKey = this.prefixKey(key);
+        try {
+            await this.executeWithFallback(async (backend) => {
+                await this.storeInBackend(backend, fullKey, value, ttl);
+            });
+            this.updateMetrics('store', startTime, this.activeBackend);
+        }
+        catch (error) {
+            this.logger.error(`Failed to store key ${fullKey}:`, error);
+            this.metrics.errorCount++;
+            throw error;
+        }
+    }
+    /**
+     * Store in specific backend
+     */
+    async storeInBackend(backend, key, value, ttl) {
+        switch (backend) {
+            case 'sqlite':
+                await this.swarmMemory.store(key, value, { ttl, partition: this.config.namespace });
+                break;
+            case 'agentdb':
+                // AgentDB stores patterns, not key-value pairs
+                // Fall through to JSON for key-value storage
+                throw new Error('AgentDB not suitable for key-value storage');
+            case 'json':
+                this.jsonStore.set(key, {
+                    value,
+                    ttl,
+                    createdAt: Date.now(),
+                });
+                break;
+            default:
+                throw new Error(`Unknown backend: ${backend}`);
+        }
+    }
+    /**
+     * Retrieve a value by key
+     */
+    async retrieve(key) {
+        const startTime = Date.now();
+        const fullKey = this.prefixKey(key);
+        try {
+            const result = await this.executeWithFallback(async (backend) => {
+                return await this.retrieveFromBackend(backend, fullKey);
+            });
+            this.updateMetrics('retrieve', startTime, this.activeBackend);
+            return result;
+        }
+        catch (error) {
+            this.logger.error(`Failed to retrieve key ${fullKey}:`, error);
+            this.metrics.errorCount++;
+            return null;
+        }
+    }
+    /**
+     * Retrieve from specific backend
+     */
+    async retrieveFromBackend(backend, key) {
+        switch (backend) {
+            case 'sqlite':
+                return await this.swarmMemory.retrieve(key, { partition: this.config.namespace });
+            case 'json': {
+                const entry = this.jsonStore.get(key);
+                if (!entry)
+                    return null;
+                // Check TTL
+                if (entry.ttl && Date.now() - entry.createdAt > entry.ttl * 1000) {
+                    this.jsonStore.delete(key);
+                    return null;
+                }
+                return entry.value;
+            }
+            default:
+                throw new Error(`Backend ${backend} not suitable for key-value retrieval`);
+        }
+    }
+    /**
+     * Delete a key
+     */
+    async delete(key) {
+        const startTime = Date.now();
+        const fullKey = this.prefixKey(key);
+        try {
+            const result = await this.executeWithFallback(async (backend) => {
+                return await this.deleteFromBackend(backend, fullKey);
+            });
+            this.updateMetrics('delete', startTime, this.activeBackend);
+            return result;
+        }
+        catch (error) {
+            this.logger.error(`Failed to delete key ${fullKey}:`, error);
+            this.metrics.errorCount++;
+            return false;
+        }
+    }
+    /**
+     * Delete from specific backend
+     */
+    async deleteFromBackend(backend, key) {
+        switch (backend) {
+            case 'sqlite':
+                await this.swarmMemory.delete(key, this.config.namespace);
+                return true;
+            case 'json':
+                return this.jsonStore.delete(key);
+            default:
+                return false;
+        }
+    }
+    /**
+     * Check if key exists
+     */
+    async exists(key) {
+        const value = await this.retrieve(key);
+        return value !== null;
+    }
+    /**
+     * List keys matching pattern
+     */
+    async list(pattern) {
+        const startTime = Date.now();
+        try {
+            const result = await this.executeWithFallback(async (backend) => {
+                return await this.listFromBackend(backend, pattern);
+            });
+            this.updateMetrics('list', startTime, this.activeBackend);
+            return result;
+        }
+        catch (error) {
+            this.logger.error('Failed to list keys:', error);
+            this.metrics.errorCount++;
+            return [];
+        }
+    }
+    /**
+     * List from specific backend
+     */
+    async listFromBackend(backend, pattern) {
+        switch (backend) {
+            case 'sqlite': {
+                const sqlPattern = pattern ? pattern.replace(/\*/g, '%') : '%';
+                const entries = await this.swarmMemory.query(sqlPattern, { partition: this.config.namespace });
+                return entries.map(e => e.key);
+            }
+            case 'json': {
+                const keys = Array.from(this.jsonStore.keys());
+                if (!pattern)
+                    return keys;
+                const regex = new RegExp(pattern.replace(/\*/g, '.*'));
+                return keys.filter(k => regex.test(k));
+            }
+            default:
+                return [];
+        }
+    }
+    /**
+     * Search for entries
+     */
+    async search(query, options = {}) {
+        const startTime = Date.now();
+        try {
+            const results = await this.executeWithFallback(async (backend) => {
+                return await this.searchInBackend(backend, query, options);
+            });
+            this.updateMetrics('search', startTime, this.activeBackend);
+            return results;
+        }
+        catch (error) {
+            this.logger.error('Failed to search:', error);
+            this.metrics.errorCount++;
+            return [];
+        }
+    }
+    /**
+     * Search in specific backend
+     */
+    async searchInBackend(backend, query, options) {
+        switch (backend) {
+            case 'sqlite': {
+                const sqlPattern = `%${query}%`;
+                const entries = await this.swarmMemory.query(sqlPattern, { partition: this.config.namespace });
+                const keys = entries.map(e => e.key);
+                const results = [];
+                for (const key of keys.slice(options.offset ?? 0, (options.offset ?? 0) + (options.limit ?? 10))) {
+                    const value = await this.swarmMemory.retrieve(key, { partition: this.config.namespace });
+                    if (value) {
+                        results.push({ key, value, backend: 'sqlite' });
+                    }
+                }
+                return results;
+            }
+            case 'json': {
+                const results = [];
+                const limit = options.limit ?? 10;
+                const offset = options.offset ?? 0;
+                let count = 0;
+                for (const [key, entry] of this.jsonStore.entries()) {
+                    if (key.includes(query)) {
+                        if (count >= offset && count < offset + limit) {
+                            results.push({ key, value: entry.value, backend: 'json' });
+                        }
+                        count++;
+                    }
+                }
+                return results;
+            }
+            default:
+                return [];
+        }
+    }
+    /**
+     * Store multiple entries in batch
+     */
+    async storeBatch(entries) {
+        const startTime = Date.now();
+        try {
+            await this.executeWithFallback(async (backend) => {
+                for (const entry of entries) {
+                    const fullKey = this.prefixKey(entry.key);
+                    await this.storeInBackend(backend, fullKey, entry.value, entry.ttl);
+                }
+            });
+            this.updateMetrics('storeBatch', startTime, this.activeBackend);
+        }
+        catch (error) {
+            this.logger.error('Failed to store batch:', error);
+            this.metrics.errorCount++;
+            throw error;
+        }
+    }
+    /**
+     * Retrieve multiple entries in batch
+     */
+    async retrieveBatch(keys) {
+        const startTime = Date.now();
+        const results = new Map();
+        try {
+            await this.executeWithFallback(async (backend) => {
+                for (const key of keys) {
+                    const fullKey = this.prefixKey(key);
+                    const value = await this.retrieveFromBackend(backend, fullKey);
+                    results.set(key, value);
+                }
+            });
+            this.updateMetrics('retrieveBatch', startTime, this.activeBackend);
+            return results;
+        }
+        catch (error) {
+            this.logger.error('Failed to retrieve batch:', error);
+            this.metrics.errorCount++;
+            return results;
+        }
+    }
+    /**
+     * Store a vector
+     */
+    async storeVector(key, vector, metadata) {
+        if (!this.vectorStore) {
+            throw new Error('Vector operations not enabled');
+        }
+        const pattern = {
+            id: this.prefixKey(key),
+            type: 'vector',
+            domain: this.config.namespace,
+            content: '',
+            embedding: vector,
+            metadata,
+        };
+        await this.vectorStore.storePattern(pattern);
+    }
+    /**
+     * Search for similar vectors
+     */
+    async searchSimilar(vector, limit = 10) {
+        if (!this.vectorStore) {
+            throw new Error('Vector operations not enabled');
+        }
+        const results = await this.vectorStore.searchSimilar(vector, { k: limit });
+        return results.map(r => ({
+            key: r.pattern.id,
+            similarity: r.score,
+            metadata: r.pattern.metadata,
+            vector: r.pattern.embedding,
+        }));
+    }
+    /**
+     * Store a pattern
+     */
+    async storePattern(pattern) {
+        if (this.vectorStore && pattern.embedding) {
+            const testPattern = {
+                id: pattern.id,
+                type: pattern.type,
+                domain: this.config.namespace,
+                content: pattern.content,
+                embedding: pattern.embedding,
+                metadata: pattern.metadata,
+            };
+            await this.vectorStore.storePattern(testPattern);
+        }
+        else {
+            // Store as key-value
+            await this.store(`pattern:${pattern.id}`, pattern);
+        }
+    }
+    /**
+     * Query patterns
+     */
+    async queryPatterns(filter) {
+        const results = [];
+        if (this.vectorStore) {
+            // Use vector store
+            const keys = await this.list('pattern:*');
+            for (const key of keys.slice(0, filter.limit ?? 100)) {
+                const patternId = key.replace('pattern:', '');
+                const pattern = await this.vectorStore.getPattern(patternId);
+                if (pattern) {
+                    if (filter.type && pattern.type !== filter.type)
+                        continue;
+                    if (filter.domain && pattern.domain !== filter.domain)
+                        continue;
+                    results.push({
+                        id: pattern.id,
+                        type: pattern.type,
+                        content: pattern.content,
+                        confidence: 1.0,
+                        metadata: pattern.metadata ?? {},
+                        embedding: pattern.embedding,
+                    });
+                }
+            }
+        }
+        else {
+            // Fall back to key-value search
+            const keys = await this.list('pattern:*');
+            for (const key of keys.slice(0, filter.limit ?? 100)) {
+                const pattern = await this.retrieve(key);
+                if (pattern) {
+                    if (filter.type && pattern.type !== filter.type)
+                        continue;
+                    if (filter.minConfidence && pattern.confidence < filter.minConfidence)
+                        continue;
+                    results.push(pattern);
+                }
+            }
+        }
+        return results;
+    }
+    /**
+     * Get backend-specific instance
+     */
+    getSwarmMemory() {
+        return this.swarmMemory;
+    }
+    getAgentDB() {
+        return this.agentDB;
+    }
+    getVectorStore() {
+        return this.vectorStore;
+    }
+    /**
+     * Check health of all backends
+     */
+    async checkHealth() {
+        const backends = ['sqlite', 'agentdb', 'json', 'vector'];
+        for (const backend of backends) {
+            const startTime = Date.now();
+            try {
+                await this.healthCheckBackend(backend);
+                const latency = Date.now() - startTime;
+                this.updateHealthStatus(backend, {
+                    backend,
+                    status: 'healthy',
+                    latency,
+                    lastCheck: new Date(),
+                    errorCount: 0,
+                    details: {},
+                });
+            }
+            catch (error) {
+                const health = this.healthStatus.get(backend);
+                const errorCount = (health?.errorCount ?? 0) + 1;
+                this.updateHealthStatus(backend, {
+                    backend,
+                    status: errorCount > 3 ? 'failed' : 'degraded',
+                    latency: 0,
+                    lastCheck: new Date(),
+                    errorCount,
+                    details: { error: String(error) },
+                });
+            }
+        }
+        return this.healthStatus;
+    }
+    /**
+     * Health check for specific backend
+     */
+    async healthCheckBackend(backend) {
+        switch (backend) {
+            case 'sqlite':
+                if (!this.swarmMemory)
+                    throw new Error('SwarmMemory not initialized');
+                // Try a simple operation - query with wildcard to verify connectivity
+                await this.swarmMemory.query('%', { partition: this.config.namespace });
+                break;
+            case 'agentdb':
+                if (!this.agentDB)
+                    throw new Error('AgentDB not initialized');
+                // AgentDB health check would go here
+                break;
+            case 'vector':
+                if (!this.vectorStore)
+                    throw new Error('VectorStore not initialized');
+                await this.vectorStore.getStats();
+                break;
+            case 'json':
+                // JSON store is always healthy
+                break;
+        }
+    }
+    /**
+     * Get health status
+     */
+    getHealthStatus() {
+        return new Map(this.healthStatus);
+    }
+    /**
+     * Check if coordinator is healthy
+     */
+    isHealthy() {
+        const primaryHealth = this.healthStatus.get(this.activeBackend);
+        return primaryHealth?.status === 'healthy';
+    }
+    /**
+     * Execute with fallback
+     */
+    async executeWithFallback(operation, backends) {
+        const chain = backends ?? this.fallbackChain;
+        let lastError = null;
+        for (const backend of chain) {
+            try {
+                const result = await operation(backend);
+                // If we're not using the primary backend, consider switching
+                if (backend !== this.activeBackend) {
+                    this.metrics.failoverCount++;
+                    this.logger.warn(`Using fallback backend: ${backend}`);
+                }
+                return result;
+            }
+            catch (error) {
+                lastError = error;
+                this.logger.debug(`Backend ${backend} failed:`, error);
+                // Update health status
+                const health = this.healthStatus.get(backend);
+                if (health) {
+                    health.errorCount++;
+                    health.status = 'degraded';
+                }
+            }
+        }
+        throw new Error(`All backends failed: ${lastError?.message}`);
+    }
+    /**
+     * Switch backend
+     */
+    async switchBackend(from, to) {
+        this.logger.info(`Switching backend from ${from} to ${to}`);
+        this.activeBackend = to;
+        this.fallbackChain = this.buildFallbackChain(to);
+        // Optionally sync data
+        if (this.config.enableFallback) {
+            await this.syncBackends();
+        }
+    }
+    /**
+     * Sync data between backends
+     */
+    async syncBackends() {
+        if (this.syncInProgress) {
+            return {
+                success: false,
+                recordsSynced: 0,
+                conflicts: 0,
+                duration: 0,
+                errors: ['Sync already in progress'],
+            };
+        }
+        this.syncInProgress = true;
+        const startTime = Date.now();
+        let recordsSynced = 0;
+        const errors = [];
+        try {
+            this.logger.debug('Starting backend synchronization...');
+            // Sync SQLite to JSON
+            if (this.swarmMemory) {
+                try {
+                    const entries = await this.swarmMemory.query('%', { partition: this.config.namespace });
+                    const keys = entries.map(e => e.key);
+                    for (const key of keys) {
+                        try {
+                            const value = await this.swarmMemory.retrieve(key, { partition: this.config.namespace });
+                            if (value) {
+                                this.jsonStore.set(key, {
+                                    value,
+                                    createdAt: Date.now(),
+                                });
+                                recordsSynced++;
+                            }
+                        }
+                        catch (error) {
+                            errors.push(`Failed to sync key ${key}: ${error}`);
+                        }
+                    }
+                }
+                catch (error) {
+                    errors.push(`Failed to sync from SQLite: ${error}`);
+                }
+            }
+            const duration = Date.now() - startTime;
+            this.metrics.syncCount++;
+            this.metrics.lastSync = new Date();
+            this.logger.info(`Sync completed: ${recordsSynced} records in ${duration}ms`);
+            return {
+                success: errors.length === 0,
+                recordsSynced,
+                conflicts: 0,
+                duration,
+                errors: errors.length > 0 ? errors : undefined,
+            };
+        }
+        finally {
+            this.syncInProgress = false;
+        }
+    }
+    /**
+     * Create namespaced coordinator
+     */
+    createNamespace(name) {
+        return new NamespacedCoordinator(this, name);
+    }
+    /**
+     * Get metrics
+     */
+    getMetrics() {
+        return {
+            ...this.metrics,
+            operationsByBackend: new Map(this.metrics.operationsByBackend),
+        };
+    }
+    /**
+     * Start health monitoring
+     */
+    startHealthMonitoring() {
+        if (this.healthCheckTimer) {
+            clearInterval(this.healthCheckTimer);
+        }
+        this.healthCheckTimer = setInterval(async () => {
+            try {
+                await this.checkHealth();
+            }
+            catch (error) {
+                this.logger.error('Health check failed:', error);
+            }
+        }, this.config.healthCheckInterval);
+    }
+    /**
+     * Start periodic sync
+     */
+    startPeriodicSync() {
+        if (this.syncTimer) {
+            clearInterval(this.syncTimer);
+        }
+        this.syncTimer = setInterval(async () => {
+            try {
+                await this.syncBackends();
+            }
+            catch (error) {
+                this.logger.error('Periodic sync failed:', error);
+            }
+        }, this.config.syncInterval);
+    }
+    /**
+     * Update health status
+     */
+    updateHealthStatus(backend, health) {
+        this.healthStatus.set(backend, health);
+    }
+    /**
+     * Update metrics
+     */
+    updateMetrics(operation, startTime, backend) {
+        const duration = Date.now() - startTime;
+        this.metrics.totalOperations++;
+        const backendOps = this.metrics.operationsByBackend.get(backend) ?? 0;
+        this.metrics.operationsByBackend.set(backend, backendOps + 1);
+        // Update average latency
+        const totalLatency = this.metrics.averageLatency * (this.metrics.totalOperations - 1) + duration;
+        this.metrics.averageLatency = totalLatency / this.metrics.totalOperations;
+    }
+    /**
+     * Prefix key with namespace
+     */
+    prefixKey(key) {
+        return `${this.config.namespace}:${key}`;
+    }
+    /**
+     * Shutdown coordinator
+     */
+    async shutdown() {
+        this.logger.info('Shutting down UnifiedMemoryCoordinator...');
+        // Stop timers
+        if (this.healthCheckTimer) {
+            clearInterval(this.healthCheckTimer);
+        }
+        if (this.syncTimer) {
+            clearInterval(this.syncTimer);
+        }
+        // Final sync
+        if (this.config.enableFallback) {
+            await this.syncBackends();
+        }
+        // Shutdown backends
+        if (this.vectorStore) {
+            await this.vectorStore.shutdown();
+        }
+        if (this.agentDB) {
+            await this.agentDB.close();
+        }
+        if (this.swarmMemory) {
+            await this.swarmMemory.close();
+        }
+        this.logger.info('UnifiedMemoryCoordinator shut down');
+    }
+}
+exports.UnifiedMemoryCoordinator = UnifiedMemoryCoordinator;
+/**
+ * Namespaced wrapper for isolated operations
+ */
+class NamespacedCoordinator {
+    constructor(coordinator, namespace) {
+        this.coordinator = coordinator;
+        this.namespace = namespace;
+    }
+    async store(key, value, ttl) {
+        return this.coordinator.store(this.prefixKey(key), value, ttl);
+    }
+    async retrieve(key) {
+        return this.coordinator.retrieve(this.prefixKey(key));
+    }
+    async delete(key) {
+        return this.coordinator.delete(this.prefixKey(key));
+    }
+    async list(pattern) {
+        const keys = await this.coordinator.list(pattern ? this.prefixKey(pattern) : undefined);
+        return keys.map(k => this.unprefixKey(k));
+    }
+    prefixKey(key) {
+        return `${this.namespace}:${key}`;
+    }
+    unprefixKey(key) {
+        const prefix = `${this.namespace}:`;
+        return key.startsWith(prefix) ? key.slice(prefix.length) : key;
+    }
+}
+exports.NamespacedCoordinator = NamespacedCoordinator;
+/**
+ * Convenience function to create a coordinator
+ */
+async function createUnifiedMemoryCoordinator(config) {
+    const coordinator = new UnifiedMemoryCoordinator(config);
+    await coordinator.initialize();
+    return coordinator;
+}
+//# sourceMappingURL=UnifiedMemoryCoordinator.js.map