Update stateManager.js

stateManager.js

@@ -5,9 +5,9 @@ let supabase = null;
 const activeProjects = new Map();
 const initializationLocks = new Set(); 
 
-// Streaming Buffers (Short-term storage for polling)
-const streamBuffers = new Map(); // projectId -> String (accumulated text)
-const statusUpdates = new Map(); // projectId -> String (current status message)
+// --- NEW STREAMING BUFFERS ---
+const streamBuffers = new Map(); // projectId -> String (accumulated partial text)
+const statusBuffers = new Map(); // projectId -> String (current status message)
 
 export const initDB = () => {
     if (!process.env.SUPABASE_URL || !process.env.SUPABASE_SERVICE_ROLE_KEY) {
@@ -26,24 +26,34 @@ export const StateManager = {
         // 1. Check Cache
         if (activeProjects.has(projectId)) {
             const cached = activeProjects.get(projectId);
-            return cached;
+            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;
 
+        // Fetch last 10 chunks to reconstruct history
         const { data: chunks } = await supabase.from('message_chunks')
             .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,
+            thumbnail: proj.info?.thumbnail || null,
+            gdd: proj.info?.gdd || null,
+            
+            // Flatten history chunks (Oldest -> Newest)
             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()
         };
 
@@ -51,9 +61,11 @@ export const StateManager = {
         return memoryObject;
     },
 
-    // --- HISTORY ---
+    // --- HISTORY (PERSISTENT & CHUNKED) ---
     addHistory: async (projectId, type, role, text) => {
         const newMessage = { role, parts: [{ text }] };
+        
+        // 1. Update local memory immediately (for speed)
         const project = activeProjects.get(projectId);
         if (project) {
             const historyKey = type === 'pm' ? 'pmHistory' : 'workerHistory';
@@ -61,64 +73,91 @@ export const StateManager = {
             project[historyKey].push(newMessage);
         }
 
+        // 2. Database Sync
         try {
-            const { data: chunks } = await supabase.from('message_chunks')
+            // Fetch ONLY the latest chunk metadata to save bandwidth
+            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(1);
+                .limit(10);
+
+            if (fetchError) {
+                console.error(`[DB Error] Failed to fetch history for ${projectId}:`, fetchError.message);
+                return;
+            }
 
             const latest = chunks?.[0];
+            
+            // Calculate current size safely
             const currentPayload = (latest && Array.isArray(latest.payload)) ? latest.payload : [];
-
-            if (latest && currentPayload.length < 20) {
-                await supabase.from('message_chunks').update({ payload: [...currentPayload, newMessage] }).eq('id', latest.id);
-            } else {
-                const nextIndex = (latest?.chunk_index ?? -1) + 1;
-                await supabase.from('message_chunks').insert({
-                    project_id: projectId, type, chunk_index: nextIndex, payload: [newMessage]
+            const currentSize = currentPayload.length;
+            const latestIndex = (latest && typeof latest.chunk_index === 'number') ? latest.chunk_index : -1;
+
+            // LOGIC: If we have a chunk and it has room (< 20 items), UPDATE it.
+            if (latest && currentSize < 20) {
+                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: Create a NEW chunk
+            else {
+                const nextIndex = latestIndex + 1;
+                const { error: insertError } = await supabase.from('message_chunks').insert({
+                    project_id: projectId,
+                    type,
+                    chunk_index: nextIndex,
+                    payload: [newMessage] // Start new array
                 });
+                if (insertError) console.error(`[DB Error] Insert new chunk failed:`, insertError.message);
             }
-        } catch (e) { console.error("[StateManager] DB Sync Error:", e); }
-    },
-
-    // --- STREAM BUFFERING (For Polling) ---
-    updateStatus: (projectId, message) => {
-        statusUpdates.set(projectId, message);
-    },
-
-    getStatus: (projectId) => {
-        return statusUpdates.get(projectId) || "Idle";
-    },
-
-    appendToStream: (projectId, textChunk) => {
-        const current = streamBuffers.get(projectId) || "";
-        streamBuffers.set(projectId, current + textChunk);
-    },
-
-    popStream: (projectId) => {
-        const content = streamBuffers.get(projectId) || "";
-        streamBuffers.set(projectId, ""); // Clear after popping
-        return content;
+        } catch (e) {
+            console.error("[StateManager] Unexpected error in addHistory:", e);
+        }
     },
 
-    // --- COMMANDS ---
+    // --- COMMANDS (MEMORY ONLY + PARSING) ---
     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;
-        if (typeof input === 'object' && input.type) command = input;
+
+        if (typeof input === 'object' && input.type && input.payload) {
+            command = input;
+        } 
         else if (typeof input === 'string') {
-            const codeMatch = input.match(/```(?:lua|luau)?([\s\S]*?)```/i);
+            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
+            const codeMatch = rawResponse.match(/```(?:lua|luau)?([\s\S]*?)```/i);
+            const readScriptMatch = rawResponse.match(/\[READ_SCRIPT:\s*(.*?)\]/);
+            const readHierarchyMatch = rawResponse.match(/\[READ_HIERARCHY:\s*(.*?)\]/);
+            const readLogsMatch = rawResponse.includes("[READ_LOGS]");
+
             if (codeMatch) command = { type: "EXECUTE", payload: codeMatch[1].trim() };
+            else if (readScriptMatch) command = { type: "READ_SCRIPT", payload: readScriptMatch[1].trim() };
+            else if (readHierarchyMatch) command = { type: "READ_HIERARCHY", payload: readHierarchyMatch[1].trim() };
+            else if (readLogsMatch) command = { type: "READ_LOGS", payload: null };
         }
         
         if (command) {
             if (!project.commandQueue) project.commandQueue = [];
             project.commandQueue.push(command);
+            console.log(`[Memory] Queued command for ${projectId}: ${command.type}`);
         }
     },
 
@@ -128,12 +167,75 @@ export const StateManager = {
         return project.commandQueue.shift();
     },
 
+    // --- STREAMING HELPERS (FOR POLLING) ---
+    setStatus: (projectId, status) => {
+        statusBuffers.set(projectId, status);
+    },
+
+    getStatus: (projectId) => {
+        return statusBuffers.get(projectId) || "Idle";
+    },
+
+    appendStream: (projectId, chunk) => {
+        const current = streamBuffers.get(projectId) || "";
+        streamBuffers.set(projectId, current + chunk);
+    },
+
+    popStream: (projectId) => {
+        const content = streamBuffers.get(projectId) || "";
+        streamBuffers.set(projectId, ""); // Clear buffer after read
+        return content;
+    },
+
+    // --- METADATA UPDATE ---
     updateProject: async (projectId, data) => {
+        // 1. Update Memory
         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);
+        }
+
+        // 2. Prepare DB Payload
+        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, ...payload.info };
+             delete mergedInfo.commandQueue; 
+             
+             const { error } = await supabase.from('projects').update({ info: mergedInfo }).eq('id', projectId);
+             if (error) console.error("[DB ERROR] Update Project failed:", error.message);
+        }
+    },
+
+    cleanupMemory: () => {
+        const now = Date.now();
+        const FOUR_HOURS = 4 * 60 * 60 * 1000;
+        let count = 0;
+
+        for (const [id, data] of activeProjects.entries()) {
+            if (!data.lastActive) data.lastActive = now; 
+            if (now - data.lastActive > FOUR_HOURS) {
+                activeProjects.delete(id);
+                // Also clean streams
+                streamBuffers.delete(id);
+                statusBuffers.delete(id);
+                count++;
+            }
         }
-        // DB update logic omitted for brevity, assumed same as before
+        return count;
     },
 
     getSupabaseClient: () => supabase