Update app.js

app.js

@@ -4,22 +4,46 @@ import cors from 'cors';
 import { StateManager } from './stateManager.js';
 import { AIEngine } from './aiEngine.js';
 import fs from 'fs';
+import admin from 'firebase-admin';
+
+// --- FIREBASE SETUP ---
+// If you do not have 'serviceAccountKey.json', this will gracefully degrade to memory-only
+let db = null;
+try {
+    if (fs.existsSync('./serviceAccountKey.json')) {
+        const serviceAccount = JSON.parse(fs.readFileSync('./serviceAccountKey.json', 'utf8'));
+        admin.initializeApp({
+            credential: admin.credential.cert(serviceAccount),
+            databaseURL: "https://YOUR-FIREBASE-PROJECT.firebaseio.com" // REPLACE THIS
+        });
+        db = admin.database();
+        console.log("🔥 Firebase Connected");
+    } else {
+        console.warn("⚠️ No serviceAccountKey.json found. Running in Memory-Only mode.");
+    }
+} catch (e) {
+    console.error("Firebase Init Error:", e);
+}
 
 const app = express();
 const PORT = process.env.PORT || 7860;
 
+// Load Prompts for Server-Side Logic Checks
 const sysPrompts = JSON.parse(fs.readFileSync('./prompts.json', 'utf8'));
 
 app.use(cors());
 app.use(bodyParser.json({ limit: '50mb' }));
 
+// --- HELPERS ---
 const validateRequest = (req, res, next) => {
+    // For Onboarding, IDs might be generated on the fly, so we skip rigid validation there
+    if (req.path.includes('/onboarding')) return next();
+    
     const { userId, projectId } = req.body;
     if (!userId || !projectId) return res.status(400).json({ error: "Missing ID" });
     next();
 };
 
