Update stateManager.js

stateManager.js

@@ -4,9 +4,10 @@ let supabase = null;
 const activeProjects = new Map();
 const initializationLocks = new Set(); 
 
-const streamBuffers = new Map(); 
-const statusBuffers = new Map(); 
-const snapshotBuffers = new Map(); 
+// --- REALTIME BUFFERS ---
+const streamBuffers = new Map(); // Destructive (Plugin)
+const statusBuffers = new Map(); // Status (Frontend)
+const snapshotBuffers = new Map(); // Non-Destructive (Frontend)
 
 export const initDB = () => {
     if (!process.env.SUPABASE_URL || !process.env.SUPABASE_SERVICE_ROLE_KEY) {
@@ -24,7 +25,9 @@ export const StateManager = {
     getProject: async (projectId) => {
         if (activeProjects.has(projectId)) {
             const cached = activeProjects.get(projectId);
-            if (cached.workerHistory && cached.pmHistory) return cached;
+            if (cached.workerHistory && cached.pmHistory) {
+                return cached;
+            }
         }
         
         const { data: proj, error } = await supabase.from('projects').select('*').eq('id', projectId).single();
@@ -38,9 +41,14 @@ export const StateManager = {
             ...proj.info,
             id: proj.id,
             userId: proj.user_id,
+            thumbnail: proj.info?.thumbnail || null,
+            gdd: proj.info?.gdd || null,
+            
             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: [], 
+            failureCount: proj.info?.failureCount || 0,
             lastActive: Date.now()
         };
 
@@ -58,48 +66,87 @@ export const StateManager = {
         }
 
         try {
-            const { data: chunks } = await supabase.from('message_chunks')
-                .select('id, chunk_index, payload').eq('project_id', projectId).eq('type', type)
-                .order('chunk_index', { ascending: false }).limit(1);
+            const { data: chunks, error: fetchError } = await supabase.from('message_chunks')
+                .select('id, chunk_index, payload')
+                .eq('project_id', projectId)
+                .eq('type', type)
+                .order('chunk_index', { ascending: false })
+                .limit(10);
+
+            if (fetchError) {
+                console.error(`[DB Error] Failed to fetch history for ${projectId}:`, fetchError.message);
+                return;
+            }
 
             const latest = chunks?.[0];
             const currentPayload = (latest && Array.isArray(latest.payload)) ? latest.payload : [];
+            const latestIndex = (latest && typeof latest.chunk_index === 'number') ? latest.chunk_index : -1;
 
             if (latest && currentPayload.length < 20) {
-                await supabase.from('message_chunks').update({ payload: [...currentPayload, newMessage] }).eq('id', latest.id);
-            } else {
-                await supabase.from('message_chunks').insert({
-                    project_id: projectId, type, chunk_index: (latest?.chunk_index ?? -1) + 1, payload: [newMessage]
+                const updatedPayload = [...currentPayload, newMessage];
+                const { error: updateError } = await supabase.from('message_chunks')
+                    .update({ payload: updatedPayload })
+                    .eq('id', latest.id);
+                if (updateError) console.error(`[DB Error] Update chunk failed:`, updateError.message);
+            } 
+            else {
+                const nextIndex = latestIndex + 1;
+                const { error: insertError } = await supabase.from('message_chunks').insert({
+                    project_id: projectId,
+                    type,
+                    chunk_index: nextIndex,
+                    payload: [newMessage]
                 });
+                if (insertError) console.error(`[DB Error] Insert new chunk failed:`, insertError.message);
             }
-        } catch (e) { console.error("[StateManager] addHistory failed:", e.message); }
+        } catch (e) {
+            console.error("[StateManager] Unexpected error in addHistory:", e);
+        }
     },
 
-    setStatus: (projectId, status) => { statusBuffers.set(projectId, status); },
-    getStatus: (projectId) => statusBuffers.get(projectId) || "Idle",
+    setStatus: (projectId, status) => {
+        statusBuffers.set(projectId, status);
+    },
+
+    getStatus: (projectId) => {
+        return statusBuffers.get(projectId) || "Working...";
+    },
 
     appendStream: (projectId, chunk) => {
-        streamBuffers.set(projectId, (streamBuffers.get(projectId) || "") + chunk);
-        snapshotBuffers.set(projectId, (snapshotBuffers.get(projectId) || "") + chunk);
+        const currentDestructive = streamBuffers.get(projectId) || "";
+        streamBuffers.set(projectId, currentDestructive + chunk);
+
+        const currentSnapshot = snapshotBuffers.get(projectId) || "";
+        snapshotBuffers.set(projectId, currentSnapshot + chunk);
     },
+
     appendSnapshotOnly: (projectId, chunk) => {
-        snapshotBuffers.set(projectId, (snapshotBuffers.get(projectId) || "") + chunk);
+        const currentSnapshot = snapshotBuffers.get(projectId) || "";
+        snapshotBuffers.set(projectId, currentSnapshot + chunk);
     },
+
     popStream: (projectId) => {
         const content = streamBuffers.get(projectId) || "";
         streamBuffers.set(projectId, ""); 
         return content;
     },
-    getSnapshot: (projectId) => snapshotBuffers.get(projectId) || "",
+
+    getSnapshot: (projectId) => {
+        return snapshotBuffers.get(projectId) || "";
+    },
+
     clearSnapshot: (projectId) => {
         snapshotBuffers.delete(projectId);
         statusBuffers.delete(projectId);
     },
 
-    // --- RESTORED FULL REGEX LOGIC ---
     queueCommand: async (projectId, input) => {
         let project = activeProjects.get(projectId);
-        if (!project) project = await StateManager.getProject(projectId);
+        
+        if (!project) {
+            project = await StateManager.getProject(projectId);
+        }
+
         if (!project) return;
 
         let command = null;
@@ -110,12 +157,10 @@ export const StateManager = {
         else if (typeof input === 'string') {
             const rawResponse = input;
             
-            // Loop Prevention
             if (rawResponse.includes("[ASK_PM:")) return;
             if (rawResponse.includes("[ROUTE_TO_PM:")) return;
             if (rawResponse.includes("[GENERATE_IMAGE:") && !rawResponse.includes("```")) return;
 
-            // REGEX Parsing (RESTORED)
             const codeMatch = rawResponse.match(/```(?:lua|luau)?([\s\S]*?)```/i);
             const readScriptMatch = rawResponse.match(/\[READ_SCRIPT:\s*(.*?)\]/);
             const readHierarchyMatch = rawResponse.match(/\[READ_HIERARCHY:\s*(.*?)\]/);
@@ -130,7 +175,7 @@ export const StateManager = {
         if (command) {
             if (!project.commandQueue) project.commandQueue = [];
             project.commandQueue.push(command);
-            console.log(`[Memory] Queued command: ${command.type}`);
+            console.log(`[Memory] Queued command for ${projectId}: ${command.type}`);
         }
     },
 
@@ -143,16 +188,30 @@ export const StateManager = {
     updateProject: async (projectId, data) => {
         if (activeProjects.has(projectId)) {
             const current = activeProjects.get(projectId);
-            activeProjects.set(projectId, { ...current, ...data, lastActive: Date.now() });
+            const newData = { ...current, ...data, lastActive: Date.now() };
+            activeProjects.set(projectId, newData);
         }
+
+        const payload = {
+            info: {
+                title: data.title,
+                status: data.status,
+                stats: data.stats,
+                description: data.description,
+                failureCount: data.failureCount
+            }
+        };
+
+        Object.keys(payload.info).forEach(key => payload.info[key] === undefined && delete payload.info[key]);
+
         const { data: currentDb } = await supabase.from('projects').select('info').eq('id', projectId).single();
+        
         if (currentDb) {
-             const mergedInfo = { ...currentDb.info, ...data };
+             const mergedInfo = { ...currentDb.info, ...payload.info };
              delete mergedInfo.commandQueue; 
-             await supabase.from('projects').update({ 
-                info: mergedInfo, 
-                updated_at: new Date().toISOString() // RESTORED TIMESTAMP
-             }).eq('id', projectId);
+             
+             const { error } = await supabase.from('projects').update({ info: mergedInfo }).eq('id', projectId);
+             if (error) console.error("[DB ERROR] Update Project failed:", error.message);
         }
     },
 
@@ -160,13 +219,21 @@ export const StateManager = {
         const now = Date.now();
         const FOUR_HOURS = 4 * 60 * 60 * 1000;
         let count = 0;
+
         for (const [id, data] of activeProjects.entries()) {
-            if (now - (data.lastActive || now) > FOUR_HOURS) {
-                activeProjects.delete(id); streamBuffers.delete(id); snapshotBuffers.delete(id); statusBuffers.delete(id);
+            if (!data.lastActive) data.lastActive = now; 
+
+            if (now - data.lastActive > FOUR_HOURS) {
+                console.log(`[StateManager] 🧹 Removing expired project: ${id}`);
+                activeProjects.delete(id);
+                streamBuffers.delete(id); 
+                snapshotBuffers.delete(id);
+                statusBuffers.delete(id);
                 count++;
             }
         }
         return count;
     },
+
     getSupabaseClient: () => supabase
 };