Update app.js

app.js

@@ -3,211 +3,252 @@ 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 || 7860;
+
+// Load prompts
+const sysPrompts = JSON.parse(fs.readFileSync('./prompts.json', 'utf8'));
+
 app.use(cors());
 app.use(bodyParser.json({ limit: '50mb' }));
-const PORT = process.env.PORT || 7860;
 
-// Helper to format Roblox context for AI
-const formatContext = (ctx) => {
-    let s = "";
-    if (ctx.hierarchyContext) s += `\nCURRENT HIERARCHY:\n${ctx.hierarchyContext.tree}\n`;
-    if (ctx.scriptContext) s += `\nEDITING SCRIPT: ${ctx.scriptContext.targetName}\nSOURCE:\n${ctx.scriptContext.scriptSource}\n`;
-    if (ctx.logContext) s += `\nRECENT LOGS (Errors/Output):\n${ctx.logContext.logs}\n`;
-    return s;
+const validateRequest = (req, res, next) => {
+    const { userId, projectId } = req.body;
+    if (!userId || !projectId) return res.status(400).json({ error: "Missing ID" });
+    next();
 };
 
-// =======================================================
-// 1. NEW PROJECT (Non-Blocking / Background)
-// =======================================================
-app.post('/new/project', async (req, res) => {
+/**
+ * 1. NEW PROJECT
+ * PM Creates GDD -> PM Creates Isolated Worker Prompt -> Worker Starts
+ */
+app.post('/new/project', validateRequest, async (req, res) => {
     const { userId, projectId, description } = req.body;
-    
-    if (!userId || !projectId || !description) {
-        return res.status(400).json({ error: "Missing required fields." });
-    }
 
-    // Initialize State immediately so Ping works
-    await StateManager.updateProject(projectId, { 
-        userId, 
-        status: "INITIALIZING", // Flag to track state
-        pmHistory: [], 
-        workerHistory: [] 
-    });
-
-    console.log(`[${projectId}] Request accepted. Starting Background Init...`);
-
-    // 1. Respond IMMEDIATELY to client
-    res.json({ 
-        success: true, 
-        message: "Project initialization started in background. The AI will start outputting commands shortly." 
-    });
-
-    // 2. Run Heavy AI Logic asynchronously (Fire & Forget)
-    startBackgroundInit(projectId, description).catch(err => {
-        console.error(`[${projectId}] CRITICAL INIT FAILURE:`, err);
-        // Queue an error message to the plugin console so the user knows it failed
-        StateManager.queueCommand(projectId, `print("CRITICAL AI ERROR: Project Init Failed. ${err.message}")`);
-    });
-});
+    try {
+        // 1. PM: Generate GDD
+        const pmHistory = [];
+        const gddPrompt = `Create a GDD for: ${description}`;
+        const gddResponse = await AIEngine.callPM(pmHistory, gddPrompt);
+        
+        pmHistory.push({ role: 'user', parts: [{ text: gddPrompt }] });
+        pmHistory.push({ role: 'model', parts: [{ text: gddResponse }] });
 
-// The Background Logic
-async function startBackgroundInit(projectId, description) {
-    const pmHist = [];
-    
-    // A. PM Generates GDD
-    console.log(`[${projectId}] Generating GDD...`);
-    const gdd = await AIEngine.callPM(pmHist, `New Project: ${description}. Generate a concise GDD.`);
-    pmHist.push({ role: 'user', parts: [{ text: description }] });
-    pmHist.push({ role: 'model', parts: [{ text: gdd }] });
-
-    // B. PM Generates Tasks
-    console.log(`[${projectId}] Generating Tasks...`);
-    const tasks = await AIEngine.callPM(pmHist, "Create a list of the first 3 technical tasks.");
-    
-    // C. Worker Starts Task 1 (FORCE CODE GENERATION)
-    console.log(`[${projectId}] Worker executing Task 1...`);
-    const workerHist = [];
-    
-    // We add a system instruction suffix to ensure it creates code
-    const firstPrompt = `CONTEXT:\n${gdd}\n\nTASKS:\n${tasks}\n\nINSTRUCTION:\nCreate the Script for Task 1 immediately. Output the Lua code block now. Do not talk.`;
-    
-    const code = await AIEngine.callWorker(workerHist, firstPrompt);
-    
-    workerHist.push({ role: 'user', parts: [{ text: firstPrompt }] });
-    workerHist.push({ role: 'model', parts: [{ text: code }] });
-
-    // Update State
-    await StateManager.updateProject(projectId, { 
-        pmHistory: pmHist, 
-        workerHistory: workerHist, 
-        gdd: gdd,
-        status: "ACTIVE"
-    });
-
-    // Queue the code
-    await StateManager.queueCommand(projectId, code);
-    console.log(`[${projectId}] Init Complete. First command queued.`);
-}
+        // 2. PM: Create First Isolated Task
+        // We force the PM to extract just the necessary context for Task 1
+        const taskGenPrompt = "Based on the GDD, define the first technical task. \nOutput format:\nTASK_NAME: ...\nWORKER_PROMPT: ... (Write this as a direct command to the worker. Do not include the full GDD, just the relevant specs for this task).";
+        const taskResponse = await AIEngine.callPM(pmHistory, taskGenPrompt);
+
+        pmHistory.push({ role: 'user', parts: [{ text: taskGenPrompt }] });
+        pmHistory.push({ role: 'model', parts: [{ text: taskResponse }] });
+
+        // 3. Parse PM Response to get Worker Prompt
+        const workerInstruction = extractWorkerPrompt(taskResponse) || `Initialize project structure for: ${description}`;
+
+        // 4. Initialize Worker (Fresh Scope)
+        const workerHistory = [];
+        const initialWorkerPrompt = `CONTEXT: None. \nINSTRUCTION: ${workerInstruction}`;
+        const workerResponse = await AIEngine.callWorker(workerHistory, initialWorkerPrompt);
+
+        workerHistory.push({ role: 'user', parts: [{ text: initialWorkerPrompt }] });
+        workerHistory.push({ role: 'model', parts: [{ text: workerResponse }] });
 
-// =======================================================
-// 2. FEEDBACK
-// =======================================================
+        // Save State
+        await StateManager.updateProject(projectId, {
+            userId, pmHistory, workerHistory, 
+            gdd: gddResponse, failureCount: 0
+        });
 
+        StateManager.queueCommand(projectId, workerResponse);
+        res.json({ success: true, message: "Project Started", workerInstruction });
+
+    } catch (err) {
+        console.error(err);
+        res.status(500).json({ error: "Init Failed" });
+    }
+});
+
+/**
+ * 2. FEEDBACK LOOP
+ * Handles Termination and Scope Isolation
+ */
 app.post('/project/feedback', async (req, res) => {
-    // Added 'taskComplete' to the destructured body
     const { projectId, prompt, hierarchyContext, scriptContext, logContext, taskComplete } = req.body;
     
     const project = await StateManager.getProject(projectId);
     if (!project) return res.status(404).json({ error: "Project not found." });
 
-    // 1. CHECK FOR LOOP STOPPER
+    // --- A. TASK COMPLETE: PM Assigns Next Task ---
     if (taskComplete) {
-        console.log(`[${projectId}] ✅ TASK COMPLETE. Stopping Feedback Loop.`);
+        console.log(`[${projectId}] ✅ TASK COMPLETE. Calling PM.`);
         
-        // We log it to history but DO NOT call the Worker AI
-        project.workerHistory.push({ role: 'user', parts: [{ text: "USER: Task Execution Confirmed. Logs: " + (logContext?.logs || "OK") }] });
-        await StateManager.updateProject(projectId, { workerHistory: project.workerHistory });
+        // 1. Tell PM the task is done
+        const summary = `Worker completed the task. Logs: ${logContext?.logs || "Clean"}. Generate the NEXT task. \nREMEMBER: Output 'WORKER_PROMPT: ...' with isolated instructions.`;
         
-        return res.json({ success: true, message: "Loop Stopped. Waiting for new instructions." });
-    }
+        const pmResponse = await AIEngine.callPM(project.pmHistory, summary);
+        project.pmHistory.push({ role: 'user', parts: [{ text: summary }] });
+        project.pmHistory.push({ role: 'model', parts: [{ text: pmResponse }] });
 
-    // 2. ERROR DETECTION (Safety Net)
-    let isFailure = false;
-    if (logContext && logContext.logs) {
-        const errorKeywords = ["Infinite yield", "Stack Begin", "Error:", "Exception", "failed"];
-        if (errorKeywords.some(keyword => logContext.logs.includes(keyword))) {
-            isFailure = true;
-            console.log(`[${projectId}] ⚠️ Detected Error in Logs.`);
+        // 2. Parse new instruction
+        const nextWorkerInstruction = extractWorkerPrompt(pmResponse);
+
+        if (!nextWorkerInstruction) {
+             // PM thinks project is done or failed to format
+             await StateManager.updateProject(projectId, { pmHistory: project.pmHistory, status: "IDLE" });
+             return res.json({ success: true, message: "Project Idle/Finished." });
         }
-    }
 
-    // 3. BUILD AI PROMPT
-    const fullInput = `USER: ${prompt || "Automatic Feedback"}` + formatContext({ hierarchyContext, scriptContext, logContext });
-    
-    let finalPrompt = fullInput;
-    if (isFailure && (!prompt || prompt.length < 5)) {
-        finalPrompt += "\n[SYSTEM ALERT]: The logs indicate a Runtime Error or Infinite Yield. Fix the code immediately. Do not use WaitForChild.";
+        // 3. NUKE WORKER (Scope Isolation)
+        // We clear history and give the new standalone prompt
+        console.log(`[${projectId}] 🧹 Nuking Worker for next task...`);
+        const newWorkerHistory = [];
+        const newPrompt = `New Objective: ${nextWorkerInstruction}`;
+        
+        const workerResponse = await AIEngine.callWorker(newWorkerHistory, newPrompt);
+        newWorkerHistory.push({ role: 'user', parts: [{ text: newPrompt }] });
+        newWorkerHistory.push({ role: 'model', parts: [{ text: workerResponse }] });
+
+        await StateManager.updateProject(projectId, {
+            pmHistory: project.pmHistory,
+            workerHistory: newWorkerHistory,
+            failureCount: 0
+        });
+
+        // Send Clean Console command + Code
+        StateManager.queueCommand(projectId, "CLEAR_CONSOLE"); 
+        StateManager.queueCommand(projectId, workerResponse);
+
+        return res.json({ success: true, message: "Next Task Assigned" });
     }
 
-    console.log(`[${projectId}] Processing Feedback...`);
+    // --- B. ERROR HANDLING & PM INTERVENTION ---
+    let isFailure = false;
+    if (logContext?.logs && ["Error", "Exception", "failed"].some(k => logContext.logs.includes(k))) {
+        isFailure = true;
+        project.failureCount = (project.failureCount || 0) + 1;
+    }
 
-    // 4. CALL AI (Continue Loop)
-    try {
-        const response = await AIEngine.callWorker(project.workerHistory, finalPrompt);
+    // Standard Feedback Context
+    const fullInput = `USER: ${prompt || "Auto-Feedback"}` + formatContext({ hierarchyContext, scriptContext, logContext });
+    
+    // Check for Escalation (Failure > 2)
+    if (project.failureCount > 2) {
+        console.log(`[${projectId}] 🚨 Escalating to PM...`);
         
-        // Check Escalation
-        if (response.includes("STATUS: ESCALATE_TO_PM") || (project.failureCount > 2)) {
-            console.log(`[${projectId}] Escalating to PM...`);
-            const guidance = await AIEngine.callPM(project.pmHistory, `Worker Stuck. Input: ${fullInput}`);
-            const fixed = await AIEngine.callWorker(project.workerHistory, `PM GUIDANCE: ${guidance}`);
+        // Ask PM for judgment
+        const pmGuidancePrompt = sysPrompts.pm_guidance_prompt.replace('{{LOGS}}', logContext?.logs);
+        const pmVerdict = await AIEngine.callPM(project.pmHistory, pmGuidancePrompt);
+
+        // CHECK FOR TERMINATION ORDER
+        if (pmVerdict.includes("[TERMINATE]")) {
+            console.log(`[${projectId}] 💀 PM Ordered Termination.`);
+            
+            // Extract the fix from PM's verdict to use as the new 'Initial Prompt'
+            const fixInstruction = pmVerdict.replace("[TERMINATE]", "").trim();
+            
+            // Reset Worker completely
+            const resetHistory = [];
+            const resetPrompt = `[SYSTEM]: You were terminated for incompetence. \nNew Objective: ${fixInstruction}`;
+            
+            const workerResp = await AIEngine.callWorker(resetHistory, resetPrompt);
+            resetHistory.push({ role: 'user', parts: [{ text: resetPrompt }] });
+            resetHistory.push({ role: 'model', parts: [{ text: workerResp }] });
+
+            await StateManager.updateProject(projectId, {
+                workerHistory: resetHistory,
+                failureCount: 0
+            });
+            
+            StateManager.queueCommand(projectId, "CLEAR_CONSOLE");
+            StateManager.queueCommand(projectId, workerResp);
+            return res.json({ success: true, message: "Worker Terminated & Replaced." });
+        } else {
+            // Standard PM Guidance (Injection)
+            const injection = `[PM GUIDANCE]: ${pmVerdict} \n\nFix your code immediately.`;
+            const workerResp = await AIEngine.callWorker(project.workerHistory, injection);
             
-            await StateManager.updateProject(projectId, { failureCount: 0 });
-            project.workerHistory.push({ role: 'user', parts: [{ text: fullInput }] });
-            project.workerHistory.push({ role: 'model', parts: [{ text: fixed }] });
-            await StateManager.queueCommand(projectId, fixed);
-            return res.json({ success: true, message: "Escalated & Fixed." });
+            project.workerHistory.push({ role: 'user', parts: [{ text: injection }] });
+            project.workerHistory.push({ role: 'model', parts: [{ text: workerResp }] });
+            
+            await StateManager.updateProject(projectId, { workerHistory: project.workerHistory, failureCount: 0 }); // Reset count after help
+            await StateManager.queueCommand(projectId, workerResp);
+            return res.json({ success: true, message: "PM Guidance Sent." });
         }
+    }
 
+    // --- C. STANDARD LOOP (Worker iterates) ---
+    try {
+        const response = await AIEngine.callWorker(project.workerHistory, fullInput);
         project.workerHistory.push({ role: 'user', parts: [{ text: fullInput }] });
         project.workerHistory.push({ role: 'model', parts: [{ text: response }] });
-        await StateManager.updateProject(projectId, { workerHistory: project.workerHistory });
+        
+        await StateManager.updateProject(projectId, { 
+            workerHistory: project.workerHistory,
+            failureCount: project.failureCount 
+        });
+        
         await StateManager.queueCommand(projectId, response);
-
-        res.json({ success: true, message: "Input Processed." });
+        res.json({ success: true });
 
     } catch (err) {
-        console.error("AI Error:", err);
+        console.error(err);
         res.status(500).json({ error: "AI Failed" });
     }
 });
-;
+
+// --- HUMAN OVERRIDE (Preserved) ---
+app.post('/human/override', validateRequest, async (req, res) => {
+    const { projectId, instruction, pruneHistory } = req.body;
+    const project = await StateManager.getProject(projectId);
     
-// =======================================================
-// 3. INTERNAL / PING
-// =======================================================
-app.post('/project/ping', async (req, res) => {
-    const { projectId } = req.body;
+    const overrideMsg = `[SYSTEM OVERRIDE]: ${instruction}`;
     
-    // We check project existence here to avoid crashing on random pings
-    const project = await StateManager.getProject(projectId);
-    if (!project) return res.json({ action: "IDLE" });
+    // If we prune, we remove the last error context so the AI isn't confused
+    if (pruneHistory && project.workerHistory.length > 2) {
+        project.workerHistory = project.workerHistory.slice(0, -2);
+    }
 
-    const command = await StateManager.popCommand(projectId);
+    const response = await AIEngine.callWorker(project.workerHistory, overrideMsg);
+    project.workerHistory.push({ role: 'user', parts: [{ text: overrideMsg }] });
+    project.workerHistory.push({ role: 'model', parts: [{ text: response }] });
 
-    if (command) {
-        // Parse raw command string into specific actions for the plugin
-        let action = command.type; // EXECUTE, READ_SCRIPT, etc.
-        let target = command.payload;
-        let code = (command.type === 'EXECUTE') ? command.payload : null;
+    await StateManager.updateProject(projectId, { workerHistory: project.workerHistory });
+    await StateManager.queueCommand(projectId, response);
+    res.json({ success: true });
+});
 
-        res.json({ action, target, code });
+app.post('/project/ping', async (req, res) => {
+    const { projectId } = req.body;
+    const command = await StateManager.popCommand(projectId);
+    if (command) {
+        // If the command string is exactly "CLEAR_CONSOLE", send special action
+        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" });
     }
 });
 
-// Direct PM Intervention Endpoint
-app.post('/internal/ping/pm', async (req, res) => {
-    const { projectId, distressMessage } = req.body;
-    const project = await StateManager.getProject(projectId);
-    
-    if(!project) return res.status(404).json({error: "Project not found"});
-
-    console.log(`[${projectId}] Direct PM Intervention: ${distressMessage}`);
+// Helper to extract "WORKER_PROMPT:" from PM text
+function extractWorkerPrompt(text) {
+    const match = text.match(/WORKER_PROMPT:\s*(.*)/s);
+    return match ? match[1].trim() : null;
+}
 
-    // PM analyzes distress
-    const pmResponse = await AIEngine.callPM(project.pmHistory, `DIRECT INTERVENTION: ${distressMessage}. Provide solution.`);
-    
-    // Guide worker
-    const workerResp = await AIEngine.callWorker(project.workerHistory, `PM INTERVENTION: ${pmResponse}`);
-    
-    project.workerHistory.push({ role: 'model', parts: [{ text: workerResp }] });
-    await StateManager.updateProject(projectId, { workerHistory: project.workerHistory });
-    await StateManager.queueCommand(projectId, workerResp);
-    
-    res.json({ success: true, message: "PM Intervened." });
-});
+function formatContext({ hierarchyContext, scriptContext, logContext }) {
+    let out = "";
+    if (scriptContext) out += `\n[SCRIPT]: ${scriptContext.targetName}`;
+    if (logContext) out += `\n[LOGS]: ${logContext.logs}`;
+    return out;
+}
 
-app.listen(PORT, () => console.log(`🚀 AI Server running on port ${PORT}`));
+app.listen(PORT, () => { console.log(`Backend Running on ${PORT}`); });