Update app.js

app.js

@@ -21,6 +21,417 @@ app.use(bodyParser.json({ limit: '50mb' }));
 const MIN_BASIC_REQUIRED = 50; 
 const MIN_DIAMOND_REQUIRED = 50; 
 
+// --- STATUS PHASES ---
+const WORKER_PHASES = [
+    "Worker: Sorting...",
+    "Worker: Analyzing Request...",
+    "Worker: Reading Context...",
+    "Worker: Checking Hierarchy...",
+    "Worker: Planning Logic...",
+    "Worker: Preparing Environment...",
+    "Worker: Thinking..." 
+];
+
+const PM_PHASES = [
+    "Manager: Sorting...",
+    "Manager: Reviewing Request...",
+    "Manager: Analyzing Project Structure...",
+    "Manager: Consulting Guidelines...",
+    "Manager: Formulating Strategy...",
+    "Manager: Delegating Tasks...",
+    "Manager: Thinking..." 
+];
+
+function startStatusLoop(projectId, type = 'worker') {
+    const phases = type === 'pm' ? PM_PHASES : WORKER_PHASES;
+    let index = 0;
+    
+    StateManager.setStatus(projectId, phases[0]);
+
+    const interval = setInterval(() => {
+        index++;
+        if (index < phases.length) {
+            StateManager.setStatus(projectId, phases[index]);
+        } else {
+            clearInterval(interval);
+        }
+    }, 3500); 
+
+    return () => clearInterval(interval);
+}
+
+async function checkMinimumCredits(userId, type = 'basic') {
+    if (!supabase) return; 
+
+    const { data, error } = await supabase
+        .from('users')
+        .select('credits')
+        .eq('id', userId)
+        .single();
+    
+    if (error || !data) return; 
+
+    const credits = data.credits?.[type] || 0;
+    const required = type === 'diamond' ? MIN_DIAMOND_REQUIRED : MIN_BASIC_REQUIRED;
+
+    if (credits < required) {
+        throw new Error(`Insufficient ${type} credits. You have ${credits}, need minimum ${required}.`);
+    }
+}
+
+async function deductUserCredits(userId, amount, type = 'basic') {
+    if (!supabase || !amount || amount <= 0) return;
+    
+    try {
+        const { data } = await supabase.from('users').select('credits').eq('id', userId).single();
+        if (!data) return;
+
+        const currentCredits = data.credits || {};
+        const currentVal = currentCredits[type] || 0;
+        const newVal = Math.max(0, currentVal - amount);
+        
+        const updatedCredits = { ...currentCredits, [type]: newVal };
+
+        await supabase
+            .from('users')
+            .update({ credits: updatedCredits })
+            .eq('id', userId);
+
+        console.log(`[Credits] Deducted ${amount} ${type} from User ${userId}. Remaining: ${newVal}`);
+    } catch (err) {
+        console.error(`[Credits] Failed to deduct from ${userId}:`, err);
+    }
+}
+
+const validateRequest = (req, res, next) => {
+    if (req.path.includes('/admin/cleanup')) return next();
+    const { userId } = req.body;
+    if (!userId && (req.path.includes('/onboarding') || req.path.includes('/new') || req.path.includes('/project'))) {
+        return res.status(400).json({ error: "Missing userId" });
+    }
+    next();
+};
+
+function extractWorkerPrompt(text) {
+    if (!text || typeof text !== 'string') return null;
+    const match = text.match(/WORKER_PROMPT:\s*(.*)/s);
+    return match ? match[1].trim() : null;
+}
+
+function extractPMQuestion(text) {
+    if (!text || typeof text !== 'string') return null;
+    const match = text.match(/\[ASK_PM:\s*(.*?)\]/s); 
+    return match ? match[1].trim() : null;
+}
+
+function extractImagePrompt(text) {
+    if (!text || typeof text !== 'string') return null;
+    const match = text.match(/\[GENERATE_IMAGE:\s*(.*?)\]/s);
+    return match ? match[1].trim() : null;
+}
+
+function extractRouteToPM(text) {
+    if (!text || typeof text !== 'string') return null;
+    const match = text.match(/\[ROUTE_TO_PM:\s*(.*?)\]/s);
+    return match ? match[1].trim() : null;
+}
+
+function formatContext({ hierarchyContext, scriptContext, logContext }) {
+    let out = "";
+    if (scriptContext) out += `\n[TARGET SCRIPT]: ${scriptContext.targetName}\n[SOURCE PREVIEW]: ${scriptContext.scriptSource}`;
+    if (logContext) out += `\n[LAST LOGS]: ${logContext.logs}`;
+    if (hierarchyContext) out += `\n[Hierarchy Context]: ${hierarchyContext}`;
+    return out;
+}
+
+async function runBackgroundInitialization(projectId, userId, description) {
+    if (StateManager.isLocked(projectId)) return;
+    StateManager.lock(projectId);
+    
+    let diamondUsage = 0; 
+    let basicUsage = 0;   
+
+    try {
+        await StateManager.getProject(projectId);
+        await StateManager.updateProject(projectId, { status: "working", failureCount: 0 });
+
+        const pmHistory = [];
+        let stopStatus = startStatusLoop(projectId, 'pm');
+        
+        const gddPrompt = `Create a comprehensive Game Design Document (GDD) for: ${description}`;
+        const gddResult = await AIEngine.callPM(pmHistory, gddPrompt);
+        stopStatus();
+        
+        if (!gddResult?.text) throw new Error("PM failed to generate GDD");
+        diamondUsage += (gddResult.usage?.totalTokenCount || 0);
+
+        await StateManager.addHistory(projectId, 'pm', 'user', gddPrompt);
+        await StateManager.addHistory(projectId, 'pm', 'model', gddResult.text);
+
+        pmHistory.push({ role: 'user', parts: [{ text: gddPrompt }] });
+        pmHistory.push({ role: 'model', parts: [{ text: gddResult.text }] });
+
+        stopStatus = startStatusLoop(projectId, 'pm');
+        const taskPrompt = "Based on the GDD, generate the first technical milestone.\nOutput format:\nTASK_NAME: <Name>\nWORKER_PROMPT: <Specific, isolated instructions for the worker>";
+        const taskResult = await AIEngine.callPM(pmHistory, taskPrompt);
+        stopStatus();
+
+        if (!taskResult?.text) throw new Error("PM failed to generate Task");
+        diamondUsage += (taskResult.usage?.totalTokenCount || 0);
+
+        await StateManager.addHistory(projectId, 'pm', 'user', taskPrompt);
+        await StateManager.addHistory(projectId, 'pm', 'model', taskResult.text);
+
+        const initialWorkerInstruction = extractWorkerPrompt(taskResult.text) || `Initialize structure for: ${description}`;
+        const initialWorkerPrompt = `CONTEXT: New Project. \nINSTRUCTION: ${initialWorkerInstruction}`;
+        
+        stopStatus = startStatusLoop(projectId, 'worker');
+        const workerResult = await AIEngine.callWorkerStream(
+            [], 
+            initialWorkerPrompt, 
+            (thought) => { StateManager.appendSnapshotOnly(projectId, thought); },
+            (chunk) => { StateManager.appendStream(projectId, chunk); }
+        );
+        stopStatus();
+
+        if (!workerResult?.text) throw new Error("Worker failed to initialize");
+        basicUsage += (workerResult.usage?.totalTokenCount || 0);
+
+        await StateManager.addHistory(projectId, 'worker', 'user', initialWorkerPrompt);
+        await StateManager.addHistory(projectId, 'worker', 'model', workerResult.text);
+
+        await StateManager.updateProject(projectId, { gdd: gddResult.text, status: "idle" });
+        await processAndQueueResponse(projectId, workerResult.text, userId); 
+        
+    } catch (err) {
+        console.error(`[Background] Init Error:`, err.message);
+        await StateManager.updateProject(projectId, { status: "error" });
+    } finally {
+        if (diamondUsage > 0) await deductUserCredits(userId, diamondUsage, 'diamond');
+        if (basicUsage > 0) await deductUserCredits(userId, basicUsage, 'basic');
+        StateManager.unlock(projectId);
+    }
+}
+
+async function runAsyncFeedback(projectId, userId, fullInput, images = []) {
+    let diamondUsage = 0;
+    let basicUsage = 0;
+
+    try {
+        // 1. Persistence First
+        await Promise.all([
+            StateManager.updateProject(projectId, { status: "working" }),
+            StateManager.addHistory(projectId, 'worker', 'user', fullInput)
+        ]);
+
+        const project = await StateManager.getProject(projectId);
+        StateManager.clearSnapshot(projectId);
+        let stopStatus = startStatusLoop(projectId, 'worker');
+        
+        const currentWorkerHistory = [...(project.workerHistory || [])];
+
+        // 2. Worker Turn 1
+        const firstTurn = await AIEngine.callWorkerStream(
+            currentWorkerHistory, 
+            fullInput, 
+            (thought) => { 
+                stopStatus();
+                StateManager.setStatus(projectId, "Worker: Thinking..."); 
+                StateManager.appendSnapshotOnly(projectId, thought); 
+            },
+            (chunk) => { 
+                stopStatus();
+                StateManager.setStatus(projectId, "Worker: Coding..."); 
+                StateManager.appendStream(projectId, chunk); 
+            },
+            images 
+        );
+        basicUsage += (firstTurn.usage?.totalTokenCount || 0);
+
+        const routeTask = extractRouteToPM(firstTurn.text);
+        const pmQuestion = extractPMQuestion(firstTurn.text);
+
+        let finalResponseToExecute = firstTurn.text;
+
+        if (routeTask || pmQuestion) {
+            await StateManager.addHistory(projectId, 'worker', 'model', firstTurn.text);
+            currentWorkerHistory.push({ role: 'model', parts: [{ text: firstTurn.text }] });
+
+            let pmPrompt = routeTask ? 
+                `[ROUTED TASK]: ${routeTask}\nWrite the backend/logic. Then use WORKER_PROMPT: <task> to delegate.` :
+                `[WORKER QUESTION]: ${pmQuestion}\nProvide a technical answer or code snippet.`;
+
+            // 3. PM Turn
+            StateManager.clearSnapshot(projectId); 
+            stopStatus = startStatusLoop(projectId, 'pm');
+            const pmResult = await AIEngine.callPMStream(
+                project.pmHistory,
+                pmPrompt,
+                (thought) => { 
+                    stopStatus();
+                    StateManager.setStatus(projectId, "Manager: Thinking..."); 
+                    StateManager.appendSnapshotOnly(projectId, thought); 
+                },
+                (chunk) => { 
+                    stopStatus();
+                    StateManager.setStatus(projectId, "Manager: Architecture..."); 
+                    StateManager.appendSnapshotOnly(projectId, chunk); 
+                }
+            );
+            diamondUsage += (pmResult.usage?.totalTokenCount || 0);
+            
+            await StateManager.addHistory(projectId, 'pm', 'user', pmPrompt);
+            await StateManager.addHistory(projectId, 'pm', 'model', pmResult.text);
+
+            // Execute PM Code
+            await processAndQueueResponse(projectId, pmResult.text, userId);
+
+            // 4. Worker Turn 2 (Continuation)
+            const nextInstruction = extractWorkerPrompt(pmResult.text) || pmResult.text;
+            const workerContPrompt = `[PM RESPONSE]: ${nextInstruction}\n\nBased on this, finalize the task.`;
+
+            await StateManager.addHistory(projectId, 'worker', 'user', workerContPrompt);
+            currentWorkerHistory.push({ role: 'user', parts: [{ text: workerContPrompt }] });
+
+            StateManager.clearSnapshot(projectId);
+            stopStatus = startStatusLoop(projectId, 'worker');
+            const secondTurn = await AIEngine.callWorkerStream(
+                currentWorkerHistory, 
+                workerContPrompt,
+                (thought) => { 
+                    stopStatus();
+                    StateManager.setStatus(projectId, "Worker: Applying..."); 
+                    StateManager.appendSnapshotOnly(projectId, thought); 
+                },
+                (chunk) => { 
+                    stopStatus();
+                    StateManager.setStatus(projectId, "Worker: Finalizing..."); 
+                    StateManager.appendStream(projectId, chunk); 
+                }
+            );
+            basicUsage += (secondTurn.usage?.totalTokenCount || 0);
+
+            await StateManager.addHistory(projectId, 'worker', 'model', secondTurn.text);
+            finalResponseToExecute = secondTurn.text;
+        } else {
+            await StateManager.addHistory(projectId, 'worker', 'model', firstTurn.text);
+        }
+
+        await processAndQueueResponse(projectId, finalResponseToExecute, userId);
+        await StateManager.updateProject(projectId, { status: "idle" });
+
+    } catch (err) {
+        console.error("Async Feedback Error:", err);
+        StateManager.setStatus(projectId, "Error: " + err.message);
+        await StateManager.updateProject(projectId, { status: "error" });
+    } finally {
+        // --- ONLY DEDUCT HERE ---
+        if (diamondUsage > 0) await deductUserCredits(userId, diamondUsage, 'diamond');
+        if (basicUsage > 0) await deductUserCredits(userId, basicUsage, 'basic');
+    }
+}
+
+async function processAndQueueResponse(projectId, rawResponse, userId) {
+    if (!rawResponse) return;
+    const imgPrompt = extractImagePrompt(rawResponse);
+    if (imgPrompt) {
+        const imgResult = await AIEngine.generateImage(imgPrompt);
+        if (imgResult?.image) {
+            await deductUserCredits(userId, 1000, 'basic');
+            await StateManager.queueCommand(projectId, { type: "CREATE_ASSET", payload: imgResult.image });
+        }
+    }
+    await StateManager.queueCommand(projectId, { type: "EXECUTE", payload: rawResponse });
+}
+
+app.post('/onboarding/analyze', validateRequest, async (req, res) => {
+    const { description, userId } = req.body;
+    try {
+        await checkMinimumCredits(userId, 'basic');
+        const result = await AIEngine.generateEntryQuestions(description);
+        
+        if (result.usage?.totalTokenCount > 0) {
+            await deductUserCredits(userId, result.usage.totalTokenCount, 'basic');
+        }
+
+        if (result.status === "REJECTED") return res.json({ rejected: true, reason: result.reason });
+        res.json({ questions: result.questions });
+    } catch (err) { res.status(500).json({ error: err.message }); }
+});
+
+app.post('/onboarding/create', validateRequest, async (req, res) => {
+    const { userId, description, answers } = req.body;
+    try {
+        await checkMinimumCredits(userId, 'basic');
+        await checkMinimumCredits(userId, 'diamond'); 
+
+        const projectId = `proj_${Date.now()}_${crypto.randomBytes(4).toString('hex')}`;
+        const gradingResult = await AIEngine.gradeProject(description, answers);
+        
+        if (gradingResult.usage?.totalTokenCount > 0) {
+            await deductUserCredits(userId, gradingResult.usage.totalTokenCount, 'basic');
+        }
+
+        if (gradingResult.feasibility >= 30 && gradingResult.rating !== 'F') {
+            await supabase.from('projects').insert({
+                id: projectId, user_id: userId,
+                info: { title: gradingResult.title || "Untitled", stats: gradingResult, description, answers, status: "initializing" }
+            });
+            runBackgroundInitialization(projectId, userId, description);
+        }
+        res.json({ status: 200, success: true, projectId, stats: gradingResult });
+    } catch (err) { res.status(500).json({ error: err.message }); }
+});
+
+app.post('/project/feedback', async (req, res) => {
+    const { userId, projectId, prompt, hierarchyContext, scriptContext, logContext, images } = req.body;
+    try {
+        const project = await StateManager.getProject(projectId);
+        if (!project || project.userId !== userId) return res.status(403).json({ error: "Auth Error" });
+        await checkMinimumCredits(userId, 'basic');
+        const context = formatContext({ hierarchyContext, scriptContext, logContext });
+        runAsyncFeedback(projectId, userId, `USER: ${prompt || "Automatic Feedback"}${context}`, images || []);
+        res.json({ success: true });
+    } catch (err) { res.status(500).json({ error: err.message }); }
+});
+
+app.post('/project/ping', async (req, res) => {
+    const { projectId, userId, isFrontend } = req.body;
+    const project = await StateManager.getProject(projectId);
+    if (!project || project.userId !== userId) return res.json({ action: "IDLE" });
+    if (isFrontend) return res.json({ status: StateManager.getStatus(projectId), snapshot: StateManager.getSnapshot(projectId) });
+    const command = await StateManager.popCommand(projectId);
+    const streamData = StateManager.popStream(projectId);
+    res.json({ action: streamData ? "STREAM_APPEND" : (command?.type || "IDLE"), stream: streamData, target: command?.payload, code: command?.type === 'EXECUTE' ? command.payload : null });
+});
+
+app.get('/admin/cleanup', async (req, res) => { res.json({ success: true, removedCount: StateManager.cleanupMemory() }); });
+
+app.listen(PORT, () => console.log(`AI Backend Running on ${PORT}`));
+
+/* import express from 'express';
+import bodyParser from 'body-parser';
+import cors from 'cors';
+import { StateManager, initDB } from './stateManager.js'; 
+import { AIEngine } from './aiEngine.js';
+import fs from 'fs';
+import crypto from "crypto";
+import dotenv from 'dotenv';
+
+dotenv.config();
+
+initDB();
+const supabase = StateManager.getSupabaseClient(); 
+
+const app = express();
+const PORT = process.env.PORT || 7860;
+
+app.use(cors());
+app.use(bodyParser.json({ limit: '50mb' }));
+
+const MIN_BASIC_REQUIRED = 50; 
+const MIN_DIAMOND_REQUIRED = 50; 
+
 // --- STATUS PHASES ---
 const WORKER_PHASES = [
   "Worker: Sorting...",
@@ -455,9 +866,9 @@ app.post('/onboarding/analyze', validateRequest, async (req, res) => {
       if (result.usage?.totalTokenCount > 0) {
     await deductUserCredits(userId, result.usage.totalTokenCount, 'basic');
       }
-      /* const usage = result.usage?.totalTokenCount || 0;
-        if (usage > 0) await deductUserCredits(userId, usage, 'basic');
-       */
+      // const usage = result.usage?.totalTokenCount || 0;
+      //  if (usage > 0) await deductUserCredits(userId, usage, 'basic');
+       //
       
         if (result.status === "REJECTED") {
             return res.json({ rejected: true, reason: result.reason || "Idea violates TOS." });
@@ -638,4 +1049,4 @@ app.get('/admin/cleanup', async (req, res) => {
 
 app.listen(PORT, () => {
     console.log(`AI Backend Running on ${PORT} (Supabase Edition)`);
-});
+}); */