Update stateManager.js

stateManager.js

@@ -1,186 +1,111 @@
 import { createClient } from '@supabase/supabase-js';
 
-// --- SUPABASE SETUP ---
 let supabase = null;
+const activeProjects = new Map();
 
 export const initDB = () => {
-    if (process.env.SUPABASE_URL && process.env.SUPABASE_SERVICE_ROLE_KEY) {
-        supabase = createClient(
-            process.env.SUPABASE_URL,
-            process.env.SUPABASE_SERVICE_ROLE_KEY
-        );
-        console.log("⚡ Supabase Client Initialized");
-    } else {
-        console.warn("⚠️ Supabase Credentials Missing - Memory Mode Only");
-    }
+    supabase = createClient(process.env.SUPABASE_URL, process.env.SUPABASE_SERVICE_ROLE_KEY);
 };
 
-const activeProjects = new Map();
-
 export const StateManager = {
-  getProject: async (projectId) => {
-    // 1. Try Memory
-    if (activeProjects.has(projectId)) {
-        return activeProjects.get(projectId);
-    }
-
-    // 2. Try Supabase
-    if (supabase) {
-        try {
-            const { data, error } = await supabase
-                .from('projects')
-                .select('*')
-                .eq('id', projectId)
-                .single();
-            
-            if (data) {
-                // Flatten DB structure (info + state) to Memory Object
-                const memoryObject = {
-                    ...data.info,           // Title, stats, description, status
-                    ...data.state,          // workerHistory, pmHistory, queue
-                    id: data.id,
-                    userId: data.user_id,
-                    thumbnail: data.thumbnail,
-                    lastActive: Date.now(),
-                    lastUpdated: Date.now()
-                };
-
-                // Ensure arrays exist
-                if (!memoryObject.commandQueue) memoryObject.commandQueue = [];
-                if (!memoryObject.workerHistory) memoryObject.workerHistory = [];
-                if (!memoryObject.pmHistory) memoryObject.pmHistory = [];
-                if (!memoryObject.failureCount) memoryObject.failureCount = 0;
-
-                activeProjects.set(projectId, memoryObject);
-                return memoryObject;
-            }
-        } catch (err) {
-            console.error(`[StateManager] Error reading DB for ${projectId}:`, err);
-        }
-    }
-
-    return null; 
-  },
-
-  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 
-        };
-    }
-    
-    // 1. Update Memory (Flat Merge)
-    const newData = { 
-        ...current, 
-        ...data, 
-        lastActive: Date.now(), 
-        lastUpdated: Date.now()
-    };
-    activeProjects.set(projectId, newData);
-
-    // 2. Update Supabase
-    if (supabase) {
-        // We separate data into columns: 'info' and 'state'
-        const infoUpdate = {
-            title: newData.title,
-            stats: newData.stats,
-            description: newData.description,
-            status: newData.status,
-            lastUpdated: newData.lastUpdated
-        };
-
-        const stateUpdate = {
-            workerHistory: newData.workerHistory,
-            pmHistory: newData.pmHistory,
-            commandQueue: newData.commandQueue,
-            failureCount: newData.failureCount,
-            gdd: newData.gdd
-        };
-
-        const updatePayload = {
-            info: infoUpdate,
-            state: stateUpdate,
-        };
-
-        if (data.thumbnail) updatePayload.thumbnail = data.thumbnail;
-
-        await supabase
-            .from('projects')
-            .update(updatePayload)
-            .eq('id', projectId);
-    }
-
-    return newData;
-  },
-
-  queueCommand: async (projectId, input) => {
-    const project = await StateManager.getProject(projectId);
-    if (!project) return;
-    
-    let command = null;
-
-    if (typeof input === 'object' && input.type && input.payload) {
-        command = input;
-    } 
-    else if (typeof input === 'string') {
-        const rawResponse = input;
+    getProject: async (projectId) => {
+        if (activeProjects.has(projectId)) return activeProjects.get(projectId);
         
-        // Filters
-        if (rawResponse.includes("[ASK_PM:")) return;
-        if (rawResponse.includes("[ROUTE_TO_PM:")) return;
-        if (rawResponse.includes("[GENERATE_IMAGE:") && !rawResponse.includes("```")) return;
+        const { data: proj } = await supabase.from('projects').select('*').eq('id', projectId).single();
+        if (!proj) return null;
+
+        // Fetch the 2 most recent chunks (up to 40 messages) for AI context
+        const { data: chunks } = await supabase.from('message_chunks')
+            .select('*').eq('project_id', projectId)
+            .order('chunk_index', { ascending: false }).limit(2);
+
+        const memoryObject = {
+            ...proj.info,
+            id: proj.id,
+            userId: proj.user_id,
+            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: proj.info.commandQueue || [],
+            failureCount: proj.info.failureCount || 0,
+            lastActive: Date.now()
+        };
 
-        // Extractors
-        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]");
+        activeProjects.set(projectId, memoryObject);
+        return memoryObject;
+    },
 
-        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 };
-    }
+    // CUSTOM CHUNK LOGIC: Appends message to chunked entry (max 20 per entry)
+    addHistory: async (projectId, type, role, text) => {
+        const newMessage = { role, parts: [{ text }] };
         
-    if (command) {
-      project.commandQueue.push(command);
-      console.log(`[${projectId}] Queued Action: ${command.type}`);
-      await StateManager.updateProject(projectId, { commandQueue: project.commandQueue });
-    }
-  },
-  
-  popCommand: async (projectId) => {
-    const project = await StateManager.getProject(projectId);
-    if (!project || !project.commandQueue.length) return null;
-    
-    const command = project.commandQueue.shift();
-    await StateManager.updateProject(projectId, { commandQueue: project.commandQueue });
-    
-    return command;
-  },
-
-  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;
-            continue; 
+        // Find latest chunk for this type
+        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.length < 20) {
+            // Append to existing chunk
+            const updatedPayload = [...latest.payload, newMessage];
+            await supabase.from('message_chunks').update({ payload: updatedPayload }).eq('id', latest.id);
+        } else {
+            // Create new chunk
+            const nextIndex = latest ? latest.chunk_index + 1 : 0;
+            await supabase.from('message_chunks').insert({
+                project_id: projectId,
+                type,
+                chunk_index: nextIndex,
+                payload: [newMessage]
+            });
         }
