Update stateManager.js

stateManager.js

@@ -1,10 +1,6 @@
-import admin from 'firebase-admin';
-
-// Initialize Firebase (Assuming it's initialized in server.js, but we need the ref here)
-// We will rely on server.js to initialize the app, or we can lazy-load the db ref.
+// stateManager.js
 let db = null;
 
-// This function allows server.js to pass the initialized DB instance
 export const initDB = (firebaseDB) => {
     db = firebaseDB;
 };
@@ -14,7 +10,8 @@ const activeProjects = new Map();
 export const StateManager = {
   /**
    * GET PROJECT
-   * Strategy: Memory First -> DB Fallback -> Null
+   * Hydrates from DB if not in memory.
+   * Flattens { info, thumbnail, state } into a usable Memory Object.
    */
   getProject: async (projectId) => {
     // 1. Try Memory
@@ -26,19 +23,29 @@ export const StateManager = {
     if (db) {
         try {
             console.log(`[StateManager] 🟡 Hydrating project ${projectId} from DB...`);
+            // We fetch the root because the Server AI needs EVERYTHING (context, history) to function.
+            // If this was a client-side Dashboard, we would only fetch /info.
             const snapshot = await db.ref(`projects/${projectId}`).once('value');
+            
             if (snapshot.exists()) {
-                const projectData = snapshot.val();
+                const dbData = snapshot.val();
                 
-                // Ensure arrays exist (Firebase doesn't store empty arrays)
-                if (!projectData.commandQueue) projectData.commandQueue = [];
-                if (!projectData.workerHistory) projectData.workerHistory = [];
-                if (!projectData.pmHistory) projectData.pmHistory = [];
+                // FLATTEN DB STRUCTURE -> MEMORY STRUCTURE
+                const memoryObject = {
+                    ...dbData.info,             // Title, stats, description
+                    thumbnail: dbData.thumbnail || null,
+                    // State might be undefined if just created, so default it
+                    commandQueue: dbData.state?.commandQueue || [],
+                    workerHistory: dbData.state?.workerHistory || [],
+                    pmHistory: dbData.state?.pmHistory || [],
+                    failureCount: dbData.state?.failureCount || 0,
+                    gdd: dbData.state?.gdd || null
+                };
                 
                 // Load into Memory
-                activeProjects.set(projectId, projectData);
+                activeProjects.set(projectId, memoryObject);
                 console.log(`[StateManager] 🟢 Project ${projectId} hydrated.`);
-                return projectData;
+                return memoryObject;
             }
         } catch (err) {
             console.error(`[StateManager] Error reading DB for ${projectId}:`, err);
@@ -50,122 +57,113 @@ export const StateManager = {
 
   /**
    * UPDATE PROJECT
-   * Strategy: Update Memory -> Async Write to DB
+   * Updates Memory immediately.
+   * Performs granular updates to DB (separating Info vs State).
    */
   updateProject: async (projectId, data) => {
-    // We get the current state from memory (or hydrate it if missing, though usually called after get)
     let current = activeProjects.get(projectId);
     
-    // If it wasn't in memory, try to get it first to avoid overwriting with partial data
+    // Safety check: ensure we have base state
     if (!current) {
         current = await StateManager.getProject(projectId) || { 
-            commandQueue: [], 
-            workerHistory: [],
-            pmHistory: [],
-            failureCount: 0 
+            commandQueue: [], workerHistory: [], pmHistory: [], failureCount: 0 
         };
     }
 
     const timestamp = Date.now();
     
-    // Merge Data
+    // 1. Update Memory (Flat Merge)
     const newData = { 
         ...current, 
         ...data, 
-        lastUpdated: timestamp, // UCT timestamp for sync
+        lastUpdated: timestamp, 
         lastActive: timestamp 
     };
-
-    // 1. Write to Memory
     activeProjects.set(projectId, newData);
 
-    // 2. Write to Firebase (Fire and Forget)
+    // 2. Update Firebase (Nested Split)
     if (db) {
-        db.ref(`projects/${projectId}`).update(data).catch(err => {
-            console.error(`[StateManager] 🔴 DB Write Failed for ${projectId}:`, err);
-        });
+        const updates = {};
+        
+        // We assume 'data' contains the specific fields that changed.
+        // However, to be safe and robust, we map the current state to the correct buckets.
+        
+        // Bucket: Info
+        if (data.status || data.stats || data.title) {
+             updates[`projects/${projectId}/info/status`] = newData.status;
+             if (newData.lastUpdated) updates[`projects/${projectId}/info/lastUpdated`] = newData.lastUpdated;
+             // Add other info fields if they are mutable
+        }
+
+        // Bucket: State (History, Queue, GDD) - This is the most frequent update
+        if (data.workerHistory || data.pmHistory || data.commandQueue || data.failureCount || data.gdd) {
+            updates[`projects/${projectId}/state/workerHistory`] = newData.workerHistory;
+            updates[`projects/${projectId}/state/pmHistory`] = newData.pmHistory;
+            updates[`projects/${projectId}/state/commandQueue`] = newData.commandQueue;
+            updates[`projects/${projectId}/state/failureCount`] = newData.failureCount;
+            if (newData.gdd) updates[`projects/${projectId}/state/gdd`] = newData.gdd;
+        }
+
+        // Bucket: Thumbnail (Only update if explicitly passed in 'data', avoiding re-upload of massive string)
+        if (data.thumbnail) {
+            updates[`projects/${projectId}/thumbnail`] = data.thumbnail;
+        }
+
+        // Perform the update
+        if (Object.keys(updates).length > 0) {
+            db.ref().update(updates).catch(err => {
+                console.error(`[StateManager] 🔴 DB Write Failed for ${projectId}:`, err);
+            });
+        }
     }
 
     return newData;
   },
 
-  /**
-   * QUEUE COMMAND
-   * Parses input, updates command list in Memory & DB
-   */
   queueCommand: async (projectId, input) => {
-    // Ensure project is loaded
     const project = await StateManager.getProject(projectId);
     if (!project) return;
     
     let command = null;
 
-    // A. HANDLE PRE-FORMED OBJECTS
     if (typeof input === 'object' && input.type && input.payload) {
         command = input;
     } 
-    // B. HANDLE RAW TEXT RESPONSE
     else if (typeof input === 'string') {
         const rawResponse = input;
-
-        if (rawResponse.includes("[ASK_PM:")) {
-            console.log(`[${projectId}] Skipped Plugin Queue (Internal PM Consultation)`);
-            return; 
-        }
-
-        if (rawResponse.includes("[GENERATE_IMAGE:") && !rawResponse.includes("```")) {
-             return;
-        }
+        if (rawResponse.includes("[ASK_PM:")) return;
+        if (rawResponse.includes("[GENERATE_IMAGE:") && !rawResponse.includes("```")) return;
 
         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 (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) {
       project.commandQueue.push(command);
       console.log(`[${projectId}] Queued Action: ${command.type}`);
-      
-      // Persist the updated queue to both
+      // Sync queue to DB
       await StateManager.updateProject(projectId, { commandQueue: project.commandQueue });
-    } else {
-        if (typeof input === 'string' && input.length < 500) {
-             console.log(`[${projectId}] Chatter (No Command):`, input);
-        }
     }
   },
   
-  /**
-   * POP COMMAND
-   * Removes from Memory & DB
-   */
   popCommand: async (projectId) => {
     const project = await StateManager.getProject(projectId);
     if (!project || !project.commandQueue.length) return null;
     
     const command = project.commandQueue.shift();
-    
-    // Sync the removal to DB
+    // Sync queue to DB
     await StateManager.updateProject(projectId, { commandQueue: project.commandQueue });
     
     return command;
   },
 
-  /**
-   * CLEANUP
-   * Removes projects from Memory if inactive for > 4 hours
-   */
   cleanupMemory: () => {
     const now = Date.now();
     const FOUR_HOURS = 4 * 60 * 60 * 1000;