Update stateManager.js

stateManager.js

@@ -22,7 +22,6 @@ export const StateManager = {
         // 1. Check Cache
         if (activeProjects.has(projectId)) {
             const cached = activeProjects.get(projectId);
-            // Ensure we have history arrays to prevent crashes
             if (cached.workerHistory && cached.pmHistory) {
                 return cached;
             }
@@ -32,6 +31,7 @@ export const StateManager = {
         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);
@@ -41,10 +41,10 @@ export const StateManager = {
             ...proj.info,
             id: proj.id,
             userId: proj.user_id,
-            // --- RESTORED FIELDS ---
-            thumbnail: proj.info?.thumbnail || null, // Ensure thumbnail is carried over
-            gdd: proj.info?.gdd || null,             // Ensure GDD is carried over
-            // -----------------------
+            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 || []),
             
@@ -57,12 +57,11 @@ export const StateManager = {
         return memoryObject;
     },
 
-  
-    // --- HISTORY (PERSISTENT) ---
+    // --- HISTORY (PERSISTENT & CHUNKED) ---
     addHistory: async (projectId, type, role, text) => {
         const newMessage = { role, parts: [{ text }] };
         
-        // 1. Update local memory immediately
+        // 1. Update local memory immediately (for speed)
         const project = activeProjects.get(projectId);
         if (project) {
             const historyKey = type === 'pm' ? 'pmHistory' : 'workerHistory';
@@ -70,34 +69,60 @@ export const StateManager = {
             project[historyKey].push(newMessage);
         }
 
-        // 2. Database Sync (Optimized Chunking)
-        const { data: chunks } = await supabase.from('message_chunks')
-            .select('*')
-            .eq('project_id', projectId)
-            .eq('type', type)
-            .order('chunk_index', { ascending: false })
-            .limit(1);
-
-        const latest = chunks?.[0];
-
-        if (latest && latest.payload && latest.payload.length < 20) {
-            const updatedPayload = [...(latest.payload || []), newMessage];
-            await supabase.from('message_chunks')
-                .update({ payload: updatedPayload })
-                .eq('id', latest.id);
-        } else {
-            const nextIndex = latest ? (latest.chunk_index + 1) : 0;
-            await supabase.from('message_chunks').insert({
-                project_id: projectId,
-                type,
-                chunk_index: nextIndex,
-                payload: [newMessage]
-            });
+        // 2. Database Sync
+        try {
+            // 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(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 : [];
+            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) {
+                console.log(`[History] Appending to Chunk ${latestIndex} (Count: ${currentSize} -> ${currentSize + 1})`);
+                
+                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;
+                console.log(`[History] Chunk ${latestIndex} full (${currentSize}). Creating Chunk ${nextIndex}.`);
+                
+                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] Unexpected error in addHistory:", e);
         }
     },
-    
 
-    // --- COMMANDS (MEMORY ONLY) ---
+    // --- COMMANDS (MEMORY ONLY + PARSING) ---
     queueCommand: async (projectId, input) => {
         let project = activeProjects.get(projectId);
         
@@ -107,23 +132,20 @@ export const StateManager = {
 
         if (!project) return;
 
-        // --- RESTORED PARSING LOGIC START ---
         let command = null;
 
         if (typeof input === 'object' && input.type && input.payload) {
-            // It's already a formatted command object
             command = input;
         } 
         else if (typeof input === 'string') {
             const rawResponse = input;
             
-            // Filters to prevent loops
+            // Loop Prevention
             if (rawResponse.includes("[ASK_PM:")) return;
             if (rawResponse.includes("[ROUTE_TO_PM:")) return;
-            // Ignore generic image generation triggers if no code is present
             if (rawResponse.includes("[GENERATE_IMAGE:") && !rawResponse.includes("```")) return;
 
-            // REGEX: Extract Lua code, Read Script, Read Hierarchy, Logs
+            // 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*(.*?)\]/);
@@ -134,31 +156,21 @@ export const StateManager = {
             else if (readHierarchyMatch) command = { type: "READ_HIERARCHY", payload: readHierarchyMatch[1].trim() };
             else if (readLogsMatch) command = { type: "READ_LOGS", payload: null };
         }
-        // --- RESTORED PARSING LOGIC END ---
-
+        
         if (command) {
             if (!project.commandQueue) project.commandQueue = [];
             project.commandQueue.push(command);
             console.log(`[Memory] Queued command for ${projectId}: ${command.type}`);
-            
-            // Optional: If you want to persist the queue to Supabase like you did in Firebase, 
-            // you would call updateProject here. But keeping it memory-only is faster.
         }
     },
 
     popCommand: async (projectId) => {
-        // Strictly memory check. If it's not in RAM, it has no commands pending.
         const project = activeProjects.get(projectId);
-        
-        if (!project || !project.commandQueue || project.commandQueue.length === 0) {
-            return null;
-        }
-
-        const command = project.commandQueue.shift();
-        return command;
+        if (!project || !project.commandQueue || project.commandQueue.length === 0) return null;
+        return project.commandQueue.shift();
     },
 
-    // --- METADATA UPDATE (PERSISTENT) ---
+    // --- METADATA UPDATE ---
     updateProject: async (projectId, data) => {
         // 1. Update Memory
         if (activeProjects.has(projectId)) {
@@ -167,8 +179,7 @@ export const StateManager = {
             activeProjects.set(projectId, newData);
         }
 
-        // 2. Prepare DB Payload
-        // IMPORTANT: We explicitly DO NOT include 'commandQueue' here.
+        // 2. Prepare DB Payload (Exclude commandQueue)
         const payload = {
             info: {
                 title: data.title,
@@ -176,69 +187,39 @@ export const StateManager = {
                 stats: data.stats,
                 description: data.description,
                 failureCount: data.failureCount
-                // commandQueue is omitted to keep DB clean
             }
         };
 
         // Clean undefined keys
         Object.keys(payload.info).forEach(key => payload.info[key] === undefined && delete payload.info[key]);
 
-        // 3. Merge Update to DB
-        // Fetch current info to preserve fields we aren't updating right now
         const { data: currentDb } = await supabase.from('projects').select('info').eq('id', projectId).single();
         
         if (currentDb) {
              const mergedInfo = { ...currentDb.info, ...payload.info };
-             // Ensure we sanitize commandQueue out of the DB even if it was there historically
-             delete mergedInfo.commandQueue; 
+             delete mergedInfo.commandQueue; // Sanity check
              
              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()) {
-        // FIX: If lastActive is missing/undefined/0, reset it to NOW.
-        // This prevents the "54 year old project" bug where (now - 0) > 4 hours.
-        if (!data.lastActive) {
-            console.warn(`[StateManager] ⚠️ Project ${id} missing timestamp. Healing data...`);
-            data.lastActive = now;
-            continue; // Skip deleting this round
-        }
-
-        if (now - data.lastActive > FOUR_HOURS) {
-            console.log(`[StateManager] 🧹 Removing expired project: ${id}`);
-            activeProjects.delete(id);
-            count++;
-        }
-    }
-    
-    if (count > 0) {
-        console.log(`[StateManager] 🗑️ Cleaned ${count} projects from memory.`);
-    }
-    return count;
-  },
-
-    /* cleanupMemory: () => {
-        // Optional: Remove projects inactive for > 1 hour
+    cleanupMemory: () => {
         const now = Date.now();
+        const FOUR_HOURS = 4 * 60 * 60 * 1000;
         let count = 0;
-        for (const [id, proj] of activeProjects.entries()) {
-            if (now - proj.lastActive > 
-               // 3600000 // 1 hour
-                18000000 //5 hours
-               ) {
+
+        for (const [id, data] of activeProjects.entries()) {
+            if (!data.lastActive) data.lastActive = now; // Heal missing timestamp
+
+            if (now - data.lastActive > FOUR_HOURS) {
+                console.log(`[StateManager] 🧹 Removing expired project: ${id}`);
                 activeProjects.delete(id);
                 count++;
             }
         }
         return count;
-    }, */
+    },
 
     getSupabaseClient: () => supabase
 };