Update app.js

app.js

@@ -1,235 +1,175 @@
-// server.js
 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 || 7860;
-
-// Load prompts for dynamic usage
-const sysPrompts = JSON.parse(fs.readFileSync('./prompts.json', 'utf8'));
-
 app.use(cors());
-app.use(bodyParser.json({ limit: '50mb' })); // Increased limit for images
+app.use(bodyParser.json({ limit: '50mb' }));
+const PORT = process.env.PORT || 7860;
 
-// 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();
+// 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;
 };
 
-/**
- * 1. NEW PROJECT
- * Flow: PM (GDD) -> PM (Tasks) -> Worker (Task 1)
- */
-app.post('/new/project', validateRequest, async (req, res) => {
+// =======================================================
+// 1. NEW PROJECT (Non-Blocking / Background)
+// =======================================================
+app.post('/new/project', async (req, res) => {
     const { userId, projectId, description } = req.body;
+    
+    if (!userId || !projectId || !description) {
+        return res.status(400).json({ error: "Missing required fields." });
+    }
 
-    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 }] });
+    // Initialize State immediately so Ping works
+    await StateManager.updateProject(projectId, { 
+        userId, 
+        status: "INITIALIZING", // Flag to track state
+        pmHistory: [], 
+        workerHistory: [] 
+    });
 
-        // 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);
+    console.log(`[${projectId}] Request accepted. Starting Background Init...`);
 
-        workerHistory.push({ role: 'user', parts: [{ text: initialWorkerPrompt }] });
-        workerHistory.push({ role: 'model', parts: [{ text: workerResponse }] });
+    // 1. Respond IMMEDIATELY to client
+    res.json({ 
+        success: true, 
+        message: "Project initialization started in background. The AI will start outputting commands shortly." 
+    });
 
-        // Save State
-        await StateManager.updateProject(projectId, {
-            userId,
-            pmHistory,
-            workerHistory,
-            gdd: gddResponse,
-            failureCount: 0
-        });
+    // 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}")`);
+    });
+});
 
-        // Queue the result for the plugin
-        StateManager.queueCommand(projectId, workerResponse);
+// 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 GDD.`);
+    pmHist.push({ role: 'user', parts: [{ text: description }] });
+    pmHist.push({ role: 'model', parts: [{ text: gdd }] });
+
+    // B. PM Generates First Task
+    console.log(`[${projectId}] Generating Tasks...`);
+    const tasks = await AIEngine.callPM(pmHist, "Create a JSON list of the first 3 technical tasks.");
+    
+    // C. Worker Starts Task 1
+    console.log(`[${projectId}] Worker executing Task 1...`);
+    const workerHist = [];
+    const firstPrompt = `GDD: ${gdd}\nTasks: ${tasks}\n\nStart Task 1.`;
+    const code = await AIEngine.callWorker(workerHist, firstPrompt);
+    
+    workerHist.push({ role: 'user', parts: [{ text: firstPrompt }] });
+    workerHist.push({ role: 'model', parts: [{ text: code }] });
 
-        res.json({ success: true, message: "Project initialized", gddPreview: gddResponse.substring(0, 200) });
+    // Update State
+    await StateManager.updateProject(projectId, { 
+        pmHistory: pmHist, 
+        workerHistory: workerHist, 
+        gdd: gdd,
+        status: "ACTIVE"
+    });
 
-    } catch (err) {
-        console.error(err);
-        res.status(500).json({ error: "AI Processing Failed" });
-    }
-});
+    // Queue the code for the plugin
+    await StateManager.queueCommand(projectId, code);
+    console.log(`[${projectId}] Init Complete. First command queued.`);
+}
 
