Update stateManager.js

stateManager.js

@@ -3,21 +3,32 @@ import { createClient } from '@supabase/supabase-js';
 
 let supabase = null;
 const activeProjects = new Map();
-const initializationLocks = new Set(); // To prevent double-init
+const initializationLocks = new Set(); 
 
 export const initDB = () => {
+    if (!process.env.SUPABASE_URL || !process.env.SUPABASE_SERVICE_ROLE_KEY) {
+        console.error("Missing Supabase Env Variables");
+        return;
+    }
     supabase = createClient(process.env.SUPABASE_URL, process.env.SUPABASE_SERVICE_ROLE_KEY);
 };
 
 export const StateManager = {
-    // NEW: Check if project is already being initialized
     isLocked: (projectId) => initializationLocks.has(projectId),
     lock: (projectId) => initializationLocks.add(projectId),
     unlock: (projectId) => initializationLocks.delete(projectId),
 
     getProject: async (projectId) => {
-        if (activeProjects.has(projectId)) return activeProjects.get(projectId);
+        // 1. Check Cache
+        if (activeProjects.has(projectId)) {
+            const cached = activeProjects.get(projectId);
+            // Extra safety: Ensure it's a "Real" project object with history arrays
+            if (cached.workerHistory && cached.pmHistory) {
+                return cached;
+            }
+        }
         
+        // 2. Fetch from DB
         const { data: proj, error } = await supabase.from('projects').select('*').eq('id', projectId).single();
         if (error || !proj) return null;
 
@@ -25,14 +36,16 @@ export const StateManager = {
             .select('*').eq('project_id', projectId)
             .order('chunk_index', { ascending: false }).limit(10);
 
+        // 3. Construct Full Memory Object
         const memoryObject = {
             ...proj.info,
             id: proj.id,
-            userId: proj.user_id,
-            workerHistory: (chunks || []).filter(c => c.type === 'worker').reverse().flatMap(c => c.payload),
-            pmHistory: (chunks || []).filter(c => c.type === 'pm').reverse().flatMap(c => c.payload),
-            commandQueue: proj.info.commandQueue || [],
-            failureCount: proj.info.failureCount || 0,
+            user_id: proj.user_id, // Note: Supabase usually uses snake_case 'user_id'
+            userId: proj.user_id,  // Keeping camelCase for compatibility
+            workerHistory: (chunks || []).filter(c => c.type === 'worker').reverse().flatMap(c => c.payload || []),
+            pmHistory: (chunks || []).filter(c => c.type === 'pm').reverse().flatMap(c => c.payload || []),
+            commandQueue: proj.info?.commandQueue || [],
+            failureCount: proj.info?.failureCount || 0,
             lastActive: Date.now()
         };
 
@@ -40,35 +53,48 @@ export const StateManager = {
         return memoryObject;
     },
 
-    // ADVANCED SYNC: Always backs up immediately to DB
     addHistory: async (projectId, type, role, text) => {
         const newMessage = { role, parts: [{ text }] };
         
-        // 1. Update local memory immediately so AI has context for next turn
+        // 1. Update local memory (Optimistic)
         const project = activeProjects.get(projectId);
         if (project) {
             const historyKey = type === 'pm' ? 'pmHistory' : 'workerHistory';
+            
+            // FIX: Ensure the array exists before pushing
+            if (!Array.isArray(project[historyKey])) {
+                project[historyKey] = [];
+            }
             project[historyKey].push(newMessage);
         }
 
-        // 2. Fetch latest chunk from DB to see if we append or create new
-        const { data: chunks } = await supabase.from('message_chunks')
-            .select('*').eq('project_id', projectId).eq('type', type)
-            .order('chunk_index', { ascending: false }).limit(1);
+        // 2. Database Sync
+        const { data: chunks, error: fetchError } = await supabase.from('message_chunks')
+            .select('*')
+            .eq('project_id', projectId)
+            .eq('type', type)
+            .order('chunk_index', { ascending: false })
+            .limit(1);
+
+        if (fetchError) {
+            console.error(`[DB ERROR] Fetching chunks for ${projectId}:`, fetchError.message);
+            return;
+        }
 
         const latest = chunks?.[0];
 
-        if (latest && latest.payload.length < 20) {
-            // APPEND & UPDATE DB IMMEDIATELY
-            const updatedPayload = [...latest.payload, newMessage];
+        // Check if we can append to the latest chunk (limit 20 messages per chunk)
+        if (latest && latest.payload && latest.payload.length < 20) {
+            // APPEND
+            const updatedPayload = [...(latest.payload || []), newMessage]; // Safety check on payload
             const { error } = await supabase.from('message_chunks')
                 .update({ payload: updatedPayload })
                 .eq('id', latest.id);
             
             if (error) console.error(`[DB ERROR] Failed to append ${type} history:`, error.message);
         } else {
-            // CREATE NEW CHUNK & INSERT IMMEDIATELY
-            const nextIndex = latest ? latest.chunk_index + 1 : 0;
+            // CREATE NEW CHUNK
+            const nextIndex = latest ? (latest.chunk_index + 1) : 0;
             const { error } = await supabase.from('message_chunks').insert({
                 project_id: projectId,
                 type,
@@ -81,24 +107,48 @@ export const StateManager = {
     },
 
     updateProject: async (projectId, data) => {
-        const current = activeProjects.get(projectId) || {};
-        const newData = { ...current, ...data, lastActive: Date.now() };
-        activeProjects.set(projectId, newData);
+        // FIX: Don't create a "ghost" object if project isn't in memory.
+        // If it's not in memory, we update DB only. Next getProject() will fetch fresh data.
+        if (activeProjects.has(projectId)) {
+            const current = activeProjects.get(projectId);
+            const newData = { ...current, ...data, lastActive: Date.now() };
+            activeProjects.set(projectId, newData);
+        }
 
+        // Prepare DB Payload (Flattening for JSONB 'info' column)
+        // We fetch current DB state first if we want to be perfectly safe, 
+        // but typically overwriting specific fields in 'info' is handled via logic.
+        // Since 'info' is a JSONB column, we usually need to merge carefully or replace.
+        // Assuming your architecture passes the *full* info object or we merge blindly here:
+        
+        // Note: Ideally, we should fetch the current info from DB to merge if not in memory,
+        // but for performance, we assume caller knows what they are doing.
+        
         const payload = {
             info: {
-                title: newData.title || current.title,
-                status: newData.status || current.status,
-                stats: newData.stats || current.stats,
-                description: newData.description || current.description,
-                commandQueue: newData.commandQueue || current.commandQueue || [],
-                failureCount: newData.failureCount || 0
+                title: data.title, // If undefined, it might clear it if we aren't careful. 
+                status: data.status,
+                stats: data.stats,
+                description: data.description,
+                commandQueue: data.commandQueue,
+                failureCount: data.failureCount
             }
         };
 
-        const { error } = await supabase.from('projects').update(payload).eq('id', projectId);
-        if (error) console.error("[DB ERROR] Update Project failed:", error.message);
-        return newData;
+        // Clean payload: Remove undefined keys to prevent wiping DB data
+        Object.keys(payload.info).forEach(key => payload.info[key] === undefined && delete payload.info[key]);
+
+        // Supabase JSONB update: This replaces the 'info' column content. 
+        // If you want deep merge, you need a specific Postgres function or fetch-modify-write.
+        // For now, we do a basic update on the column.
+        
+        // Fetch current to ensure we don't wipe unrelated info fields
+        const { data: currentDb } = await supabase.from('projects').select('info').eq('id', projectId).single();
+        if (currentDb) {
+             const mergedInfo = { ...currentDb.info, ...payload.info };
+             const { error } = await supabase.from('projects').update({ info: mergedInfo }).eq('id', projectId);
+             if (error) console.error("[DB ERROR] Update Project failed:", error.message);
+        }
     },
 
     getSupabaseClient: () => supabase