agentic-qe 2.8.0 → 2.8.2

package/dist/persistence/HybridPersistenceProvider.js

@@ -0,0 +1,1086 @@
+"use strict";
+/**
+ * Hybrid Persistence Provider
+ *
+ * Local-first persistence with cloud sync capabilities.
+ * Uses SQLite for immediate local storage and syncs to Supabase in the background.
+ *
+ * Features:
+ * - Immediate local writes (low latency)
+ * - Background sync to cloud
+ * - Conflict resolution strategies
+ * - Offline support with sync on reconnect
+ * - Queue-based sync for reliability
+ *
+ * @module persistence/HybridPersistenceProvider
+ */
+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.HybridPersistenceProvider = void 0;
+exports.createHybridPersistenceProvider = createHybridPersistenceProvider;
+const events_1 = require("events");
+const SupabaseConfig_js_1 = require("./SupabaseConfig.js");
+const SupabasePersistenceProvider_js_1 = require("./SupabasePersistenceProvider.js");
+const SQLiteNervousSystemStore_js_1 = require("../nervous-system/persistence/SQLiteNervousSystemStore.js");
+// ============================================
+// Provider Implementation
+// ============================================
+/**
+ * Hybrid persistence provider with local-first approach
+ *
+ * @example
+ * ```typescript
+ * const provider = new HybridPersistenceProvider({
+ *   localDbPath: './data/aqe.db',
+ *   supabaseConfig: {
+ *     connection: {
+ *       url: 'https://xxx.supabase.co',
+ *       anonKey: 'xxx',
+ *     },
+ *   },
+ * });
+ *
+ * await provider.initialize();
+ *
+ * // Writes go to local first, then sync to cloud
+ * await provider.storeExperience(experience);
+ *
+ * // Force sync
+ * const result = await provider.syncToCloud();
+ * console.log(`Synced ${result.uploaded} items`);
+ * ```
+ */
+class HybridPersistenceProvider extends events_1.EventEmitter {
+    constructor(config) {
+        super();
+        // Local store
+        this.localStore = null;
+        // Cloud provider (optional)
+        this.cloudProvider = null;
+        // Sync queue
+        this.syncQueue = [];
+        this.syncTimer = null;
+        // State
+        this.initialized = false;
+        this.syncStatus = {
+            lastSyncTime: null,
+            pendingUploads: 0,
+            pendingDownloads: 0,
+            conflicts: 0,
+            isOnline: false,
+            isSyncing: false,
+        };
+        this.config = {
+            localDbPath: config.localDbPath,
+            supabaseConfig: config.supabaseConfig ?? {},
+            syncConfig: config.syncConfig ?? {},
+            autoSync: config.autoSync ?? true,
+            maxQueueSize: config.maxQueueSize ?? 100,
+        };
+        this.syncConfig = {
+            ...SupabaseConfig_js_1.DEFAULT_SYNC_CONFIG,
+            ...config.syncConfig,
+        };
+    }
+    // ============================================
+    // Lifecycle
+    // ============================================
+    async initialize() {
+        if (this.initialized) {
+            return;
+        }
+        // Initialize local store
+        this.localStore = (0, SQLiteNervousSystemStore_js_1.createSQLiteNervousSystemStore)({
+            dbPath: this.config.localDbPath,
+        });
+        await this.localStore.initialize();
+        // Initialize cloud provider if configured
+        if ((0, SupabaseConfig_js_1.isSupabaseConfigured)() || this.config.supabaseConfig?.connection) {
+            try {
+                this.cloudProvider = new SupabasePersistenceProvider_js_1.SupabasePersistenceProvider(this.config.supabaseConfig);
+                await this.cloudProvider.initialize();
+                this.syncStatus.isOnline = true;
+                this.emit('online');
+            }
+            catch (error) {
+                console.warn('[HybridProvider] Cloud provider failed to initialize:', error);
+                this.syncStatus.isOnline = false;
+            }
+        }
+        // Start background sync if enabled
+        if (this.config.autoSync && this.syncConfig.backgroundSync) {
+            this.startBackgroundSync();
+        }
+        this.initialized = true;
+        this.emit('initialized');
+    }
+    async shutdown() {
+        // Stop background sync
+        this.stopBackgroundSync();
+        // Flush pending sync queue
+        if (this.syncQueue.length > 0 && this.syncStatus.isOnline) {
+            try {
+                await this.syncToCloud();
+            }
+            catch (error) {
+                console.warn('[HybridProvider] Failed to sync before shutdown:', error);
+            }
+        }
+        // Shutdown providers
+        if (this.cloudProvider) {
+            await this.cloudProvider.shutdown();
+            this.cloudProvider = null;
+        }
+        if (this.localStore) {
+            await this.localStore.shutdown();
+            this.localStore = null;
+        }
+        this.initialized = false;
+        this.emit('shutdown');
+    }
+    // ============================================
+    // Learning Experiences (Local-first)
+    // ============================================
+    async storeExperience(experience) {
+        this.ensureInitialized();
+        // Store locally first (immediate)
+        // For now, we store in local SQLite using a simple JSON approach
+        // In a full implementation, we'd have a proper experiences table
+        const key = `experience:${experience.id}`;
+        const data = JSON.stringify(experience);
+        // Use the nervous system state storage as a generic key-value store
+        await this.localStore.saveCircadianState(key, {
+            version: 1,
+            state: { data },
+            metrics: {},
+            lastPhaseChange: 0,
+            serializedAt: Date.now(),
+        });
+        // Queue for cloud sync
+        this.queueSync('insert', 'experiences', experience.id, experience);
+        this.emit('experience:stored', experience.id);
+    }
+    async queryExperiences(query) {
+        this.ensureInitialized();
+        // Try cloud first if online for most up-to-date data
+        if (this.syncStatus.isOnline && this.cloudProvider) {
+            try {
+                return await this.cloudProvider.queryExperiences(query);
+            }
+            catch (error) {
+                console.warn('[HybridProvider] Cloud query failed, falling back to local:', error);
+            }
+        }
+        // Fall back to local (simplified - would need proper local query implementation)
+        // For a full implementation, we'd query the local SQLite database
+        return [];
+    }
+    async searchSimilarExperiences(embedding, limit) {
+        this.ensureInitialized();
+        // Vector search only available in cloud
+        if (this.syncStatus.isOnline && this.cloudProvider) {
+            return this.cloudProvider.searchSimilarExperiences(embedding, limit);
+        }
+        // Local fallback - would need local vector search implementation
+        return [];
+    }
+    // ============================================
+    // Patterns (Local-first)
+    // ============================================
+    async storePattern(pattern) {
+        this.ensureInitialized();
+        // Store locally
+        const key = `pattern:${pattern.id}`;
+        const data = JSON.stringify(pattern);
+        await this.localStore.saveCircadianState(key, {
+            version: 1,
+            state: { data },
+            metrics: {},
+            lastPhaseChange: 0,
+            serializedAt: Date.now(),
+        });
+        // Queue for cloud sync
+        this.queueSync('insert', 'patterns', pattern.id, pattern);
+        this.emit('pattern:stored', pattern.id);
+    }
+    async queryPatterns(query) {
+        this.ensureInitialized();
+        if (this.syncStatus.isOnline && this.cloudProvider) {
+            try {
+                return await this.cloudProvider.queryPatterns(query);
+            }
+            catch (error) {
+                console.warn('[HybridProvider] Cloud query failed, falling back to local:', error);
+            }
+        }
+        return [];
+    }
+    async searchSimilarPatterns(embedding, limit) {
+        this.ensureInitialized();
+        if (this.syncStatus.isOnline && this.cloudProvider) {
+            return this.cloudProvider.searchSimilarPatterns(embedding, limit);
+        }
+        return [];
+    }
+    // ============================================
+    // Nervous System State (Local-first)
+    // ============================================
+    async saveNervousSystemState(agentId, component, state) {
+        this.ensureInitialized();
+        // For hybrid provider, delegate to cloud if available for full state handling
+        // Local store handles the underlying SQLite persistence
+        if (this.syncStatus.isOnline && this.cloudProvider) {
+            await this.cloudProvider.saveNervousSystemState(agentId, component, state);
+        }
+        // Also store locally using a simplified approach
+        // We use the circadian state table as a generic JSON store for local cache
+        const cacheKey = `ns:${agentId}:${component}`;
+        await this.localStore.saveCircadianState(cacheKey, {
+            version: 1,
+            state: {
+                phase: 'Active',
+                cycleTime: 0,
+                phaseTime: 0,
+                energyRemaining: 0,
+                cyclesCompleted: 0,
+                activeModulation: null,
+                timeToNextPhase: 0,
+                wasmEnabled: false,
+                // Store actual data as JSON in a custom field
+                _rawData: state instanceof Uint8Array ? Array.from(state) : state,
+                _isBinary: state instanceof Uint8Array,
+            },
+            metrics: {
+                phaseTime: { Active: 0, Dawn: 0, Dusk: 0, Rest: 0 },
+                reactionsPerPhase: { Active: 0, Dawn: 0, Dusk: 0, Rest: 0 },
+                rejectionsPerPhase: { Active: 0, Dawn: 0, Dusk: 0, Rest: 0 },
+                averageDutyFactor: 0,
+                totalEnergyConsumed: 0,
+                phaseTransitions: 0,
+                hysteresisActivations: 0,
+                wtaCompetitions: 0,
+            },
+            lastPhaseChange: Date.now(),
+            serializedAt: Date.now(),
+        });
+        // Queue for cloud sync if not already synced
+        if (!this.syncStatus.isOnline) {
+            this.queueSync('update', 'nervous_system', `${agentId}:${component}`, {
+                agentId,
+                component,
+                state: state instanceof Uint8Array ? Array.from(state) : state,
+            });
+        }
+        this.emit('nervousSystem:saved', { agentId, component });
+    }
+    async loadNervousSystemState(agentId, component) {
+        this.ensureInitialized();
+        // Try cloud first if available
+        if (this.syncStatus.isOnline && this.cloudProvider) {
+            try {
+                const cloudState = await this.cloudProvider.loadNervousSystemState(agentId, component);
+                if (cloudState) {
+                    return cloudState;
+                }
+            }
+            catch (error) {
+                console.warn('[HybridProvider] Cloud load failed, trying local:', error);
+            }
+        }
+        // Fall back to local cache
+        const cacheKey = `ns:${agentId}:${component}`;
+        const cached = await this.localStore.loadCircadianState(cacheKey);
+        if (cached && cached.state) {
+            const stateData = cached.state;
+            const rawData = stateData._rawData;
+            const isBinary = stateData._isBinary;
+            if (rawData) {
+                if (isBinary && Array.isArray(rawData)) {
+                    return new Uint8Array(rawData);
+                }
+                return rawData;
+            }
+        }
+        return null;
+    }
+    async deleteNervousSystemState(agentId) {
+        this.ensureInitialized();
+        await this.localStore.deleteAllState(agentId);
+        // Queue for cloud sync
+        this.queueSync('delete', 'nervous_system', agentId);
+        this.emit('nervousSystem:deleted', agentId);
+    }
+    async listAgentsWithState() {
+        this.ensureInitialized();
+        return this.localStore.listAgents();
+    }
+    // ============================================
+    // Sharing (Delegated to cloud)
+    // ============================================
+    async shareExperience(experienceId, privacyLevel) {
+        this.ensureCloudAvailable();
+        await this.cloudProvider.shareExperience(experienceId, privacyLevel);
+    }
+    async importSharedExperiences(query) {
+        this.ensureCloudAvailable();
+        return this.cloudProvider.importSharedExperiences(query);
+    }
+    async sharePattern(patternId, privacyLevel) {
+        this.ensureCloudAvailable();
+        await this.cloudProvider.sharePattern(patternId, privacyLevel);
+    }
+    async importSharedPatterns(query) {
+        this.ensureCloudAvailable();
+        return this.cloudProvider.importSharedPatterns(query);
+    }
+    // ============================================
+    // Memory Entries (Local-first)
+    // ============================================
+    async storeMemoryEntry(entry) {
+        this.ensureInitialized();
+        // Store locally first
+        const key = `memory:${entry.partition}:${entry.key}`;
+        await this.localStore.saveCircadianState(key, {
+            version: 1,
+            state: { data: JSON.stringify(entry) },
+            metrics: {},
+            lastPhaseChange: 0,
+            serializedAt: Date.now(),
+        });
+        // Queue for cloud sync
+        this.queueSync('insert', 'memory_entries', `${entry.partition}:${entry.key}`, entry);
+        this.emit('memory:stored', entry.key);
+    }
+    async storeMemoryEntries(entries) {
+        for (const entry of entries) {
+            await this.storeMemoryEntry(entry);
+        }
+    }
+    async getMemoryEntry(key, partition = 'default') {
+        this.ensureInitialized();
+        // Try cloud first if available
+        if (this.syncStatus.isOnline && this.cloudProvider?.getMemoryEntry) {
+            try {
+                const cloudEntry = await this.cloudProvider.getMemoryEntry(key, partition);
+                if (cloudEntry)
+                    return cloudEntry;
+            }
+            catch (error) {
+                console.warn('[HybridProvider] Cloud getMemoryEntry failed:', error);
+            }
+        }
+        // Fall back to local
+        const localKey = `memory:${partition}:${key}`;
+        const cached = await this.localStore.loadCircadianState(localKey);
+        if (cached?.state) {
+            const stateData = cached.state;
+            if (stateData.data) {
+                return JSON.parse(stateData.data);
+            }
+        }
+        return null;
+    }
+    async queryMemoryEntries(query) {
+        this.ensureInitialized();
+        // Query cloud if available (more complete data)
+        if (this.syncStatus.isOnline && this.cloudProvider?.queryMemoryEntries) {
+            try {
+                return await this.cloudProvider.queryMemoryEntries(query);
+            }
+            catch (error) {
+                console.warn('[HybridProvider] Cloud queryMemoryEntries failed:', error);
+            }
+        }
+        // Local fallback - simplified, would need proper implementation
+        return [];
+    }
+    async deleteMemoryEntries(keyPattern, partition) {
+        this.ensureInitialized();
+        // Queue for cloud sync
+        this.queueSync('delete', 'memory_entries', `${partition ?? 'default'}:${keyPattern}`);
+        // Also delete locally if cloud succeeds
+        if (this.syncStatus.isOnline && this.cloudProvider?.deleteMemoryEntries) {
+            try {
+                return await this.cloudProvider.deleteMemoryEntries(keyPattern, partition);
+            }
+            catch (error) {
+                console.warn('[HybridProvider] Cloud deleteMemoryEntries failed:', error);
+            }
+        }
+        return 0;
+    }
+    // ============================================
+    // Events (Local-first with buffering)
+    // ============================================
+    async storeEvent(event) {
+        this.ensureInitialized();
+        // Store locally
+        const key = `event:${event.id}`;
+        await this.localStore.saveCircadianState(key, {
+            version: 1,
+            state: { data: JSON.stringify(event) },
+            metrics: {},
+            lastPhaseChange: 0,
+            serializedAt: Date.now(),
+        });
+        // Queue for cloud sync
+        this.queueSync('insert', 'events', event.id, event);
+        this.emit('event:stored', event.id);
+    }
+    async storeEvents(events) {
+        // Batch store for efficiency
+        for (const event of events) {
+            await this.storeEvent(event);
+        }
+    }
+    async queryEvents(query) {
+        this.ensureInitialized();
+        // Query cloud if available
+        if (this.syncStatus.isOnline && this.cloudProvider?.queryEvents) {
+            try {
+                return await this.cloudProvider.queryEvents(query);
+            }
+            catch (error) {
+                console.warn('[HybridProvider] Cloud queryEvents failed:', error);
+            }
+        }
+        // Local fallback
+        return [];
+    }
+    async deleteOldEvents(olderThan) {
+        this.ensureInitialized();
+        // Queue for cloud sync
+        this.queueSync('delete', 'events', `older-than:${olderThan.toISOString()}`);
+        if (this.syncStatus.isOnline && this.cloudProvider?.deleteOldEvents) {
+            try {
+                return await this.cloudProvider.deleteOldEvents(olderThan);
+            }
+            catch (error) {
+                console.warn('[HybridProvider] Cloud deleteOldEvents failed:', error);
+            }
+        }
+        return 0;
+    }
+    // ============================================
+    // Code Chunks (Local-first)
+    // ============================================
+    async storeCodeChunk(chunk) {
+        this.ensureInitialized();
+        // Store locally
+        const key = `code:${chunk.projectId}:${chunk.filePath}:${chunk.startLine}`;
+        await this.localStore.saveCircadianState(key, {
+            version: 1,
+            state: { data: JSON.stringify(chunk) },
+            metrics: {},
+            lastPhaseChange: 0,
+            serializedAt: Date.now(),
+        });
+        // Queue for cloud sync
+        this.queueSync('insert', 'code_chunks', chunk.id, chunk);
+        this.emit('code:stored', chunk.id);
+    }
+    async storeCodeChunks(chunks) {
+        for (const chunk of chunks) {
+            await this.storeCodeChunk(chunk);
+        }
+    }
+    async queryCodeChunks(query) {
+        this.ensureInitialized();
+        // Query cloud if available
+        if (this.syncStatus.isOnline && this.cloudProvider?.queryCodeChunks) {
+            try {
+                return await this.cloudProvider.queryCodeChunks(query);
+            }
+            catch (error) {
+                console.warn('[HybridProvider] Cloud queryCodeChunks failed:', error);
+            }
+        }
+        // Local fallback
+        return [];
+    }
+    async searchSimilarCode(embedding, options) {
+        this.ensureInitialized();
+        // Vector search only available in cloud
+        if (this.syncStatus.isOnline && this.cloudProvider?.searchSimilarCode) {
+            return this.cloudProvider.searchSimilarCode(embedding, options);
+        }
+        // No local vector search - would require local embedding index
+        return [];
+    }
+    async deleteCodeChunksForFile(projectId, filePath) {
+        this.ensureInitialized();
+        // Queue for cloud sync
+        this.queueSync('delete', 'code_chunks', `file:${projectId}:${filePath}`);
+        if (this.syncStatus.isOnline && this.cloudProvider?.deleteCodeChunksForFile) {
+            try {
+                return await this.cloudProvider.deleteCodeChunksForFile(projectId, filePath);
+            }
+            catch (error) {
+                console.warn('[HybridProvider] Cloud deleteCodeChunksForFile failed:', error);
+            }
+        }
+        return 0;
+    }
+    async deleteCodeChunksForProject(projectId) {
+        this.ensureInitialized();
+        // Queue for cloud sync
+        this.queueSync('delete', 'code_chunks', `project:${projectId}`);
+        if (this.syncStatus.isOnline && this.cloudProvider?.deleteCodeChunksForProject) {
+            try {
+                return await this.cloudProvider.deleteCodeChunksForProject(projectId);
+            }
+            catch (error) {
+                console.warn('[HybridProvider] Cloud deleteCodeChunksForProject failed:', error);
+            }
+        }
+        return 0;
+    }
+    // ============================================
+    // Sync Operations
+    // ============================================
+    async syncToCloud() {
+        if (!this.syncStatus.isOnline || !this.cloudProvider) {
+            throw new Error('Cloud provider not available');
+        }
+        if (this.syncStatus.isSyncing) {
+            return { uploaded: 0, conflicts: 0 };
+        }
+        this.syncStatus.isSyncing = true;
+        this.emit('sync:started');
+        let uploaded = 0;
+        let conflicts = 0;
+        try {
+            // Process sync queue
+            const queue = [...this.syncQueue];
+            this.syncQueue = [];
+            for (const entry of queue) {
+                try {
+                    await this.processSyncEntry(entry);
+                    uploaded++;
+                }
+                catch (error) {
+                    // Check if it's a conflict
+                    if (this.isConflictError(error)) {
+                        conflicts++;
+                        await this.resolveConflict(entry);
+                    }
+                    else {
+                        // Re-queue for retry
+                        entry.retryCount++;
+                        if (entry.retryCount < this.syncConfig.retryAttempts) {
+                            this.syncQueue.push(entry);
+                        }
+                        else {
+                            console.error(`[HybridProvider] Sync failed for ${entry.tableName}:${entry.recordId}`, error);
+                        }
+                    }
+                }
+            }
+            this.syncStatus.lastSyncTime = new Date();
+            this.syncStatus.pendingUploads = this.syncQueue.length;
+            this.syncStatus.conflicts = conflicts;
+            this.emit('sync:completed', { uploaded, conflicts });
+        }
+        finally {
+            this.syncStatus.isSyncing = false;
+        }
+        return { uploaded, conflicts };
+    }
+    async syncFromCloud() {
+        if (!this.syncStatus.isOnline || !this.cloudProvider) {
+            throw new Error('Cloud provider not available');
+        }
+        // For a full implementation, this would:
+        // 1. Query cloud for records newer than last sync
+        // 2. Download and merge with local data
+        // 3. Handle conflicts based on resolution strategy
+        this.emit('sync:fromCloud');
+        return { downloaded: 0, conflicts: 0 };
+    }
+    async getSyncStatus() {
+        return {
+            ...this.syncStatus,
+            pendingUploads: this.syncQueue.length,
+        };
+    }
+    // ============================================
+    // Info
+    // ============================================
+    getProviderInfo() {
+        return {
+            type: 'hybrid',
+            features: [
+                'local-first',
+                'offline-support',
+                'background-sync',
+                'conflict-resolution',
+                'cloud-backup',
+                'memory-sync',
+                'event-sync',
+                'code-intelligence-sync',
+                ...(this.cloudProvider ? ['cloud-available', 'vector-search', 'sharing'] : []),
+            ],
+            initialized: this.initialized,
+            location: this.config.localDbPath,
+            stats: {
+                agentCount: 0, // Would need to query
+                lastSyncTime: this.syncStatus.lastSyncTime ?? undefined,
+            },
+        };
+    }
+    // ============================================
+    // Private Methods
+    // ============================================
+    ensureInitialized() {
+        if (!this.initialized || !this.localStore) {
+            throw new Error('HybridPersistenceProvider not initialized');
+        }
+    }
+    ensureCloudAvailable() {
+        this.ensureInitialized();
+        if (!this.cloudProvider) {
+            throw new Error('Cloud provider not available');
+        }
+    }
+    queueSync(operation, tableName, recordId, data) {
+        const entry = {
+            id: `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+            operation,
+            tableName,
+            recordId,
+            data,
+            retryCount: 0,
+            createdAt: Date.now(),
+        };
+        this.syncQueue.push(entry);
+        this.syncStatus.pendingUploads = this.syncQueue.length;
+        // Force sync if queue is too large
+        if (this.syncQueue.length >= this.config.maxQueueSize) {
+            this.syncToCloud().catch((err) => console.warn('[HybridProvider] Force sync failed:', err));
+        }
+    }
+    async processSyncEntry(entry) {
+        if (!this.cloudProvider)
+            return;
+        // Process based on table and operation
+        switch (entry.tableName) {
+            case 'experiences':
+                if (entry.operation === 'insert' || entry.operation === 'update') {
+                    await this.cloudProvider.storeExperience(entry.data);
+                }
+                break;
+            case 'patterns':
+                if (entry.operation === 'insert' || entry.operation === 'update') {
+                    await this.cloudProvider.storePattern(entry.data);
+                }
+                break;
+            case 'nervous_system':
+                if (entry.operation === 'update' && entry.data) {
+                    const { agentId, component, state } = entry.data;
+                    const stateValue = Array.isArray(state) ? new Uint8Array(state) : state;
+                    await this.cloudProvider.saveNervousSystemState(agentId, component, stateValue);
+                }
+                else if (entry.operation === 'delete') {
+                    await this.cloudProvider.deleteNervousSystemState(entry.recordId);
+                }
+                break;
+            case 'memory_entries':
+                if ((entry.operation === 'insert' || entry.operation === 'update') && entry.data) {
+                    if (this.cloudProvider.storeMemoryEntry) {
+                        await this.cloudProvider.storeMemoryEntry(entry.data);
+                    }
+                }
+                else if (entry.operation === 'delete') {
+                    if (this.cloudProvider.deleteMemoryEntries) {
+                        const [partition, keyPattern] = entry.recordId.split(':');
+                        await this.cloudProvider.deleteMemoryEntries(keyPattern, partition);
+                    }
+                }
+                break;
+            case 'events':
+                if ((entry.operation === 'insert' || entry.operation === 'update') && entry.data) {
+                    if (this.cloudProvider.storeEvent) {
+                        await this.cloudProvider.storeEvent(entry.data);
+                    }
+                }
+                else if (entry.operation === 'delete') {
+                    if (entry.recordId.startsWith('older-than:') && this.cloudProvider.deleteOldEvents) {
+                        const dateStr = entry.recordId.replace('older-than:', '');
+                        await this.cloudProvider.deleteOldEvents(new Date(dateStr));
+                    }
+                }
+                break;
+            case 'code_chunks':
+                if ((entry.operation === 'insert' || entry.operation === 'update') && entry.data) {
+                    if (this.cloudProvider.storeCodeChunk) {
+                        await this.cloudProvider.storeCodeChunk(entry.data);
+                    }
+                }
+                else if (entry.operation === 'delete') {
+                    if (entry.recordId.startsWith('file:') && this.cloudProvider.deleteCodeChunksForFile) {
+                        const [, projectId, ...filePathParts] = entry.recordId.split(':');
+                        await this.cloudProvider.deleteCodeChunksForFile(projectId, filePathParts.join(':'));
+                    }
+                    else if (entry.recordId.startsWith('project:') && this.cloudProvider.deleteCodeChunksForProject) {
+                        const projectId = entry.recordId.replace('project:', '');
+                        await this.cloudProvider.deleteCodeChunksForProject(projectId);
+                    }
+                }
+                break;
+        }
+    }
+    isConflictError(error) {
+        if (error instanceof Error) {
+            return error.message.includes('conflict') || error.message.includes('duplicate');
+        }
+        return false;
+    }
+    async resolveConflict(entry) {
+        // Apply conflict resolution strategy
+        switch (this.syncConfig.conflictResolution) {
+            case 'local':
+                // Keep local version - force update to cloud
+                entry.retryCount = 0;
+                this.syncQueue.push(entry);
+                break;
+            case 'remote':
+                // Keep remote version - discard local change
+                // Would need to fetch and apply remote version
+                break;
+            case 'newest':
+                // Compare timestamps and keep newest
+                // Would need to fetch remote timestamp
+                break;
+        }
+        this.emit('sync:conflict', entry);
+    }
+    startBackgroundSync() {
+        if (this.syncTimer)
+            return;
+        this.syncTimer = setInterval(() => {
+            if (this.syncQueue.length > 0 && this.syncStatus.isOnline) {
+                this.syncToCloud().catch((err) => console.warn('[HybridProvider] Background sync failed:', err));
+            }
+        }, this.syncConfig.syncInterval);
+    }
+    stopBackgroundSync() {
+        if (this.syncTimer) {
+            clearInterval(this.syncTimer);
+            this.syncTimer = null;
+        }
+    }
+    // ============================================
+    // Sync Management Methods
+    // ============================================
+    /**
+     * Get current sync statistics
+     */
+    getSyncStats() {
+        return {
+            pendingOperations: this.syncQueue.length,
+            lastSyncTime: this.syncStatus.lastSyncTime,
+            isOnline: this.syncStatus.isOnline,
+            isSyncing: this.syncStatus.isSyncing,
+            conflicts: this.syncStatus.conflicts,
+        };
+    }
+    /**
+     * Force immediate sync of all pending operations
+     */
+    async forceSyncNow() {
+        if (!this.cloudProvider) {
+            return { synced: 0, failed: 0 };
+        }
+        const queueSnapshot = [...this.syncQueue];
+        let synced = 0;
+        let failed = 0;
+        for (const entry of queueSnapshot) {
+            try {
+                await this.processSyncEntry(entry);
+                // Remove from queue
+                this.syncQueue = this.syncQueue.filter((e) => e.id !== entry.id);
+                synced++;
+            }
+            catch (error) {
+                console.warn(`[HybridProvider] Sync failed for ${entry.tableName}:${entry.recordId}:`, error);
+                failed++;
+                // Increment retry count
+                const queueEntry = this.syncQueue.find((e) => e.id === entry.id);
+                if (queueEntry) {
+                    queueEntry.retryCount++;
+                }
+            }
+        }
+        this.syncStatus.lastSyncTime = new Date();
+        this.emit('sync:completed', { synced, failed });
+        return { synced, failed };
+    }
+    /**
+     * Clear all pending sync operations
+     */
+    clearSyncQueue() {
+        const count = this.syncQueue.length;
+        this.syncQueue = [];
+        this.emit('sync:queue-cleared', { count });
+    }
+    /**
+     * Set online status (for offline/online detection)
+     */
+    setOnlineStatus(isOnline) {
+        const wasOnline = this.syncStatus.isOnline;
+        this.syncStatus.isOnline = isOnline;
+        if (!wasOnline && isOnline && this.syncQueue.length > 0) {
+            // Came back online with pending operations, trigger sync
+            this.forceSyncNow().catch((err) => console.warn('[HybridProvider] Sync on reconnect failed:', err));
+        }
+        this.emit('sync:online-status', { isOnline });
+    }
+    /**
+     * Migrate all local data from memory.db to Supabase cloud
+     * This is a one-time migration for existing local data
+     */
+    async migrateLocalToCloud(memoryDbPath, options = {}) {
+        if (!this.cloudProvider) {
+            throw new Error('Cloud provider not available');
+        }
+        const { batchSize = 100, onProgress = console.log } = options;
+        const results = { experiences: 0, memories: 0, patterns: 0, events: 0, failed: 0 };
+        // Dynamic import to avoid bundling issues
+        const Database = (await Promise.resolve().then(() => __importStar(require('better-sqlite3')))).default;
+        const db = new Database(memoryDbPath, { readonly: true });
+        try {
+            // Project should already be ensured during initialize()
+            // The cloud provider handles projectId internally
+            // Migrate learning_experiences
+            onProgress('Migrating learning experiences...');
+            const experiences = db.prepare(`
+        SELECT agent_id, task_type, state, action, reward, next_state, metadata, created_at
+        FROM learning_experiences
+      `).all();
+            for (let i = 0; i < experiences.length; i += batchSize) {
+                const batch = experiences.slice(i, i + batchSize);
+                for (const exp of batch) {
+                    try {
+                        await this.cloudProvider.storeExperience({
+                            id: crypto.randomUUID(),
+                            agentId: exp.agent_id || 'unknown',
+                            agentType: exp.task_type?.split('-')[0] || 'general',
+                            taskType: exp.task_type || 'unknown',
+                            context: this.safeJsonParse(exp.state, {}),
+                            outcome: {
+                                result: 'success',
+                                confidence: exp.reward || 0.5,
+                                ...this.safeJsonParse(exp.action, {}),
+                            },
+                            privacyLevel: 'private',
+                            isAnonymized: false,
+                            shareCount: 0,
+                            createdAt: this.safeParseDate(exp.created_at),
+                        });
+                        results.experiences++;
+                    }
+                    catch (err) {
+                        results.failed++;
+                        if (results.failed <= 3) {
+                            console.error(`  Experience error: ${err instanceof Error ? err.message : err}`);
+                        }
+                    }
+                }
+                onProgress(`  Experiences: ${Math.min(i + batchSize, experiences.length)}/${experiences.length}`);
+            }
+            // Migrate memory_entries
+            onProgress('Migrating memory entries...');
+            const memories = db.prepare(`
+        SELECT key, partition, value, owner, metadata, created_at, expires_at
+        FROM memory_entries
+        LIMIT 2000
+      `).all();
+            for (let i = 0; i < memories.length; i += batchSize) {
+                const batch = memories.slice(i, i + batchSize);
+                for (const mem of batch) {
+                    try {
+                        await this.cloudProvider.storeMemoryEntry({
+                            key: mem.key,
+                            partition: mem.partition || 'default',
+                            value: String(mem.value),
+                            owner: mem.owner || 'system',
+                            accessLevel: 'owner',
+                            metadata: this.safeJsonParse(mem.metadata, {}),
+                            createdAt: this.safeParseDate(mem.created_at),
+                            expiresAt: mem.expires_at ? this.safeParseDate(mem.expires_at) : undefined,
+                        });
+                        results.memories++;
+                    }
+                    catch (err) {
+                        results.failed++;
+                        if (results.failed <= 5) {
+                            console.error(`  Memory error: ${err instanceof Error ? err.message : err}`);
+                        }
+                    }
+                }
+                onProgress(`  Memories: ${Math.min(i + batchSize, memories.length)}/${memories.length}`);
+            }
+            // Migrate patterns
+            onProgress('Migrating patterns...');
+            const patterns = db.prepare(`
+        SELECT id, pattern, confidence, usage_count, metadata, domain, created_at
+        FROM patterns
+        LIMIT 500
+      `).all();
+            for (let i = 0; i < patterns.length; i += batchSize) {
+                const batch = patterns.slice(i, i + batchSize);
+                for (const pat of batch) {
+                    try {
+                        // Preserve original_id in metadata if not a valid UUID
+                        const metadata = this.safeJsonParse(pat.metadata, {});
+                        if (pat.id && !this.isValidUUID(pat.id)) {
+                            metadata.original_id = pat.id;
+                        }
+                        await this.cloudProvider.storePattern({
+                            id: this.isValidUUID(pat.id) ? pat.id : crypto.randomUUID(),
+                            type: 'learned',
+                            domain: pat.domain || 'general',
+                            content: pat.pattern || '',
+                            confidence: pat.confidence || 0.5,
+                            usageCount: pat.usage_count || 0,
+                            privacyLevel: 'private',
+                            isAnonymized: false,
+                            metadata,
+                            createdAt: this.safeParseDate(pat.created_at),
+                        });
+                        results.patterns++;
+                    }
+                    catch (err) {
+                        results.failed++;
+                        if (results.failed <= 8) {
+                            console.error(`  Pattern error: ${err instanceof Error ? err.message : err}`);
+                        }
+                    }
+                }
+                onProgress(`  Patterns: ${Math.min(i + batchSize, patterns.length)}/${patterns.length}`);
+            }
+            // Migrate events
+            onProgress('Migrating events...');
+            const events = db.prepare(`
+        SELECT id, type, payload, timestamp, source, ttl
+        FROM events
+        LIMIT 2000
+      `).all();
+            for (let i = 0; i < events.length; i += batchSize) {
+                const batch = events.slice(i, i + batchSize);
+                for (const evt of batch) {
+                    try {
+                        // Parse payload and add original_id to preserve reference
+                        const payload = this.safeJsonParse(evt.payload, {});
+                        if (evt.id && !this.isValidUUID(evt.id)) {
+                            payload.original_id = evt.id;
+                        }
+                        await this.cloudProvider.storeEvent({
+                            id: this.isValidUUID(evt.id) ? evt.id : crypto.randomUUID(),
+                            type: evt.type || 'unknown',
+                            payload,
+                            source: evt.source || 'migration',
+                            timestamp: this.safeParseDate(evt.timestamp),
+                            ttl: evt.ttl || 0,
+                        });
+                        results.events++;
+                    }
+                    catch (err) {
+                        results.failed++;
+                        if (results.failed <= 10) {
+                            console.error(`  Event error: ${err instanceof Error ? err.message : err}`);
+                        }
+                    }
+                }
+                onProgress(`  Events: ${Math.min(i + batchSize, events.length)}/${events.length}`);
+            }
+        }
+        finally {
+            db.close();
+        }
+        return results;
+    }
+    safeJsonParse(value, fallback) {
+        if (typeof value === 'string') {
+            try {
+                return JSON.parse(value);
+            }
+            catch {
+                return fallback;
+            }
+        }
+        return value ?? fallback;
+    }
+    isValidUUID(value) {
+        if (typeof value !== 'string')
+            return false;
+        const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+        return uuidRegex.test(value);
+    }
+    safeParseDate(value) {
+        if (!value)
+            return new Date();
+        // Try as number (timestamp)
+        const num = Number(value);
+        if (!isNaN(num) && num > 0) {
+            // Check if it's a reasonable timestamp (after year 2000, before year 2100)
+            const minTs = new Date('2000-01-01').getTime();
+            const maxTs = new Date('2100-01-01').getTime();
+            if (num >= minTs && num <= maxTs) {
+                return new Date(num);
+            }
+            // Might be seconds instead of milliseconds
+            if (num * 1000 >= minTs && num * 1000 <= maxTs) {
+                return new Date(num * 1000);
+            }
+        }
+        // Try as string
+        if (typeof value === 'string') {
+            const date = new Date(value);
+            if (!isNaN(date.getTime())) {
+                return date;
+            }
+        }
+        return new Date();
+    }
+}
+exports.HybridPersistenceProvider = HybridPersistenceProvider;
+/**
+ * Factory function to create a hybrid persistence provider
+ */
+function createHybridPersistenceProvider(config) {
+    return new HybridPersistenceProvider(config);
+}
+//# sourceMappingURL=HybridPersistenceProvider.js.map