Update app.js

app.js

@@ -1,4 +1,3 @@
-
 // App.js
 
 import express from 'express';
@@ -82,9 +81,9 @@ async function deductUserCredits(userId, amount, type = 'basic') {
             const current = current_credits || 0;
             return Math.max(0, current - amount);
         });
-        console.log(` Deducted ${amount} ${type} credits from User ${userId}`);
+        console.log(`[Credits] Deducted ${amount} ${type} credits from User ${userId}`);
     } catch (err) {
-        console.error(` Failed to deduct ${amount} ${type} from ${userId}:`, err);
+        console.error(`[Credits] Failed to deduct ${amount} ${type} from ${userId}:`, err);
     }
 }
 
@@ -101,33 +100,36 @@ const validateRequest = (req, res, next) => {
     next();
 };
 
-// --- REGEX HELPERS ---
+// --- REGEX HELPERS (FIXED) ---
 function extractWorkerPrompt(text) {
     const match = text.match(/WORKER_PROMPT:\s*(.*)/s);
-    return match ? match.trim() : null;
+    return match ? match[1].trim() : null;
 }
 
 function formatContext({ hierarchyContext, scriptContext, logContext }) {
     let out = "";
-    if (scriptContext) out += `\n: ${scriptContext.targetName}\n: ${scriptContext.scriptSource}`;
-    if (logContext) out += `\n: ${logContext.logs}`;
-    if (hierarchyContext) out += `\n: ${hierarchyContext}`;
+    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;
 }
 
 function extractPMQuestion(text) {
-    const match = text.match(/\/s); 
-    return match ? match.trim() : null;
+    // Looks for [ASK_PM: ...]
+    const match = text.match(/\[ASK_PM:\s*(.*?)\]/s); 
+    return match ? match[1].trim() : null;
 }
 
 function extractImagePrompt(text) {
-    const match = text.match(/\/s);
-    return match ? match.trim() : null;
+    // Looks for [GENERATE_IMAGE: ...]
+    const match = text.match(/\[GENERATE_IMAGE:\s*(.*?)\]/s);
+    return match ? match[1].trim() : null;
 }
 
 function extractRouteToPM(text) {
-    const match = text.match(/\/s);
-    return match ? match.trim() : null;
+    // Looks for [ROUTE_TO_PM: ...]
+    const match = text.match(/\[ROUTE_TO_PM:\s*(.*?)\]/s);
+    return match ? match[1].trim() : null;
 }
 
 // --- ADMIN ENDPOINTS ---
