agentic-qe 2.8.0 → 2.8.1

package/dist/persistence/SupabasePersistenceProvider.js

@@ -0,0 +1,955 @@
+"use strict";
+/**
+ * Supabase Persistence Provider
+ *
+ * Cloud persistence provider using Supabase PostgreSQL with RuVector extension.
+ * Supports multi-tenant data isolation via Row-Level Security and
+ * vector similarity search for intelligent experience/pattern matching.
+ *
+ * @module persistence/SupabasePersistenceProvider
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SupabasePersistenceProvider = void 0;
+exports.createSupabasePersistenceProvider = createSupabasePersistenceProvider;
+const supabase_js_1 = require("@supabase/supabase-js");
+const SupabaseConfig_js_1 = require("./SupabaseConfig.js");
+// ============================================
+// Provider Implementation
+// ============================================
+/**
+ * Supabase cloud persistence provider
+ *
+ * Implements IPersistenceProvider using Supabase PostgreSQL backend.
+ * Features:
+ * - Multi-tenant data isolation via RLS
+ * - Vector similarity search via RuVector
+ * - Automatic embedding generation (optional)
+ * - Sharing between users/teams
+ *
+ * @example
+ * ```typescript
+ * const provider = new SupabasePersistenceProvider({
+ *   connection: {
+ *     url: 'https://xxx.supabase.co',
+ *     anonKey: 'xxx',
+ *   },
+ *   project: { projectId: 'my-project' },
+ * });
+ *
+ * await provider.initialize();
+ *
+ * // Store an experience
+ * await provider.storeExperience({
+ *   id: 'exp-1',
+ *   agentId: 'test-gen',
+ *   agentType: 'test-generator',
+ *   taskType: 'unit-test-generation',
+ *   context: { sourceFile: 'UserService.ts' },
+ *   outcome: { result: 'success', confidence: 0.95 },
+ *   privacyLevel: 'team',
+ *   isAnonymized: false,
+ *   shareCount: 0,
+ *   createdAt: new Date(),
+ * });
+ *
+ * // Search for similar experiences
+ * const similar = await provider.searchSimilarExperiences(embedding, 10);
+ * ```
+ */
+class SupabasePersistenceProvider {
+    /**
+     * Create a new Supabase persistence provider
+     *
+     * @param configOverrides Configuration overrides
+     */
+    constructor(configOverrides = {}) {
+        this.client = null;
+        this.projectId = null;
+        this.initialized = false;
+        this.config = (0, SupabaseConfig_js_1.buildSupabaseConfig)(configOverrides);
+    }
+    // ============================================
+    // Lifecycle
+    // ============================================
+    async initialize() {
+        if (this.initialized) {
+            return;
+        }
+        // Create Supabase client
+        this.client = (0, supabase_js_1.createClient)(this.config.connection.url, this.config.connection.anonKey);
+        // Get or create project
+        this.projectId = await this.ensureProject();
+        this.initialized = true;
+    }
+    async shutdown() {
+        // Supabase client doesn't need explicit cleanup
+        this.client = null;
+        this.initialized = false;
+    }
+    // ============================================
+    // Learning Experiences
+    // ============================================
+    async storeExperience(experience) {
+        this.ensureInitialized();
+        const row = {
+            id: experience.id,
+            project_id: this.projectId,
+            agent_id: experience.agentId,
+            agent_type: experience.agentType,
+            task_type: experience.taskType,
+            context: experience.context,
+            outcome: experience.outcome,
+            embedding: experience.embedding ?? null,
+            privacy_level: experience.privacyLevel,
+            is_anonymized: experience.isAnonymized,
+            share_count: experience.shareCount,
+            confidence: experience.outcome.confidence,
+            created_at: experience.createdAt.toISOString(),
+            created_by: experience.createdBy ?? null,
+        };
+        const { error } = await this.client
+            .from(SupabaseConfig_js_1.SUPABASE_TABLES.EXPERIENCES)
+            .upsert(row, { onConflict: 'id' });
+        if (error) {
+            throw new Error(`Failed to store experience: ${error.message}`);
+        }
+    }
+    async queryExperiences(query) {
+        this.ensureInitialized();
+        let queryBuilder = this.client
+            .from(SupabaseConfig_js_1.SUPABASE_TABLES.EXPERIENCES)
+            .select('*')
+            .eq('project_id', this.projectId);
+        // Apply filters
+        if (query.agentId) {
+            queryBuilder = queryBuilder.eq('agent_id', query.agentId);
+        }
+        if (query.agentType) {
+            queryBuilder = queryBuilder.eq('agent_type', query.agentType);
+        }
+        if (query.taskType) {
+            queryBuilder = queryBuilder.eq('task_type', query.taskType);
+        }
+        if (query.outcome) {
+            queryBuilder = queryBuilder.eq('outcome->result', query.outcome);
+        }
+        if (query.privacyLevel) {
+            queryBuilder = queryBuilder.eq('privacy_level', query.privacyLevel);
+        }
+        if (query.minConfidence !== undefined) {
+            queryBuilder = queryBuilder.gte('confidence', query.minConfidence);
+        }
+        if (query.startDate) {
+            queryBuilder = queryBuilder.gte('created_at', query.startDate.toISOString());
+        }
+        if (query.endDate) {
+            queryBuilder = queryBuilder.lte('created_at', query.endDate.toISOString());
+        }
+        // Apply pagination
+        if (query.offset) {
+            queryBuilder = queryBuilder.range(query.offset, query.offset + (query.limit ?? 50) - 1);
+        }
+        else if (query.limit) {
+            queryBuilder = queryBuilder.limit(query.limit);
+        }
+        // Order by created_at descending
+        queryBuilder = queryBuilder.order('created_at', { ascending: false });
+        const { data, error } = await queryBuilder;
+        if (error) {
+            throw new Error(`Failed to query experiences: ${error.message}`);
+        }
+        return data.map(this.rowToExperience);
+    }
+    async searchSimilarExperiences(embedding, limit) {
+        this.ensureInitialized();
+        // Use RPC function for vector similarity search
+        const { data, error } = await this.client.rpc('search_similar_experiences', {
+            query_embedding: embedding,
+            match_threshold: 0.7,
+            match_count: limit,
+        });
+        if (error) {
+            throw new Error(`Failed to search experiences: ${error.message}`);
+        }
+        // The RPC returns a different shape, map it
+        return data.map((row) => ({
+            ...this.rowToExperience(row),
+            // Could add similarity score to metadata if needed
+        }));
+    }
+    // ============================================
+    // Patterns
+    // ============================================
+    async storePattern(pattern) {
+        this.ensureInitialized();
+        const row = {
+            id: pattern.id,
+            project_id: this.projectId,
+            type: pattern.type,
+            domain: pattern.domain ?? 'general',
+            framework: pattern.framework ?? null,
+            content: pattern.content ?? '',
+            embedding: pattern.embedding ?? null,
+            confidence: pattern.confidence,
+            usage_count: pattern.usageCount,
+            last_used: pattern.lastUsed?.toISOString() ?? null,
+            verdict: pattern.verdict ?? null,
+            privacy_level: pattern.privacyLevel,
+            is_anonymized: pattern.isAnonymized,
+            source_hash: pattern.sourceHash ?? null,
+            metadata: pattern.metadata,
+            created_at: pattern.createdAt.toISOString(),
+        };
+        const { error } = await this.client
+            .from(SupabaseConfig_js_1.SUPABASE_TABLES.PATTERNS)
+            .upsert(row, { onConflict: 'id' });
+        if (error) {
+            throw new Error(`Failed to store pattern: ${error.message}`);
+        }
+    }
+    async queryPatterns(query) {
+        this.ensureInitialized();
+        let queryBuilder = this.client
+            .from(SupabaseConfig_js_1.SUPABASE_TABLES.PATTERNS)
+            .select('*')
+            .eq('project_id', this.projectId);
+        // Apply filters
+        if (query.type) {
+            queryBuilder = queryBuilder.eq('type', query.type);
+        }
+        if (query.domain) {
+            queryBuilder = queryBuilder.eq('domain', query.domain);
+        }
+        if (query.framework) {
+            queryBuilder = queryBuilder.eq('framework', query.framework);
+        }
+        if (query.privacyLevel) {
+            queryBuilder = queryBuilder.eq('privacy_level', query.privacyLevel);
+        }
+        if (query.minConfidence !== undefined) {
+            queryBuilder = queryBuilder.gte('confidence', query.minConfidence);
+        }
+        // Apply pagination
+        if (query.offset) {
+            queryBuilder = queryBuilder.range(query.offset, query.offset + (query.limit ?? 50) - 1);
+        }
+        else if (query.limit) {
+            queryBuilder = queryBuilder.limit(query.limit);
+        }
+        // Order by usage_count descending (most used first)
+        queryBuilder = queryBuilder.order('usage_count', { ascending: false });
+        const { data, error } = await queryBuilder;
+        if (error) {
+            throw new Error(`Failed to query patterns: ${error.message}`);
+        }
+        return data.map(this.rowToPattern);
+    }
+    async searchSimilarPatterns(embedding, limit) {
+        this.ensureInitialized();
+        // Use RPC function for vector similarity search
+        const { data, error } = await this.client.rpc('search_similar_patterns', {
+            query_embedding: embedding,
+            match_threshold: 0.7,
+            match_count: limit,
+        });
+        if (error) {
+            throw new Error(`Failed to search patterns: ${error.message}`);
+        }
+        // Map RPC result to StoredPattern
+        return data.map(this.rowToPattern);
+    }
+    // ============================================
+    // Nervous System State
+    // ============================================
+    async saveNervousSystemState(agentId, component, state) {
+        this.ensureInitialized();
+        const isBinary = state instanceof Uint8Array;
+        const row = {
+            project_id: this.projectId,
+            agent_id: agentId,
+            component,
+            state_data: isBinary ? this.uint8ArrayToBase64(state) : null,
+            state_json: isBinary ? null : state,
+            version: 1,
+            updated_at: new Date().toISOString(),
+        };
+        const { error } = await this.client
+            .from(SupabaseConfig_js_1.SUPABASE_TABLES.NERVOUS_SYSTEM)
+            .upsert(row, {
+            onConflict: 'project_id,agent_id,component',
+        });
+        if (error) {
+            throw new Error(`Failed to save nervous system state: ${error.message}`);
+        }
+    }
+    async loadNervousSystemState(agentId, component) {
+        this.ensureInitialized();
+        const { data, error } = await this.client
+            .from(SupabaseConfig_js_1.SUPABASE_TABLES.NERVOUS_SYSTEM)
+            .select('*')
+            .eq('project_id', this.projectId)
+            .eq('agent_id', agentId)
+            .eq('component', component)
+            .single();
+        if (error) {
+            if (error.code === 'PGRST116') {
+                // No rows returned
+                return null;
+            }
+            throw new Error(`Failed to load nervous system state: ${error.message}`);
+        }
+        const row = data;
+        if (row.state_data) {
+            return this.base64ToUint8Array(row.state_data);
+        }
+        return row.state_json;
+    }
+    async deleteNervousSystemState(agentId) {
+        this.ensureInitialized();
+        const { error } = await this.client
+            .from(SupabaseConfig_js_1.SUPABASE_TABLES.NERVOUS_SYSTEM)
+            .delete()
+            .eq('project_id', this.projectId)
+            .eq('agent_id', agentId);
+        if (error) {
+            throw new Error(`Failed to delete nervous system state: ${error.message}`);
+        }
+    }
+    async listAgentsWithState() {
+        this.ensureInitialized();
+        const { data, error } = await this.client
+            .from(SupabaseConfig_js_1.SUPABASE_TABLES.NERVOUS_SYSTEM)
+            .select('agent_id')
+            .eq('project_id', this.projectId);
+        if (error) {
+            throw new Error(`Failed to list agents: ${error.message}`);
+        }
+        // Get unique agent IDs
+        const agentIds = new Set(data.map((r) => r.agent_id));
+        return Array.from(agentIds);
+    }
+    // ============================================
+    // Sharing (Cloud-specific)
+    // ============================================
+    async shareExperience(experienceId, privacyLevel) {
+        this.ensureInitialized();
+        const { error } = await this.client
+            .from(SupabaseConfig_js_1.SUPABASE_TABLES.EXPERIENCES)
+            .update({
+            privacy_level: privacyLevel,
+            share_count: this.client.rpc('increment_share_count'),
+        })
+            .eq('id', experienceId)
+            .eq('project_id', this.projectId);
+        if (error) {
+            throw new Error(`Failed to share experience: ${error.message}`);
+        }
+    }
+    async importSharedExperiences(query) {
+        this.ensureInitialized();
+        let queryBuilder = this.client
+            .from(SupabaseConfig_js_1.SUPABASE_TABLES.EXPERIENCES)
+            .select('*');
+        // Build privacy filter
+        const privacyFilters = [];
+        if (query.includePublic) {
+            privacyFilters.push('public');
+        }
+        if (query.includeTeam) {
+            privacyFilters.push('team');
+        }
+        if (privacyFilters.length > 0) {
+            queryBuilder = queryBuilder.in('privacy_level', privacyFilters);
+        }
+        // Exclude own project's experiences
+        queryBuilder = queryBuilder.neq('project_id', this.projectId);
+        // Apply other filters
+        if (query.agentType) {
+            queryBuilder = queryBuilder.eq('agent_type', query.agentType);
+        }
+        if (query.taskType) {
+            queryBuilder = queryBuilder.eq('task_type', query.taskType);
+        }
+        if (query.minQuality !== undefined) {
+            queryBuilder = queryBuilder.gte('confidence', query.minQuality);
+        }
+        // Apply pagination
+        if (query.limit) {
+            queryBuilder = queryBuilder.limit(query.limit);
+        }
+        const { data, error } = await queryBuilder;
+        if (error) {
+            throw new Error(`Failed to import shared experiences: ${error.message}`);
+        }
+        return data.map(this.rowToExperience);
+    }
+    async sharePattern(patternId, privacyLevel) {
+        this.ensureInitialized();
+        const { error } = await this.client
+            .from(SupabaseConfig_js_1.SUPABASE_TABLES.PATTERNS)
+            .update({ privacy_level: privacyLevel })
+            .eq('id', patternId)
+            .eq('project_id', this.projectId);
+        if (error) {
+            throw new Error(`Failed to share pattern: ${error.message}`);
+        }
+    }
+    async importSharedPatterns(query) {
+        this.ensureInitialized();
+        let queryBuilder = this.client
+            .from(SupabaseConfig_js_1.SUPABASE_TABLES.PATTERNS)
+            .select('*');
+        // Only public patterns for import
+        if (query.includePublic) {
+            queryBuilder = queryBuilder.eq('privacy_level', 'public');
+        }
+        // Exclude own project
+        queryBuilder = queryBuilder.neq('project_id', this.projectId);
+        // Apply filters
+        if (query.type) {
+            queryBuilder = queryBuilder.eq('type', query.type);
+        }
+        if (query.domain) {
+            queryBuilder = queryBuilder.eq('domain', query.domain);
+        }
+        if (query.framework) {
+            queryBuilder = queryBuilder.eq('framework', query.framework);
+        }
+        if (query.minConfidence !== undefined) {
+            queryBuilder = queryBuilder.gte('confidence', query.minConfidence);
+        }
+        // Apply pagination
+        if (query.limit) {
+            queryBuilder = queryBuilder.limit(query.limit);
+        }
+        const { data, error } = await queryBuilder;
+        if (error) {
+            throw new Error(`Failed to import shared patterns: ${error.message}`);
+        }
+        return data.map(this.rowToPattern);
+    }
+    // ============================================
+    // Memory Entries
+    // ============================================
+    async storeMemoryEntry(entry) {
+        this.ensureInitialized();
+        const row = {
+            project_id: this.projectId,
+            key: entry.key,
+            partition: entry.partition,
+            value: entry.value,
+            owner: entry.owner,
+            access_level: entry.accessLevel,
+            team_id: entry.teamId ?? null,
+            swarm_id: entry.swarmId ?? null,
+            metadata: entry.metadata ?? null,
+            created_at: entry.createdAt.toISOString(),
+            expires_at: entry.expiresAt?.toISOString() ?? null,
+        };
+        const { error } = await this.client
+            .from(SupabaseConfig_js_1.SUPABASE_TABLES.MEMORY_ENTRIES)
+            .upsert(row, { onConflict: 'project_id,partition,key' });
+        if (error) {
+            throw new Error(`Failed to store memory entry: ${error.message}`);
+        }
+    }
+    async storeMemoryEntries(entries) {
+        if (entries.length === 0)
+            return;
+        this.ensureInitialized();
+        const rows = entries.map((entry) => ({
+            project_id: this.projectId,
+            key: entry.key,
+            partition: entry.partition,
+            value: entry.value,
+            owner: entry.owner,
+            access_level: entry.accessLevel,
+            team_id: entry.teamId ?? null,
+            swarm_id: entry.swarmId ?? null,
+            metadata: entry.metadata ?? null,
+            created_at: entry.createdAt.toISOString(),
+            expires_at: entry.expiresAt?.toISOString() ?? null,
+        }));
+        const { error } = await this.client
+            .from(SupabaseConfig_js_1.SUPABASE_TABLES.MEMORY_ENTRIES)
+            .upsert(rows, { onConflict: 'project_id,partition,key' });
+        if (error) {
+            throw new Error(`Failed to store memory entries: ${error.message}`);
+        }
+    }
+    async getMemoryEntry(key, partition = 'default') {
+        this.ensureInitialized();
+        const { data, error } = await this.client
+            .from(SupabaseConfig_js_1.SUPABASE_TABLES.MEMORY_ENTRIES)
+            .select('*')
+            .eq('project_id', this.projectId)
+            .eq('partition', partition)
+            .eq('key', key)
+            .single();
+        if (error) {
+            if (error.code === 'PGRST116') {
+                return null;
+            }
+            throw new Error(`Failed to get memory entry: ${error.message}`);
+        }
+        return this.rowToMemoryEntry(data);
+    }
+    async queryMemoryEntries(query) {
+        this.ensureInitialized();
+        let queryBuilder = this.client
+            .from(SupabaseConfig_js_1.SUPABASE_TABLES.MEMORY_ENTRIES)
+            .select('*')
+            .eq('project_id', this.projectId);
+        if (query.partition) {
+            queryBuilder = queryBuilder.eq('partition', query.partition);
+        }
+        if (query.owner) {
+            queryBuilder = queryBuilder.eq('owner', query.owner);
+        }
+        if (query.keyPattern) {
+            queryBuilder = queryBuilder.ilike('key', query.keyPattern.replace('*', '%'));
+        }
+        if (query.accessLevel) {
+            queryBuilder = queryBuilder.eq('access_level', query.accessLevel);
+        }
+        if (!query.includeExpired) {
+            queryBuilder = queryBuilder.or('expires_at.is.null,expires_at.gt.now()');
+        }
+        if (query.offset) {
+            queryBuilder = queryBuilder.range(query.offset, query.offset + (query.limit ?? 100) - 1);
+        }
+        else if (query.limit) {
+            queryBuilder = queryBuilder.limit(query.limit);
+        }
+        const { data, error } = await queryBuilder;
+        if (error) {
+            throw new Error(`Failed to query memory entries: ${error.message}`);
+        }
+        return data.map(this.rowToMemoryEntry);
+    }
+    async deleteMemoryEntries(keyPattern, partition) {
+        this.ensureInitialized();
+        let queryBuilder = this.client
+            .from(SupabaseConfig_js_1.SUPABASE_TABLES.MEMORY_ENTRIES)
+            .delete()
+            .eq('project_id', this.projectId)
+            .ilike('key', keyPattern.replace('*', '%'));
+        if (partition) {
+            queryBuilder = queryBuilder.eq('partition', partition);
+        }
+        const { data, error } = await queryBuilder.select('id');
+        if (error) {
+            throw new Error(`Failed to delete memory entries: ${error.message}`);
+        }
+        return data.length;
+    }
+    // ============================================
+    // Events
+    // ============================================
+    async storeEvent(event) {
+        this.ensureInitialized();
+        const row = {
+            id: event.id,
+            project_id: this.projectId,
+            type: event.type,
+            payload: event.payload,
+            source: event.source,
+            timestamp: event.timestamp.toISOString(),
+            ttl: event.ttl,
+        };
+        const { error } = await this.client
+            .from(SupabaseConfig_js_1.SUPABASE_TABLES.EVENTS)
+            .insert(row);
+        if (error) {
+            throw new Error(`Failed to store event: ${error.message}`);
+        }
+    }
+    async storeEvents(events) {
+        if (events.length === 0)
+            return;
+        this.ensureInitialized();
+        const rows = events.map((event) => ({
+            id: event.id,
+            project_id: this.projectId,
+            type: event.type,
+            payload: event.payload,
+            source: event.source,
+            timestamp: event.timestamp.toISOString(),
+            ttl: event.ttl,
+        }));
+        const { error } = await this.client
+            .from(SupabaseConfig_js_1.SUPABASE_TABLES.EVENTS)
+            .insert(rows);
+        if (error) {
+            throw new Error(`Failed to store events: ${error.message}`);
+        }
+    }
+    async queryEvents(query) {
+        this.ensureInitialized();
+        let queryBuilder = this.client
+            .from(SupabaseConfig_js_1.SUPABASE_TABLES.EVENTS)
+            .select('*')
+            .eq('project_id', this.projectId);
+        if (query.type) {
+            queryBuilder = queryBuilder.eq('type', query.type);
+        }
+        if (query.source) {
+            queryBuilder = queryBuilder.eq('source', query.source);
+        }
+        if (query.startTime) {
+            queryBuilder = queryBuilder.gte('timestamp', query.startTime.toISOString());
+        }
+        if (query.endTime) {
+            queryBuilder = queryBuilder.lte('timestamp', query.endTime.toISOString());
+        }
+        queryBuilder = queryBuilder.order('timestamp', { ascending: false });
+        if (query.offset) {
+            queryBuilder = queryBuilder.range(query.offset, query.offset + (query.limit ?? 100) - 1);
+        }
+        else if (query.limit) {
+            queryBuilder = queryBuilder.limit(query.limit);
+        }
+        const { data, error } = await queryBuilder;
+        if (error) {
+            throw new Error(`Failed to query events: ${error.message}`);
+        }
+        return data.map(this.rowToEvent);
+    }
+    async deleteOldEvents(olderThan) {
+        this.ensureInitialized();
+        const { data, error } = await this.client
+            .from(SupabaseConfig_js_1.SUPABASE_TABLES.EVENTS)
+            .delete()
+            .eq('project_id', this.projectId)
+            .lt('timestamp', olderThan.toISOString())
+            .select('id');
+        if (error) {
+            throw new Error(`Failed to delete old events: ${error.message}`);
+        }
+        return data.length;
+    }
+    // ============================================
+    // Code Chunks
+    // ============================================
+    async storeCodeChunk(chunk) {
+        this.ensureInitialized();
+        const row = {
+            id: chunk.id,
+            project_id: this.projectId,
+            file_path: chunk.filePath,
+            start_line: chunk.startLine,
+            end_line: chunk.endLine,
+            chunk_type: chunk.chunkType,
+            name: chunk.name ?? null,
+            language: chunk.language,
+            content: chunk.content,
+            embedding: chunk.embedding ?? null,
+            metadata: chunk.metadata ?? null,
+            commit_sha: chunk.commitSha ?? null,
+            indexed_at: chunk.indexedAt.toISOString(),
+        };
+        const { error } = await this.client
+            .from(SupabaseConfig_js_1.SUPABASE_TABLES.CODE_CHUNKS)
+            .upsert(row, { onConflict: 'project_id,file_path,start_line,end_line' });
+        if (error) {
+            throw new Error(`Failed to store code chunk: ${error.message}`);
+        }
+    }
+    async storeCodeChunks(chunks) {
+        if (chunks.length === 0)
+            return;
+        this.ensureInitialized();
+        const rows = chunks.map((chunk) => ({
+            id: chunk.id,
+            project_id: this.projectId,
+            file_path: chunk.filePath,
+            start_line: chunk.startLine,
+            end_line: chunk.endLine,
+            chunk_type: chunk.chunkType,
+            name: chunk.name ?? null,
+            language: chunk.language,
+            content: chunk.content,
+            embedding: chunk.embedding ?? null,
+            metadata: chunk.metadata ?? null,
+            commit_sha: chunk.commitSha ?? null,
+            indexed_at: chunk.indexedAt.toISOString(),
+        }));
+        const { error } = await this.client
+            .from(SupabaseConfig_js_1.SUPABASE_TABLES.CODE_CHUNKS)
+            .upsert(rows, { onConflict: 'project_id,file_path,start_line,end_line' });
+        if (error) {
+            throw new Error(`Failed to store code chunks: ${error.message}`);
+        }
+    }
+    async queryCodeChunks(query) {
+        this.ensureInitialized();
+        let queryBuilder = this.client
+            .from(SupabaseConfig_js_1.SUPABASE_TABLES.CODE_CHUNKS)
+            .select('*')
+            .eq('project_id', query.projectId ?? this.projectId);
+        if (query.filePattern) {
+            queryBuilder = queryBuilder.ilike('file_path', query.filePattern.replace('*', '%'));
+        }
+        if (query.chunkType) {
+            queryBuilder = queryBuilder.eq('chunk_type', query.chunkType);
+        }
+        if (query.language) {
+            queryBuilder = queryBuilder.eq('language', query.language);
+        }
+        if (query.namePattern) {
+            queryBuilder = queryBuilder.ilike('name', query.namePattern.replace('*', '%'));
+        }
+        if (query.offset) {
+            queryBuilder = queryBuilder.range(query.offset, query.offset + (query.limit ?? 100) - 1);
+        }
+        else if (query.limit) {
+            queryBuilder = queryBuilder.limit(query.limit);
+        }
+        const { data, error } = await queryBuilder;
+        if (error) {
+            throw new Error(`Failed to query code chunks: ${error.message}`);
+        }
+        return data.map(this.rowToCodeChunk);
+    }
+    async searchSimilarCode(embedding, options) {
+        this.ensureInitialized();
+        const { data, error } = await this.client.rpc('search_similar_code', {
+            query_embedding: embedding,
+            match_threshold: options?.minScore ?? 0.7,
+            match_count: options?.limit ?? 10,
+            filter_project_id: options?.projectId ?? this.projectId,
+            filter_language: options?.language ?? null,
+        });
+        if (error) {
+            throw new Error(`Failed to search similar code: ${error.message}`);
+        }
+        return data.map((row) => ({
+            chunk: this.rowToCodeChunk(row),
+            score: row.similarity,
+        }));
+    }
+    async deleteCodeChunksForFile(projectId, filePath) {
+        this.ensureInitialized();
+        const { data, error } = await this.client
+            .from(SupabaseConfig_js_1.SUPABASE_TABLES.CODE_CHUNKS)
+            .delete()
+            .eq('project_id', projectId)
+            .eq('file_path', filePath)
+            .select('id');
+        if (error) {
+            throw new Error(`Failed to delete code chunks for file: ${error.message}`);
+        }
+        return data.length;
+    }
+    async deleteCodeChunksForProject(projectId) {
+        this.ensureInitialized();
+        const { data, error } = await this.client
+            .from(SupabaseConfig_js_1.SUPABASE_TABLES.CODE_CHUNKS)
+            .delete()
+            .eq('project_id', projectId)
+            .select('id');
+        if (error) {
+            throw new Error(`Failed to delete code chunks for project: ${error.message}`);
+        }
+        return data.length;
+    }
+    // ============================================
+    // Info
+    // ============================================
+    getProviderInfo() {
+        return {
+            type: 'supabase',
+            features: [
+                'cloud-persistence',
+                'vector-search',
+                'multi-tenant',
+                'rls-security',
+                'experience-sharing',
+                'pattern-sharing',
+                'real-time-sync',
+                'memory-sync',
+                'event-sync',
+                'code-intelligence-sync',
+            ],
+            initialized: this.initialized,
+            location: this.config.connection.url,
+        };
+    }
+    // ============================================
+    // Private Methods
+    // ============================================
+    ensureInitialized() {
+        if (!this.initialized || !this.client) {
+            throw new Error('SupabasePersistenceProvider not initialized. Call initialize() first.');
+        }
+    }
+    /**
+     * Get or create the project for this provider
+     */
+    async ensureProject() {
+        // If project ID is configured, use it
+        if (this.config.project.projectId) {
+            return this.config.project.projectId;
+        }
+        // Try to get current user's default project
+        const { data: user } = await this.client.auth.getUser();
+        if (user?.user) {
+            const { data: projects } = await this.client
+                .from(SupabaseConfig_js_1.SUPABASE_TABLES.PROJECTS)
+                .select('id')
+                .eq('owner_id', user.user.id)
+                .limit(1);
+            if (projects && projects.length > 0) {
+                return projects[0].id;
+            }
+            // Create a default project
+            const { data: newProject, error } = await this.client
+                .from(SupabaseConfig_js_1.SUPABASE_TABLES.PROJECTS)
+                .insert({
+                name: 'Default Project',
+                owner_id: user.user.id,
+                settings: this.config.sharing,
+            })
+                .select('id')
+                .single();
+            if (error) {
+                throw new Error(`Failed to create project: ${error.message}`);
+            }
+            return newProject.id;
+        }
+        // For anonymous usage, generate a local project ID
+        return `local-${Date.now()}`;
+    }
+    /**
+     * Convert database row to LearningExperience
+     */
+    rowToExperience(row) {
+        return {
+            id: row.id,
+            agentId: row.agent_id,
+            agentType: row.agent_type,
+            taskType: row.task_type,
+            context: row.context,
+            outcome: row.outcome,
+            embedding: row.embedding ?? undefined,
+            privacyLevel: row.privacy_level,
+            isAnonymized: row.is_anonymized,
+            shareCount: row.share_count,
+            createdAt: new Date(row.created_at),
+            createdBy: row.created_by ?? undefined,
+        };
+    }
+    /**
+     * Convert database row to StoredPattern
+     */
+    rowToPattern(row) {
+        return {
+            id: row.id,
+            projectId: row.project_id,
+            type: row.type,
+            domain: row.domain,
+            framework: row.framework ?? undefined,
+            content: row.content,
+            embedding: row.embedding ?? undefined,
+            confidence: row.confidence,
+            usageCount: row.usage_count,
+            lastUsed: row.last_used ? new Date(row.last_used) : undefined,
+            verdict: row.verdict ?? undefined,
+            privacyLevel: row.privacy_level,
+            isAnonymized: row.is_anonymized,
+            sourceHash: row.source_hash ?? undefined,
+            metadata: row.metadata,
+            createdAt: new Date(row.created_at),
+        };
+    }
+    /**
+     * Convert database row to MemoryEntry
+     */
+    rowToMemoryEntry(row) {
+        return {
+            key: row.key,
+            value: row.value,
+            partition: row.partition,
+            owner: row.owner,
+            accessLevel: row.access_level,
+            teamId: row.team_id ?? undefined,
+            swarmId: row.swarm_id ?? undefined,
+            metadata: row.metadata ?? undefined,
+            createdAt: new Date(row.created_at),
+            expiresAt: row.expires_at ? new Date(row.expires_at) : null,
+        };
+    }
+    /**
+     * Convert database row to EventRecord
+     */
+    rowToEvent(row) {
+        return {
+            id: row.id,
+            type: row.type,
+            payload: row.payload,
+            source: row.source,
+            timestamp: new Date(row.timestamp),
+            ttl: row.ttl,
+        };
+    }
+    /**
+     * Convert database row to CodeChunk
+     */
+    rowToCodeChunk(row) {
+        return {
+            id: row.id,
+            projectId: row.project_id,
+            filePath: row.file_path,
+            startLine: row.start_line,
+            endLine: row.end_line,
+            chunkType: row.chunk_type,
+            name: row.name ?? undefined,
+            language: row.language,
+            content: row.content,
+            embedding: row.embedding ?? undefined,
+            metadata: row.metadata ?? undefined,
+            commitSha: row.commit_sha ?? undefined,
+            indexedAt: new Date(row.indexed_at),
+        };
+    }
+    /**
+     * Convert Uint8Array to base64 string for storage
+     */
+    uint8ArrayToBase64(data) {
+        if (typeof Buffer !== 'undefined') {
+            return Buffer.from(data).toString('base64');
+        }
+        // Browser fallback
+        let binary = '';
+        for (let i = 0; i < data.length; i++) {
+            binary += String.fromCharCode(data[i]);
+        }
+        return btoa(binary);
+    }
+    /**
+     * Convert base64 string back to Uint8Array
+     */
+    base64ToUint8Array(base64) {
+        if (typeof Buffer !== 'undefined') {
+            return new Uint8Array(Buffer.from(base64, 'base64'));
+        }
+        // Browser fallback
+        const binary = atob(base64);
+        const bytes = new Uint8Array(binary.length);
+        for (let i = 0; i < binary.length; i++) {
+            bytes[i] = binary.charCodeAt(i);
+        }
+        return bytes;
+    }
+}
+exports.SupabasePersistenceProvider = SupabasePersistenceProvider;
+/**
+ * Factory function to create a Supabase persistence provider
+ *
+ * @param config Configuration overrides
+ * @returns Configured provider instance
+ */
+function createSupabasePersistenceProvider(config = {}) {
+    return new SupabasePersistenceProvider(config);
+}
+//# sourceMappingURL=SupabasePersistenceProvider.js.map