-// --- HELPERS ---
 function extractWorkerPrompt(text) {
     const match = text.match(/WORKER_PROMPT:\s*(.*)/s);
     return match ? match[1].trim() : null;
@@ -42,10 +66,77 @@ function extractImagePrompt(text) {
     return match ? match[1].trim() : null;
 }
 
-// --- ENDPOINTS ---
+// --- ONBOARDING ENDPOINTS ---
+
+/**
+ * 1. ANALYZE (User Idea -> Questions)
+ */
+app.post('/onboarding/analyze', validateRequest, async (req, res) => {
+    const { description } = req.body;
+    if (!description) return res.status(400).json({ error: "Description required" });
+
+    try {
+        console.log(`[Onboarding] Analyzing idea...`);
+        const questions = await AIEngine.generateEntryQuestions(description);
+        res.json({ questions });
+    } catch (err) {
+        console.error(err);
+        res.status(500).json({ error: "Analysis failed" });
+    }
+});
+
+/**
+ * 2. CREATE (User Answers -> Grade + Thumbnail -> Save)
+ */
+app.post('/onboarding/create', validateRequest, async (req, res) => {
+    const { userId, description, answers } = req.body;
+    const projectId = "proj_" + Date.now(); 
+
+    try {
+        console.log(`[Onboarding] Creating Project ${projectId}...`);
+
+        // Run Grading and Image Gen in Parallel
+        const [grading, thumbnailBase64] = await Promise.all([
+            AIEngine.gradeProject(description, answers),
+            AIEngine.generateImage(`Roblox game thumbnail, cinematic, high quality: ${description}`)
+        ]);
+
+        const projectData = {
+            id: projectId,
+            userId,
+            description,
+            answers,
+            stats: grading,
+            thumbnail: thumbnailBase64 ? `data:image/png;base64,${thumbnailBase64}` : null,
+            createdAt: Date.now(),
+            status: "initialized"
+        };
+
+        // Save to Firebase
+        if (db) {
+            await db.ref(`projects/${projectId}`).set(projectData);
+        }
+        
+        // Also Init StateManager so it's ready for /new/project call later
+        await StateManager.updateProject(projectId, {
+            ...projectData,
+            workerHistory: [],
+            pmHistory: [],
+            failureCount: 0
+        });
+
+        res.json({ success: true, projectId, stats: grading, thumbnail: projectData.thumbnail });
+
+    } catch (err) {
+        console.error("Create Error:", err);
+        res.status(500).json({ error: "Creation failed" });
+    }
+});
+
+// --- CORE WORKFLOW ENDPOINTS ---
 
 /**
- * 1. NEW PROJECT
+ * 3. INITIALIZE WORKSPACE (PM Generates GDD -> First Task)
  */
 app.post('/new/project', validateRequest, async (req, res) => {
     const { userId, projectId, description } = req.body;
@@ -73,6 +164,7 @@ app.post('/new/project', validateRequest, async (req, res) => {
         workerHistory.push({ role: 'user', parts: [{ text: initialWorkerPrompt }] });
         workerHistory.push({ role: 'model', parts: [{ text: workerResponse }] });
 
+        // Update State
         await StateManager.updateProject(projectId, {
             userId,
             pmHistory,
@@ -81,19 +173,19 @@ app.post('/new/project', validateRequest, async (req, res) => {
             failureCount: 0
         });
 
-        // Queue Initial Response
+        // Queue Actions
         await processAndQueueResponse(projectId, workerResponse);
 
-        res.json({ success: true, message: "Project Initialized", gddPreview: gddResponse.substring(0, 200) });
+        res.json({ success: true, message: "Workspace Initialized", gddPreview: gddResponse.substring(0, 200) });
 
     } catch (err) {
-        console.error(err);
-        res.status(500).json({ error: "Init Failed" });
+        console.error("Init Error:", err);
+        res.status(500).json({ error: "Initialization Failed" });
     }
 });
 
 /**
- * 2. FEEDBACK LOOP
+ * 4. FEEDBACK LOOP (The "Brain")
  */
 app.post('/project/feedback', async (req, res) => {
     const { projectId, prompt, hierarchyContext, scriptContext, logContext, taskComplete, images } = req.body;
@@ -101,7 +193,7 @@ app.post('/project/feedback', async (req, res) => {
     const project = await StateManager.getProject(projectId);
     if (!project) return res.status(404).json({ error: "Project not found." });
 
-    // A. TASK COMPLETE
+    // A. TASK COMPLETE -> SCOPE SWITCH
     if (taskComplete) {
         console.log(`[${projectId}] ✅ TASK COMPLETE.`);
         
@@ -117,6 +209,7 @@ app.post('/project/feedback', async (req, res) => {
              return res.json({ success: true, message: "No further tasks. Project Idle." });
         }
 
+        console.log(`[${projectId}] 🧹 Nuking Worker for next task.`);
         const newWorkerHistory = [];
         const newPrompt = `New Objective: ${nextInstruction}`;
         const workerResponse = await AIEngine.callWorker(newWorkerHistory, newPrompt, []);
@@ -130,13 +223,13 @@ app.post('/project/feedback', async (req, res) => {
             failureCount: 0
         });
 
-        StateManager.queueCommand(projectId, { type: "EXECUTE", payload: "warn('Starting Next Task')" }); // Reset console
+        StateManager.queueCommand(projectId, { type: "EXECUTE", payload: "warn('Starting Next Task...')" });
         await processAndQueueResponse(projectId, workerResponse);
 
         return res.json({ success: true, message: "Next Task Assigned" });
     }
 
-    // B. FAILURE DETECTION
+    // B. ERROR ESCALATION
     let isFailure = false;
     if (logContext?.logs) {
         const errs = ["Error", "Exception", "failed", "Stack Begin", "Infinite yield"];
@@ -146,7 +239,6 @@ app.post('/project/feedback', async (req, res) => {
         }
     }
 
-    // C. ESCALATION
     if (project.failureCount > 3) {
         console.log(`[${projectId}] 🚨 Escalating to PM...`);
         const pmPrompt = sysPrompts.pm_guidance_prompt.replace('{{LOGS}}', logContext?.logs);
@@ -162,7 +254,9 @@ app.post('/project/feedback', async (req, res) => {
             resetHistory.push({ role: 'model', parts: [{ text: workerResp }] });
 
             await StateManager.updateProject(projectId, { workerHistory: resetHistory, failureCount: 0 });
+            StateManager.queueCommand(projectId, { type: "EXECUTE", payload: "print('SYSTEM: Worker Reset')" });
             await processAndQueueResponse(projectId, workerResp);
+            
             return res.json({ success: true, message: "Worker Terminated." });
         } else {
             const injection = `[PM GUIDANCE]: ${pmVerdict} \n\nApply this fix now.`;
@@ -173,29 +267,31 @@ app.post('/project/feedback', async (req, res) => {
             
             await StateManager.updateProject(projectId, { workerHistory: project.workerHistory, failureCount: 1 });
             await processAndQueueResponse(projectId, workerResp);
+            
             return res.json({ success: true, message: "PM Guidance Applied." });
         }
     }
 
-    // D. STANDARD WORKER FLOW
+    // C. STANDARD LOOP + CONSULTATION
     try {
         const fullInput = `USER: ${prompt || "Automatic Feedback"}` + formatContext({ hierarchyContext, scriptContext, logContext });
         
         let response = await AIEngine.callWorker(project.workerHistory, fullInput, images || []);
         
-        // CHECK: PM CONSULTATION
+        // CHECK: Consultant Question
         const pmQuestion = extractPMQuestion(response);
         if (pmQuestion) {
             console.log(`[${projectId}] 🙋 Worker asking PM: "${pmQuestion}"`);
-            const pmConsultPrompt = `[WORKER CONSULTATION]: The Worker asks: "${pmQuestion}"\nProvide a technical answer.`;
+            
+            const pmConsultPrompt = `[WORKER CONSULTATION]: The Worker asks: "${pmQuestion}"\nProvide a technical answer to unblock them.`;
             const pmAnswer = await AIEngine.callPM(project.pmHistory, pmConsultPrompt);
 
+            // Update PM Context
             project.pmHistory.push({ role: 'user', parts: [{ text: pmConsultPrompt }] });
             project.pmHistory.push({ role: 'model', parts: [{ text: pmAnswer }] });
 
+            // Feed Answer Back
             const injectionMsg = `[PM RESPONSE]: ${pmAnswer}`;
-            
-            // Push question-answer to history
             project.workerHistory.push({ role: 'user', parts: [{ text: fullInput }] });
             project.workerHistory.push({ role: 'model', parts: [{ text: response }] });
             
@@ -214,7 +310,6 @@ app.post('/project/feedback', async (req, res) => {
             failureCount: project.failureCount 
         });
         
-        // Process response for Code OR Images
         await processAndQueueResponse(projectId, response);
         res.json({ success: true });
 
@@ -225,7 +320,29 @@ app.post('/project/feedback', async (req, res) => {
 });
 
 /**
- * HUMAN OVERRIDE
+ * 5. PING (Plugin Polling)
+ */
+app.post('/project/ping', async (req, res) => {
+    const { projectId } = req.body;
+    const command = await StateManager.popCommand(projectId);
+    
+    if (command) {
+        if (command.payload === "CLEAR_CONSOLE") {
+             res.json({ action: "CLEAR_LOGS" });
+        } else {
+            res.json({ 
+                action: command.type, 
+                target: command.payload, 
+                code: command.type === 'EXECUTE' ? command.payload : null 
+            });
+        }
+    } else {
+        res.json({ action: "IDLE" });
+    }
+});
+
+/**
+ * 6. MANUAL OVERRIDE
  */
 app.post('/human/override', validateRequest, async (req, res) => {
     const { projectId, instruction, pruneHistory } = req.body;
@@ -247,52 +364,25 @@ app.post('/human/override', validateRequest, async (req, res) => {
     res.json({ success: true });
 });
 
-/**
- * PING (Plugin Polling)
- */
-app.post('/project/ping', async (req, res) => {
-    const { projectId } = req.body;
-    const command = await StateManager.popCommand(projectId);
-    
-    if (command) {
-        if (command.payload === "CLEAR_CONSOLE") {
-             res.json({ action: "CLEAR_LOGS" });
-        } else {
-            // Can be: EXECUTE, READ_SCRIPT, READ_HIERARCHY, CREATE_ASSET
-            res.json({ 
-                action: command.type, 
-                target: command.payload, 
-                code: command.type === 'EXECUTE' ? command.payload : null 
-            });
-        }
-    } else {
-        res.json({ action: "IDLE" });
-    }
-});
 
-
-// --- CORE LOGIC: PROCESS RESPONSE & HANDLE IMAGES ---
+// --- RESPONSE PROCESSOR ---
 async function processAndQueueResponse(projectId, rawResponse) {
-    // 1. Check for Image Generation Tag
+    // 1. Intercept Image Requests
     const imgPrompt = extractImagePrompt(rawResponse);
     if (imgPrompt) {
-        console.log(`[${projectId}] 🎨 Generating Image for: ${imgPrompt}`);
+        console.log(`[${projectId}] 🎨 Generating Asset: ${imgPrompt}`);
         const base64Image = await AIEngine.generateImage(imgPrompt);
         
         if (base64Image) {
-            // Queue the creation command for the plugin
+            // Queue asset creation for Plugin
             await StateManager.queueCommand(projectId, {
                 type: "CREATE_ASSET", 
-                payload: base64Image // Plugin receives Base64
+                payload: base64Image
             });
-            console.log(`[${projectId}] Image Asset Queued.`);
-        } else {
-            console.error(`[${projectId}] Image Generation Failed.`);
         }
     }
 
-    // 2. Queue standard commands (Code, Reads, etc.)
-    // We pass the RAW response to StateManager to parse code blocks
+    // 2. Queue the Raw Response (StateManager parses code)
     await StateManager.queueCommand(projectId, rawResponse);
 }