Update stateManager.js

stateManager.js

@@ -1,5 +1,4 @@
-import admin from 'firebase-admin';
-
+// stateManager.js
 let db = null;
 
 export const initDB = (firebaseDB) => {
@@ -7,67 +6,50 @@ export const initDB = (firebaseDB) => {
 };
 
 const activeProjects = new Map();
-// New: Prevents multiple requests from triggering DB fetches for the same ID simultaneously
-const hydrationPromises = new Map(); 
 
 export const StateManager = {
   /**
    * GET PROJECT
-   * Fixes: Concurrency handling & String normalization
+   * Hydrates from DB if not in memory.
+   * Flattens { info, thumbnail, state } into a usable Memory Object.
    */
-  getProject: async (rawId) => {
-    const projectId = String(rawId).trim(); // Force string
-
+  getProject: async (projectId) => {
     // 1. Try Memory
     if (activeProjects.has(projectId)) {
-        const project = activeProjects.get(projectId);
-        // Update activity timestamp on read so it doesn't get cleaned up while active
-        project.lastActive = Date.now(); 
-        return project;
+        return activeProjects.get(projectId);
     }
 
-    // 2. Check if already hydrating (Race Condition Fix)
-    if (hydrationPromises.has(projectId)) {
-        return hydrationPromises.get(projectId);
-    }
-
-    // 3. Try Firebase (Hydration)
+    // 2. Try Firebase (Hydration)
     if (db) {
-        const hydrationTask = (async () => {
-            try {
-                console.log(`[StateManager] 🟡 Hydrating project ${projectId} from DB...`);
-                const snapshot = await db.ref(`projects/${projectId}`).once('value');
+        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 dbData = snapshot.val();
+                
+                // 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
+                };
                 
-                if (snapshot.exists()) {
-                    const dbData = snapshot.val();
-                    
-                    // Flatten DB structure for Memory usage
-                    const memoryObject = {
-                        ...dbData.info, 
-                        thumbnail: null, // dbData.thumbnail || null,
-                        commandQueue: dbData.state?.commandQueue || [],
-                        workerHistory: dbData.state?.workerHistory || [],
-                        pmHistory: dbData.state?.pmHistory || [],
-                        failureCount: dbData.state?.failureCount || 0,
-                        gdd: dbData.state?.gdd || null,
-                        lastActive: Date.now(), // Set initial active time
-                        lastUpdated: dbData.info?.lastUpdated || Date.now()
-                    };
-                    
-                    activeProjects.set(projectId, memoryObject);
-                    console.log(`[StateManager] 🟢 Project ${projectId} hydrated.`);
-                    return memoryObject;
-                }
-            } catch (err) {
-                console.error(`[StateManager] Error reading DB for ${projectId}:`, err);
-            } finally {
-                hydrationPromises.delete(projectId); // Clear lock
+                // Load into Memory
+                activeProjects.set(projectId, memoryObject);
+                console.log(`[StateManager] 🟢 Project ${projectId} hydrated.`);
+                return memoryObject;
             }
-            return null;
-        })();
-
-        hydrationPromises.set(projectId, hydrationTask);
-        return hydrationTask;
+        } catch (err) {
+            console.error(`[StateManager] Error reading DB for ${projectId}:`, err);
+        }
     }
 
     return null; 
@@ -75,11 +57,13 @@ export const StateManager = {
 
   /**
    * UPDATE PROJECT
+   * Updates Memory immediately.
+   * Performs granular updates to DB (separating Info vs State).
    */
-  updateProject: async (rawId, data) => {
-    const projectId = String(rawId).trim();
+  updateProject: async (projectId, data) => {
     let current = activeProjects.get(projectId);
     
+    // Safety check: ensure we have base state
     if (!current) {
         current = await StateManager.getProject(projectId) || { 
             commandQueue: [], workerHistory: [], pmHistory: [], failureCount: 0 
@@ -88,7 +72,7 @@ export const StateManager = {
 
     const timestamp = Date.now();
     
-    // 1. Update Memory
+    // 1. Update Memory (Flat Merge)
     const newData = { 
         ...current, 
         ...data, 
@@ -97,17 +81,21 @@ export const StateManager = {
     };
     activeProjects.set(projectId, newData);
 
-    // 2. Update Firebase
+    // 2. Update Firebase (Nested Split)
     if (db) {
         const updates = {};
         
-        // Info Bucket
+        // 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;
-             updates[`projects/${projectId}/info/lastUpdated`] = timestamp;
+             if (newData.lastUpdated) updates[`projects/${projectId}/info/lastUpdated`] = newData.lastUpdated;
+             // Add other info fields if they are mutable
         }
 
-        // State Bucket (Most frequent)
+        // 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;
@@ -116,22 +104,23 @@ export const StateManager = {
             if (newData.gdd) updates[`projects/${projectId}/state/gdd`] = newData.gdd;
         }
 
-        // Thumbnail Bucket
+        // Bucket: Thumbnail (Only update if explicitly passed in 'data', avoiding re-upload of massive string)
         if (data.thumbnail) {
             updates[`projects/${projectId}/thumbnail`] = data.thumbnail.url;
         }
 
+        // Perform the update
         if (Object.keys(updates).length > 0) {
-            // No await here - let it write in background to not block the AI
-            db.ref().update(updates).catch(err => console.error(`[DB Write Error]`, err));
+            db.ref().update(updates).catch(err => {
+                console.error(`[StateManager] 🔴 DB Write Failed for ${projectId}:`, err);
+            });
         }
     }
 
     return newData;
   },
 
-  queueCommand: async (rawId, input) => {
-    const projectId = String(rawId).trim();
+  queueCommand: async (projectId, input) => {
     const project = await StateManager.getProject(projectId);
     if (!project) return;
     
@@ -142,7 +131,6 @@ export const StateManager = {
     } 
     else if (typeof input === 'string') {
         const rawResponse = input;
-        // Logic filters
         if (rawResponse.includes("[ASK_PM:")) return;
         if (rawResponse.includes("[GENERATE_IMAGE:") && !rawResponse.includes("```")) return;
 
@@ -160,18 +148,17 @@ export const StateManager = {
     if (command) {
       project.commandQueue.push(command);
       console.log(`[${projectId}] Queued Action: ${command.type}`);
+      // Sync queue to DB
       await StateManager.updateProject(projectId, { commandQueue: project.commandQueue });
     }
   },
   
-  popCommand: async (rawId) => {
-    const projectId = String(rawId).trim();
-    // This call ensures hydration AND updates lastActive
+  popCommand: async (projectId) => {
     const project = await StateManager.getProject(projectId);
-    
     if (!project || !project.commandQueue.length) return null;
     
     const command = project.commandQueue.shift();
+    // Sync queue to DB
     await StateManager.updateProject(projectId, { commandQueue: project.commandQueue });
     
     return command;
@@ -183,7 +170,6 @@ export const StateManager = {
     let count = 0;
 
     for (const [id, data] of activeProjects.entries()) {
-        // Only clean if it hasn't been active in 4 hours
         if (now - (data.lastActive || 0) > FOUR_HOURS) {
             activeProjects.delete(id);
             count++;