-/**
- * 2. FEEDBACK (The Main Loop Endpoint)
- * Accepts text + optional image. Hits Worker. Checks for escalation.
- */
+// =======================================================
+// 2. FEEDBACK
+// =======================================================
 app.post('/project/feedback', async (req, res) => {
     const { projectId, prompt, hierarchyContext, scriptContext, logContext } = req.body;
     
     const project = await StateManager.getProject(projectId);
-    if (!project) return res.status(404).json({ error: "Project not found." });
+    if (!project) return res.status(404).json({ error: "Project not found. Run /new/project first." });
 
-    // Build Context String based on what was sent
-    let contextStr = "";
-    if (prompt) contextStr += `USER: ${prompt}\n`;
-    
-    // If Plugin sent Hierarchy
-    if (hierarchyContext) {
-        contextStr += `[SYSTEM] HIERARCHY SCAN (${hierarchyContext.rootName}):\n${hierarchyContext.tree}\n`;
-    }
-    // If Plugin sent Script Source
-    if (scriptContext) {
-        contextStr += `[SYSTEM] SCRIPT SOURCE (${scriptContext.targetName}):\n${scriptContext.scriptSource}\n`;
-    }
-    // If Plugin sent Logs
-    if (logContext) {
-        contextStr += `[SYSTEM] CONSOLE LOGS:\n${logContext.logs}\n`;
-    }
+    const fullInput = `USER: ${prompt || "Automatic Feedback"}` + formatContext({ hierarchyContext, scriptContext, logContext });
 
-    console.log(`[${projectId}] Input Received. Processing...`);
+    console.log(`[${projectId}] Feedback received. Processing...`);
 
     // Call Worker
-    const response = await AIEngine.callWorker(project.workerHistory, contextStr);
+    const response = await AIEngine.callWorker(project.workerHistory, fullInput);
     
-    // Standard History Update
-    project.workerHistory.push({ role: 'user', parts: [{ text: contextStr }] });
+    // 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}`);
+        
+        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." });
+    }
+
+    // Normal Success
+    project.workerHistory.push({ role: 'user', parts: [{ text: fullInput }] });
     project.workerHistory.push({ role: 'model', parts: [{ text: response }] });
     await StateManager.updateProject(projectId, { workerHistory: project.workerHistory });
-    
-    // Parse and Queue the next move (Execute code or Fetch more info)
     await StateManager.queueCommand(projectId, response);
 
-    res.json({ success: true, message: "Context received. Worker processing." });
+    res.json({ success: true, message: "Input Processed." });
 });
 
-/**
- * 3. INTERNAL PING WORKER
- * PM sends guidance to Worker.
- */
-app.post('/internal/ping/worker', validateRequest, async (req, res) => {
-    const { projectId, guidancePrompt } = req.body;
+// =======================================================
+// 3. INTERNAL / PING
+// =======================================================
+app.post('/project/ping', async (req, res) => {
+    const { projectId } = req.body;
+    
+    // We check project existence here to avoid crashing on random pings
     const project = await StateManager.getProject(projectId);
-    if (!project) return res.status(404).json({ error: "Project not found" });
+    if (!project) return res.json({ action: "IDLE" });
 
-    // Inject PM Context (GDD/History) into the message if requested
-    const fullContextPrompt = `PM CONTEXT: ${JSON.stringify(project.pmHistory)}. \n GUIDANCE: ${guidancePrompt}`;
+    const command = await StateManager.popCommand(projectId);
 
-    const response = await AIEngine.callWorker(project.workerHistory, fullContextPrompt);
-    StateManager.queueCommand(projectId, response);
-    
-    res.json({ success: true, message: "Guidance sent to Worker" });
-});
+    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;
 
-/**
- * 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 });
+        res.json({ action, target, code });
     } else {
-        // Just guide
-        const workerResp = await AIEngine.callWorker(project.workerHistory, `PM FIX: ${pmResponse}`);
-        StateManager.queueCommand(projectId, workerResp);
-        res.json({ action: "GUIDANCE", guidance: pmResponse });
+        res.json({ action: "IDLE" });
     }
 });
 
-/**
- * 5. PROJECT RESET
- * Resets the worker thread completely.
- */
-app.post('/project/reset', validateRequest, async (req, res) => {
-    const { projectId } = req.body;
+// Direct PM Intervention Endpoint
+app.post('/internal/ping/pm', async (req, res) => {
+    const { projectId, distressMessage } = 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" });
-    }
-
-    // Pop the oldest command
-    const command = project.commandQueue.shift();
-    await StateManager.updateProject(projectId, { commandQueue: project.commandQueue });
+    if(!project) return res.status(404).json({error: "Project not found"});
 
-    // 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
-    });
-});
-*/
-
-/**
- * 7. INACTIVITY CLEANUP
- */
-app.delete('/internal/cleanup', async (req, res) => {
-    const count = StateManager.cleanupInactivity();
-    res.json({ success: true, removed: count });
-});
-
-app.post('/project/ping', async (req, res) => {
-    const { projectId } = req.body;
-    const command = await StateManager.popCommand(projectId);
+    console.log(`[${projectId}] Direct PM Intervention: ${distressMessage}`);
 
-    if (command) {
-        // Sends: { action: "EXECUTE", target: "...", code: "..." }
-        res.json({ 
-            action: command.type, 
-            target: command.payload, 
-            code: command.type === 'EXECUTE' ? command.payload : null 
-        });
-    } else {
-        res.json({ action: "IDLE" });
-    }
+    // 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." });
 });
 
-app.listen(PORT, () => {
-    console.log(`AI Builder Backend running on port ${PORT}`);
-});
+app.listen(PORT, () => console.log(`🚀 AI Server running on port ${PORT}`));