@@ -148,7 +150,7 @@ app.post('/onboarding/analyze', validateRequest, async (req, res) => {
 
     try {
         await checkMinimumCredits(userId, 'basic');
-        console.log(` Analyzing idea...`);
+        console.log(`[Onboarding] Analyzing idea...`);
         
         const result = await AIEngine.generateEntryQuestions(description);
         const usage = result.usage?.totalTokenCount || 0;
@@ -182,7 +184,7 @@ app.post('/onboarding/create', validateRequest, async (req, res) => {
         const randomHex = (n = 6) => crypto.randomBytes(Math.ceil(n/2)).toString("hex").slice(0, n);
         const projectId = `proj_${Date.now()}_${randomHex(7)}`;
 
-        console.log(` Grading Project ${projectId}...`);
+        console.log(`[Onboarding] Grading Project ${projectId}...`);
 
         const gradingResult = await AIEngine.gradeProject(description, answers);
         basicTokens += (gradingResult.usage?.totalTokenCount || 0);
@@ -203,9 +205,9 @@ app.post('/onboarding/create', validateRequest, async (req, res) => {
                 thumbnail: thumbnailUrl, 
                 createdAt: Date.now(),
                 status: "Idle",
-                workerHistory:[],
+                workerHistory: [],
                 pmHistory: [],
-                commandQueue:[],
+                commandQueue: [],
                 failureCount: 0
             };
             await StateManager.updateProject(projectId, memoryObject);
@@ -215,14 +217,14 @@ app.post('/onboarding/create', validateRequest, async (req, res) => {
             await firestore.collection('projects').doc(projectId).set({
                 id: projectId,
                 userId: userId,
-                assets: thumbnailUrl ? :[],
+                assets: thumbnailUrl ? [thumbnailUrl] : [],
                 createdAt: admin.firestore.FieldValue.serverTimestamp()
             });
         }
 
         if (db && !isFailure) {
             const updates = {};
-            updates = {
+            updates[`projects/${projectId}/info`] = {
                 id: projectId,
                 userId,
                 title: gradingResult.title || "Untitled",
@@ -232,11 +234,11 @@ app.post('/onboarding/create', validateRequest, async (req, res) => {
                 createdAt: Date.now(),
                 status: "Idle"
             };
-            if (thumbnailUrl) updates = { url: thumbnailUrl };
-            updates = {
+            if (thumbnailUrl) updates[`projects/${projectId}/thumbnail`] = { url: thumbnailUrl };
+            updates[`projects/${projectId}/state`] = {
                 workerHistory: [],
-                pmHistory:[],
-                commandQueue:[],
+                pmHistory: [],
+                commandQueue: [],
                 failureCount: 0
             };
             await db.ref().update(updates);
@@ -265,13 +267,13 @@ app.post('/onboarding/create', validateRequest, async (req, res) => {
 // --- CORE ENDPOINTS ---
 
 async function runBackgroundInitialization(projectId, userId, description) {
-    console.log(` Starting initialization for ${projectId}`);
+    console.log(`[Background] Starting initialization for ${projectId}`);
     
     let diamondUsage = 0; 
     let basicUsage = 0;   
 
     try {
-        const pmHistory =[];
+        const pmHistory = [];
         
         // 1. Generate GDD (PM -> Diamond)
         const gddPrompt = `Create a comprehensive GDD for: ${description}`;
@@ -280,8 +282,8 @@ async function runBackgroundInitialization(projectId, userId, description) {
         diamondUsage += (gddResult.usage?.totalTokenCount || 0);
         const gddText = gddResult.text;
 
-        pmHistory.push({ role: 'user', parts: });
-        pmHistory.push({ role: 'model', parts: });
+        pmHistory.push({ role: 'user', parts: [{ text: gddPrompt }] });
+        pmHistory.push({ role: 'model', parts: [{ text: gddText }] });
 
         // 2. Generate First Task (PM -> Diamond)
         const taskPrompt = "Based on the GDD, generate the first technical milestone.\nOutput format:\nTASK_NAME: <Name>\nWORKER_PROMPT: <Specific, isolated instructions for the worker>";
@@ -290,21 +292,21 @@ async function runBackgroundInitialization(projectId, userId, description) {
         diamondUsage += (taskResult.usage?.totalTokenCount || 0);
         const taskText = taskResult.text;
 
-        pmHistory.push({ role: 'user', parts: });
-        pmHistory.push({ role: 'model', parts: });
+        pmHistory.push({ role: 'user', parts: [{ text: taskPrompt }] });
+        pmHistory.push({ role: 'model', parts: [{ text: taskText }] });
 
         // 3. Initialize Worker (Worker -> Basic)
         const initialWorkerInstruction = extractWorkerPrompt(taskText) || `Initialize structure for: ${description}`;
-        const workerHistory =[];
+        const workerHistory = [];
         const initialWorkerPrompt = `CONTEXT: New Project. \nINSTRUCTION: ${initialWorkerInstruction}`;
         
-        const workerResult = await AIEngine.callWorker(workerHistory, initialWorkerPrompt,[]);
+        const workerResult = await AIEngine.callWorker(workerHistory, initialWorkerPrompt, []);
         
         basicUsage += (workerResult.usage?.totalTokenCount || 0);
         const workerText = workerResult.text;
 
-        workerHistory.push({ role: 'user', parts: });
-        workerHistory.push({ role: 'model', parts: });
+        workerHistory.push({ role: 'user', parts: [{ text: initialWorkerPrompt }] });
+        workerHistory.push({ role: 'model', parts: [{ text: workerText }] });
 
         // 4. Update Memory
         await StateManager.updateProject(projectId, {
@@ -328,10 +330,10 @@ async function runBackgroundInitialization(projectId, userId, description) {
         if (diamondUsage > 0) await deductUserCredits(userId, diamondUsage, 'diamond');
         if (basicUsage > 0) await deductUserCredits(userId, basicUsage, 'basic');
         
-        console.log(` Init complete. Diamond: ${diamondUsage}, Basic: ${basicUsage}`);
+        console.log(`[Background] Init complete. Diamond: ${diamondUsage}, Basic: ${basicUsage}`);
 
     } catch (err) {
-        console.error(` Init Error for ${projectId}:`, err);
+        console.error(`[Background] Init Error for ${projectId}:`, err);
         if(db) await db.ref(`projects/${projectId}/info/status`).set("error");
     }
 }
@@ -378,15 +380,15 @@ app.post('/project/feedback', async (req, res) => {
           
         // SCENARIO 1: TASK COMPLETE (Worker asks PM for next job)
         if (taskComplete) {
-            console.log(` ✅ TASK COMPLETE.`);
+            console.log(`[${projectId}] ✅ TASK COMPLETE.`);
             const summary = `Worker completed the previous task. Logs: ${logContext?.logs || "Clean"}. \nGenerate the NEXT task using 'WORKER_PROMPT:' format.`;
             
             const pmResult = await AIEngine.callPM(project.pmHistory, summary);
             diamondUsage += (pmResult.usage?.totalTokenCount || 0);
             const pmText = pmResult.text;
             
-            project.pmHistory.push({ role: 'user', parts: });
-            project.pmHistory.push({ role: 'model', parts: });
+            project.pmHistory.push({ role: 'user', parts: [{ text: summary }] });
+            project.pmHistory.push({ role: 'model', parts: [{ text: pmText }] });
 
             const nextInstruction = extractWorkerPrompt(pmText);
             if (!nextInstruction) {
@@ -397,12 +399,12 @@ app.post('/project/feedback', async (req, res) => {
             }
 
             const newPrompt = `New Objective: ${nextInstruction}`;
-            const workerResult = await AIEngine.callWorker(project.workerHistory, newPrompt,[]);
+            const workerResult = await AIEngine.callWorker(project.workerHistory, newPrompt, []);
             basicUsage += (workerResult.usage?.totalTokenCount || 0);
             const workerText = workerResult.text;
 
-            project.workerHistory.push({ role: 'user', parts: });
-            project.workerHistory.push({ role: 'model', parts: });
+            project.workerHistory.push({ role: 'user', parts: [{ text: newPrompt }] });
+            project.workerHistory.push({ role: 'model', parts: [{ text: workerText }] });
 
             await StateManager.updateProject(projectId, {
                 pmHistory: project.pmHistory,
@@ -428,17 +430,17 @@ app.post('/project/feedback', async (req, res) => {
             diamondUsage += (pmResult.usage?.totalTokenCount || 0);
             const pmVerdict = pmResult.text;
 
-            if (pmVerdict.includes("")) {
-                const fixInstruction = pmVerdict.replace("", "").trim();
-                const resetPrompt = `: Previous worker terminated. \nNew Objective: ${fixInstruction}`;
+            if (pmVerdict.includes("[TERMINATE]")) {
+                const fixInstruction = pmVerdict.replace("[TERMINATE]", "").trim();
+                const resetPrompt = `[SYSTEM]: Previous worker terminated. \nNew Objective: ${fixInstruction}`;
                 
                 // Clear History on terminate
-                const resetHistory =[];
-                const workerResult = await AIEngine.callWorker(resetHistory, resetPrompt,[]);
+                const resetHistory = [];
+                const workerResult = await AIEngine.callWorker(resetHistory, resetPrompt, []);
                 basicUsage += (workerResult.usage?.totalTokenCount || 0);
                 
-                resetHistory.push({ role: 'user', parts: });
-                resetHistory.push({ role: 'model', parts: });
+                resetHistory.push({ role: 'user', parts: [{ text: resetPrompt }] });
+                resetHistory.push({ role: 'model', parts: [{ text: workerResult.text }] });
 
                 await StateManager.updateProject(projectId, { workerHistory: resetHistory, failureCount: 0 });
                 StateManager.queueCommand(projectId, { type: "EXECUTE", payload: "print('SYSTEM: Worker Reset')" });
@@ -448,12 +450,12 @@ app.post('/project/feedback', async (req, res) => {
                 if (basicUsage > 0) await deductUserCredits(userId, basicUsage, 'basic');
                 return res.json({ success: true, message: "Worker Terminated." });
             } else {
-                const injection = `: ${pmVerdict} \n\nApply this fix now.`;
-                const workerResult = await AIEngine.callWorker(project.workerHistory, injection,[]);
+                const injection = `[PM GUIDANCE]: ${pmVerdict} \n\nApply this fix now.`;
+                const workerResult = await AIEngine.callWorker(project.workerHistory, injection, []);
                 basicUsage += (workerResult.usage?.totalTokenCount || 0);
 
-                project.workerHistory.push({ role: 'user', parts: });
-                project.workerHistory.push({ role: 'model', parts: });
+                project.workerHistory.push({ role: 'user', parts: [{ text: injection }] });
+                project.workerHistory.push({ role: 'model', parts: [{ text: workerResult.text }] });
                 
                 await StateManager.updateProject(projectId, { workerHistory: project.workerHistory, failureCount: 1 });
                 await processAndQueueResponse(projectId, workerResult.text, userId);
@@ -467,7 +469,7 @@ app.post('/project/feedback', async (req, res) => {
         // SCENARIO 3: STANDARD INTERACTION (Worker is the Frontline)
         const fullInput = `USER: ${prompt || "Automatic Feedback"}` + formatContext({ hierarchyContext, scriptContext, logContext });
         
-        let workerResult = await AIEngine.callWorker(project.workerHistory, fullInput, images ||[]);
+        let workerResult = await AIEngine.callWorker(project.workerHistory, fullInput, images || []);
         basicUsage += (workerResult.usage?.totalTokenCount || 0);
         let responseText = workerResult.text;
         
@@ -478,13 +480,13 @@ app.post('/project/feedback', async (req, res) => {
             console.log(` 🔀 Task routed to PM: ${routeTask}`);
             
             // PM generates Backend Code (Diamond)
-            const pmPrompt = `: ${routeTask}\nWrite the core server/backend logic yourself. Then use WORKER_PROMPT: <task> to delegate the UI/Client aspects to the Worker.`;
+            const pmPrompt = `[ROUTED TASK]: ${routeTask}\nWrite the core server/backend logic yourself. Then use WORKER_PROMPT: <task> to delegate the UI/Client aspects to the Worker.`;
             const pmResult = await AIEngine.callPM(project.pmHistory, pmPrompt);
             diamondUsage += (pmResult.usage?.totalTokenCount || 0);
             const pmText = pmResult.text;
 
-            project.pmHistory.push({ role: 'user', parts: });
-            project.pmHistory.push({ role: 'model', parts: });
+            project.pmHistory.push({ role: 'user', parts: [{ text: pmPrompt }] });
+            project.pmHistory.push({ role: 'model', parts: [{ text: pmText }] });
 
             // Queue PM's Backend Code to Studio
             await processAndQueueResponse(projectId, pmText, userId);
@@ -492,18 +494,18 @@ app.post('/project/feedback', async (req, res) => {
             // Did the PM give the Worker UI/Client homework?
             const nextInstruction = extractWorkerPrompt(pmText);
             if (nextInstruction) {
-                const delegationPrompt = `: The PM has handled the backend logic. Now execute this UI/Client task: ${nextInstruction}`;
+                const delegationPrompt = `[SYSTEM]: The PM has handled the backend logic. Now execute this UI/Client task: ${nextInstruction}`;
                 
-                const workerDelegationResult = await AIEngine.callWorker(project.workerHistory, delegationPrompt,[]);
+                const workerDelegationResult = await AIEngine.callWorker(project.workerHistory, delegationPrompt, []);
                 basicUsage += (workerDelegationResult.usage?.totalTokenCount || 0);
                 responseText = workerDelegationResult.text;
 
-                project.workerHistory.push({ role: 'user', parts: });
-                project.workerHistory.push({ role: 'model', parts: });
+                project.workerHistory.push({ role: 'user', parts: [{ text: delegationPrompt }] });
+                project.workerHistory.push({ role: 'model', parts: [{ text: responseText }] });
             } else {
                 responseText = "System Note: The PM completed the core task without delegating client logic.";
-                project.workerHistory.push({ role: 'user', parts: });
-                project.workerHistory.push({ role: 'model', parts: });
+                project.workerHistory.push({ role: 'user', parts: [{ text: "System: PM task complete." }] });
+                project.workerHistory.push({ role: 'model', parts: [{ text: responseText }] });
             }
         } 
         // INTERCEPTOR B: Worker asks PM a question
@@ -512,29 +514,29 @@ app.post('/project/feedback', async (req, res) => {
             if (pmQuestion) {
                 console.log(` ❓ Worker asked PM: ${pmQuestion}`);
                 
-                const pmConsultPrompt = `: The Worker asks: "${pmQuestion}"\nProvide a technical answer to unblock them.`;
+                const pmConsultPrompt = `[WORKER CONSULTATION]: The Worker asks: "${pmQuestion}"\nProvide a technical answer to unblock them.`;
                 const pmResult = await AIEngine.callPM(project.pmHistory, pmConsultPrompt);
                 diamondUsage += (pmResult.usage?.totalTokenCount || 0);
                 const pmAnswer = pmResult.text;
 
-                project.pmHistory.push({ role: 'user', parts: });
-                project.pmHistory.push({ role: 'model', parts: });
+                project.pmHistory.push({ role: 'user', parts: [{ text: pmConsultPrompt }] });
+                project.pmHistory.push({ role: 'model', parts: [{ text: pmAnswer }] });
 
-                const injectionMsg = `: ${pmAnswer}`;
-                project.workerHistory.push({ role: 'user', parts: });
-                project.workerHistory.push({ role: 'model', parts: });
+                const injectionMsg = `[PM RESPONSE]: ${pmAnswer}`;
+                project.workerHistory.push({ role: 'user', parts: [{ text: injectionMsg }] });
+                project.workerHistory.push({ role: 'model', parts: [{ text: responseText }] });
                 
                 // Re-call Worker
-                workerResult = await AIEngine.callWorker(project.workerHistory, injectionMsg,[]);
+                workerResult = await AIEngine.callWorker(project.workerHistory, injectionMsg, []);
                 basicUsage += (workerResult.usage?.totalTokenCount || 0);
                 responseText = workerResult.text;
 
-                project.workerHistory.push({ role: 'user', parts: });
-                project.workerHistory.push({ role: 'model', parts: });
+                project.workerHistory.push({ role: 'user', parts: [{ text: injectionMsg }] });
+                project.workerHistory.push({ role: 'model', parts: [{ text: responseText }] });
             } else {
                 // Standard Worker Execution
-                project.workerHistory.push({ role: 'user', parts: });
-                project.workerHistory.push({ role: 'model', parts: });
+                project.workerHistory.push({ role: 'user', parts: [{ text: fullInput }] });
+                project.workerHistory.push({ role: 'model', parts: [{ text: responseText }] });
             }
         }
 
@@ -600,18 +602,18 @@ app.post('/human/override', validateRequest, async (req, res) => {
         await checkMinimumCredits(userId, 'basic');
 
         const project = await StateManager.getProject(projectId);
-        const overrideMsg = `: ${instruction}`;
+        const overrideMsg = `[SYSTEM OVERRIDE]: ${instruction}`;
 
         if (pruneHistory && project.workerHistory.length >= 2) {
             project.workerHistory.pop();
             project.workerHistory.pop();
         }
 
-        const workerResult = await AIEngine.callWorker(project.workerHistory, overrideMsg,[]);
+        const workerResult = await AIEngine.callWorker(project.workerHistory, overrideMsg, []);
         basicUsage += (workerResult.usage?.totalTokenCount || 0);
 
-        project.workerHistory.push({ role: 'user', parts: });
-        project.workerHistory.push({ role: 'model', parts: });
+        project.workerHistory.push({ role: 'user', parts: [{ text: overrideMsg }] });
+        project.workerHistory.push({ role: 'model', parts: [{ text: workerResult.text }] });
         
         await StateManager.updateProject(projectId, { workerHistory: project.workerHistory });
         await processAndQueueResponse(projectId, workerResult.text, userId);