-
-        if (now - data.lastActive > FOUR_HOURS) {
-            activeProjects.delete(id);
-            count++;
+    },
+
+    updateProject: async (projectId, data) => {
+        const current = activeProjects.get(projectId) || {};
+        const newData = { ...current, ...data, lastActive: Date.now() };
+        activeProjects.set(projectId, newData);
+
+        const payload = {
+            info: {
+                title: newData.title,
+                status: newData.status,
+                stats: newData.stats,
+                description: newData.description,
+                commandQueue: newData.commandQueue,
+                failureCount: newData.failureCount
+            }
+        };
+        await supabase.from('projects').update(payload).eq('id', projectId);
+        return newData;
+    },
+
+    queueCommand: async (projectId, input) => {
+        const project = await StateManager.getProject(projectId);
+        if (!project) return;
+        let command = typeof input === 'object' ? input : null;
+        if (typeof input === 'string') {
+            const code = input.match(/```(?:lua|luau)?([\s\S]*?)```/i);
+            const script = input.match(/\[READ_SCRIPT:\s*(.*?)\]/);
+            const hier = input.match(/\[READ_HIERARCHY:\s*(.*?)\]/);
+            if (code) command = { type: "EXECUTE", payload: code[1].trim() };
+            else if (script) command = { type: "READ_SCRIPT", payload: script[1].trim() };
+            else if (hier) command = { type: "READ_HIERARCHY", payload: hier[1].trim() };
+            else if (input.includes("[READ_LOGS]")) command = { type: "READ_LOGS", payload: null };
+        }
+        if (command) {
+            project.commandQueue.push(command);
+            await StateManager.updateProject(projectId, { commandQueue: project.commandQueue });
         }
-    }
-    return count;
-  },
+    },
+
+    popCommand: async (projectId) => {
+        const project = await StateManager.getProject(projectId);
+        if (!project || !project.commandQueue?.length) return null;
+        const cmd = project.commandQueue.shift();
+        await StateManager.updateProject(projectId, { commandQueue: project.commandQueue });
+        return cmd;
+    },
 
-  // Exporting raw client for credits check in App.js
-  getSupabaseClient: () => supabase
+    getSupabaseClient: () => supabase
 };