Update app.js

app.js

@@ -1,100 +1,233 @@
 // server.js
-import express from "express";
-import bodyParser from "body-parser";
-import cors from "cors";
-import path from "path";
-import { fileURLToPath } from "url";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const PORT = process.env.PORT || 7860;
+import express from 'express';
+import bodyParser from 'body-parser';
+import cors from 'cors';
+import { StateManager } from './stateManager.js';
+import { AIEngine } from './aiEngine.js';
+import fs from 'fs';
 
 const app = express();
+const PORT = process.env.PORT || 3000;
+
+// Load prompts for dynamic usage
+const sysPrompts = JSON.parse(fs.readFileSync('./prompts.json', 'utf8'));
+
 app.use(cors());
-app.use(bodyParser.json({ limit: "50mb" }));
-
-// === TEST MODES ===
-// 'BUILD_PART'          -> Makes a part
-// 'FETCH_SCRIPT'        -> Finds a script by name anywhere
-// 'SCAN_SERVER_STORAGE' -> Scans "ServerStorage" explicitly
-// 'SCAN_SELECTION'      -> Scans whatever you clicked on in Roblox
-// 'FETCH_LOGS'          -> Fetches the recent Output logs
-const DEMO_MODE = 'FETCH_LOGS'; 
-
-app.post("/api/ai-build", async (req, res) => {
-  try {
-    const { instruction, selection, scriptContext, logContext, hierarchyContext } = req.body;
-    
-    console.log("------------------------------------------------");
-    console.log("📥 INSTRUCTION:", instruction);
-    
-    // 1. Script Found Response
-    if (scriptContext) {
-        console.log(`📘 SCRIPT FOUND [${scriptContext.targetName}]:`);
-        console.log(`   Parent: ${scriptContext.parentName}`);
-        console.log(scriptContext.scriptSource.substring(0, 150) + "...\n");
-        return res.json({ success: true, message: `Read ${scriptContext.targetName} successfully.` });
-    }
+app.use(bodyParser.json({ limit: '50mb' })); // Increased limit for images
 
-    // 2. Hierarchy Scanned Response
-    if (hierarchyContext) {
-        console.log(`🌳 SCANNED HIERARCHY [${hierarchyContext.rootName}]:`);
-        const treePreview = hierarchyContext.tree.split('\n').slice(0, 20).join('\n');
-        console.log(treePreview);
-        return res.json({ success: true, message: `Scanned ${hierarchyContext.rootName}.` });
+// Middleware: Validate User/Project IDs
+const validateRequest = (req, res, next) => {
+    const { userId, projectId } = req.body;
+    if (!userId || !projectId) {
+        return res.status(400).json({ error: "Missing userId or projectId" });
     }
+    next();
+};
 
-    // 3. Logs Received Response (RESTORED)
-    if (logContext) {
-        console.log("📝 LOGS RECEIVED:");
-        console.log("------------------------------------------------");
-        // Print last 500 chars to avoid flooding terminal
-        const logPreview = logContext.logs.length > 500 
-            ? "..." + logContext.logs.substring(logContext.logs.length - 500) 
-            : logContext.logs;
-        console.log(logPreview);
-        console.log("------------------------------------------------");
-        return res.json({ success: true, message: "Logs received and analyzed." });
-    }
+/**
+ * 1. NEW PROJECT
+ * Flow: PM (GDD) -> PM (Tasks) -> Worker (Task 1)
+ */
+app.post('/new/project', validateRequest, async (req, res) => {
+    const { userId, projectId, description } = req.body;
+
+    try {
+        // 1. Generate GDD with PM (High Thinking)
+        const pmHistory = [];
+        const gddPrompt = `Create a comprehensive GDD for: ${description}`;
+        const gddResponse = await AIEngine.callPM(pmHistory, gddPrompt);
+        
+        pmHistory.push({ role: 'user', parts: [{ text: gddPrompt }] });
+        pmHistory.push({ role: 'model', parts: [{ text: gddResponse }] });
+
+        // 2. Generate Initial Tasks
+        const taskPrompt = "Based on the GDD, generate a prioritized list of initial technical tasks. Output them as a JSON list.";
+        const taskResponse = await AIEngine.callPM(pmHistory, taskPrompt);
+
+        pmHistory.push({ role: 'user', parts: [{ text: taskPrompt }] });
+        pmHistory.push({ role: 'model', parts: [{ text: taskResponse }] });
+
+        // 3. Initialize Worker with GDD Context and Execute First Task
+        const workerHistory = [];
+        const initialWorkerPrompt = `Here is the GDD: ${gddResponse}. \n\n Here are the tasks: ${taskResponse}. \n\n EXECUTE THE FIRST TASK NOW.`;
+        const workerResponse = await AIEngine.callWorker(workerHistory, initialWorkerPrompt);
 
-    // 4. Demo Triggers
-    if (DEMO_MODE === 'BUILD_PART') {
-        return res.send(`\`\`\`lua
-        local p = Instance.new("Part", workspace)
-        p.Position = Vector3.new(0,20,0)
-        p.Anchored = true
-        print("Created Part")
-        \`\`\``);
-    } 
-    else if (DEMO_MODE === 'FETCH_SCRIPT') {
-        console.log("   👉 Asking to find 'BikeLogic'...");
-        return res.json({ 
-            action: "read_script", 
-            targetName: "BikeLogic" 
+        workerHistory.push({ role: 'user', parts: [{ text: initialWorkerPrompt }] });
+        workerHistory.push({ role: 'model', parts: [{ text: workerResponse }] });
+
+        // Save State
+        await StateManager.updateProject(projectId, {
+            userId,
+            pmHistory,
+            workerHistory,
+            gdd: gddResponse,
+            failureCount: 0
         });
+
+        // Queue the result for the plugin
+        StateManager.queueCommand(projectId, workerResponse);
+
+        res.json({ success: true, message: "Project initialized", gddPreview: gddResponse.substring(0, 200) });
+
+    } catch (err) {
+        console.error(err);
+        res.status(500).json({ error: "AI Processing Failed" });
     }
-    else if (DEMO_MODE === 'SCAN_SERVER_STORAGE') {
-        console.log("   👉 Asking to scan ServerStorage...");
-        return res.json({ 
-            action: "read_hierarchy",
-            targetName: "ServerStorage" 
-        });
+});
+
+/**
+ * 2. FEEDBACK (The Main Loop Endpoint)
+ * Accepts text + optional image. Hits Worker. Checks for escalation.
+ */
+app.post('/project/feedback', validateRequest, async (req, res) => {
+    const { projectId, prompt, imageBase64 } = req.body;
+
+    try {
+        const project = await StateManager.getProject(projectId);
+        if (!project) return res.status(404).json({ error: "Project not found" });
+
+        let imagePart = null;
+        if (imageBase64) {
+            imagePart = { inlineData: { mimeType: 'image/png', data: imageBase64 } };
+        }
+
+        // Call Worker
+        const response = await AIEngine.callWorker(project.workerHistory, prompt, imagePart);
+        
+        // Update History
+        project.workerHistory.push({ role: 'user', parts: [{ text: prompt }] });
+        project.workerHistory.push({ role: 'model', parts: [{ text: response }] });
+
+        // Check for Escalation Condition (Keyword or Failure Count)
+        if (response.includes("STATUS: ESCALATE_TO_PM") || project.failureCount >= 2) {
+            console.log(`Project ${projectId} escalating to PM.`);
+            
+            // Auto-trigger internal PM ping
+            // We reuse the logic from /internal/ping/pm here for efficiency
+            const distressSignal = `Worker failed to solve: ${prompt}. Last response: ${response}`;
+            const pmGuidance = await AIEngine.callPM(
+                project.pmHistory, 
+                sysPrompts.pm_guidance_prompt.replace('{{DISTRESS_SIGNAL}}', distressSignal)
+            );
+
+            // Send guidance back to worker
+            const fixedWorkerResponse = await AIEngine.callWorker(project.workerHistory, `PM GUIDANCE: ${pmGuidance}. Try again.`);
+            
+            project.failureCount = 0; // Reset failure count
+            StateManager.queueCommand(projectId, fixedWorkerResponse);
+            await StateManager.updateProject(projectId, { pmHistory: project.pmHistory, workerHistory: project.workerHistory, failureCount: 0 });
+            
+            return res.json({ success: true, message: "Escalated to PM and Resolved", type: "ESCALATION" });
+        } else {
+            // Standard Success
+            StateManager.queueCommand(projectId, response);
+            await StateManager.updateProject(projectId, { workerHistory: project.workerHistory });
+            return res.json({ success: true, message: "Processed by Worker" });
+        }
+
+    } catch (err) {
+        const project = await StateManager.getProject(projectId);
+        if (project) {
+            await StateManager.updateProject(projectId, { failureCount: (project.failureCount || 0) + 1 });
+        }
+        res.status(500).json({ error: err.message });
     }
-    else if (DEMO_MODE === 'SCAN_SELECTION') {
-        console.log("   👉 Asking to scan selection...");
-        return res.json({ action: "read_hierarchy" });
+});
+
+/**
+ * 3. INTERNAL PING WORKER
+ * PM sends guidance to Worker.
+ */
+app.post('/internal/ping/worker', validateRequest, async (req, res) => {
+    const { projectId, guidancePrompt } = req.body;
+    const project = await StateManager.getProject(projectId);
+    if (!project) return res.status(404).json({ error: "Project not found" });
+
+    // Inject PM Context (GDD/History) into the message if requested
+    const fullContextPrompt = `PM CONTEXT: ${JSON.stringify(project.pmHistory)}. \n GUIDANCE: ${guidancePrompt}`;
+
+    const response = await AIEngine.callWorker(project.workerHistory, fullContextPrompt);
+    StateManager.queueCommand(projectId, response);
+    
+    res.json({ success: true, message: "Guidance sent to Worker" });
+});
+
+/**
+ * 4. INTERNAL PING PM
+ * Worker signals distress -> PM responds.
+ */
+app.post('/internal/ping/pm', validateRequest, async (req, res) => {
+    const { projectId, distressMessage } = req.body;
+    const project = await StateManager.getProject(projectId);
+    
+    // PM analyzes distress
+    const pmResponse = await AIEngine.callPM(project.pmHistory, `Worker Distress: ${distressMessage}. Provide solution.`);
+    
+    // Logic: Decide to reset worker OR guide worker
+    if (pmResponse.includes("RESET_RECOMMENDED")) {
+        // Call reset endpoint logic (internal function call)
+        project.workerHistory = [{ role: 'user', parts: [{ text: sysPrompts.worker_reset_prompt.replace('{{INSTRUCTION}}', pmResponse) }] }];
+        await StateManager.updateProject(projectId, { workerHistory: project.workerHistory });
+        res.json({ action: "RESET", guidance: pmResponse });
+    } else {
+        // Just guide
+        const workerResp = await AIEngine.callWorker(project.workerHistory, `PM FIX: ${pmResponse}`);
+        StateManager.queueCommand(projectId, workerResp);
+        res.json({ action: "GUIDANCE", guidance: pmResponse });
     }
-    else if (DEMO_MODE === 'FETCH_LOGS') {
-        console.log("   👉 Asking to fetch Console Logs...");
-        return res.json({ action: "read_logs" });
+});
+
+/**
+ * 5. PROJECT RESET
+ * Resets the worker thread completely.
+ */
+app.post('/project/reset', validateRequest, async (req, res) => {
+    const { projectId } = req.body;
+    const project = await StateManager.getProject(projectId);
+    
+    // Clear history, keep GDD context
+    const resetPrompt = `System reset. Current GDD: ${project.gdd}. Await instructions.`;
+    
+    await StateManager.updateProject(projectId, { 
+        workerHistory: [{ role: 'user', parts: [{ text: resetPrompt }] }],
+        failureCount: 0 
+    });
+
+    res.json({ success: true, message: "Worker thread reset" });
+});
+
+/**
+ * 6. PROJECT PING (The Roblox Plugin Endpoint)
+ * Plugin calls this to fetch executable code.
+ */
+app.post('/project/ping', validateRequest, async (req, res) => {
+    const { projectId } = req.body;
+    const project = await StateManager.getProject(projectId);
+
+    if (!project || !project.commandQueue || project.commandQueue.length === 0) {
+        return res.json({ status: "IDLE" });
     }
 
-    return res.json({ success: true, message: "Thinking..." });
+    // Pop the oldest command
+    const command = project.commandQueue.shift();
+    await StateManager.updateProject(projectId, { commandQueue: project.commandQueue });
+
+    // Return the whole response, but specifically parsed code for execution
+    res.json({
+        status: "EXECUTE",
+        fullResponse: command.raw,
+        codeSnippet: command.code // The markdown snippet extracted in StateManager
+    });
+});
 
-  } catch (err) {
-    console.error("Server Error:", err);
-    res.status(500).send("Server Error: " + err.message);
-  }
+/**
+ * 7. INACTIVITY CLEANUP
+ */
+app.delete('/internal/cleanup', async (req, res) => {
+    const count = StateManager.cleanupInactivity();
+    res.json({ success: true, removed: count });
 });
 
-app.listen(PORT, () => console.log(`🚀 Server running on port ${PORT}. Mode: ${DEMO_MODE}`));
+app.listen(PORT, () => {
+    console.log(`AI Builder Backend running on port ${PORT}`);
+});