Update app.js

app.js

@@ -20,59 +20,76 @@ const validateRequest = (req, res, next) => {
     next();
 };
 
+// Helper to extract PM's isolated instruction
+function extractWorkerPrompt(text) {
+    const match = text.match(/WORKER_PROMPT:\s*(.*)/s);
+    return match ? match[1].trim() : null;
+}
+
+// Helper to format context for the AI
+function formatContext({ hierarchyContext, scriptContext, logContext }) {
+    let out = "";
+    if (scriptContext) out += `\n[TARGET SCRIPT]: ${scriptContext.targetName}\n[SOURCE PREVIEW]: ${scriptContext.scriptSource.substring(0, 500)}...`;
+    if (logContext) out += `\n[LAST LOGS]: ${logContext.logs}`;
+    return out;
+}
+
 /**
- * 1. NEW PROJECT
- * PM Creates GDD -> PM Creates Isolated Worker Prompt -> Worker Starts
+ * 1. NEW PROJECT (Restored Full Logic)
+ * Flow: PM (GDD) -> PM (Tasks) -> Worker (Task 1 Isolated)
  */
 app.post('/new/project', validateRequest, async (req, res) => {
     const { userId, projectId, description } = req.body;
 
     try {
-        // 1. PM: Generate GDD
+        // 1. Generate GDD
         const pmHistory = [];
-        const gddPrompt = `Create a GDD for: ${description}`;
+        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. 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);
+        // 2. Generate Initial Task List & Extract First Prompt
+        const taskPrompt = "Based on the GDD, generate the first technical milestone.\nOutput format:\nTASK_NAME: <Name>\nWORKER_PROMPT: <Specific, isolated instructions for the worker>";
+        const taskResponse = await AIEngine.callPM(pmHistory, taskPrompt);
 
-        pmHistory.push({ role: 'user', parts: [{ text: taskGenPrompt }] });
+        pmHistory.push({ role: 'user', parts: [{ text: taskPrompt }] });
         pmHistory.push({ role: 'model', parts: [{ text: taskResponse }] });
 
-        // 3. Parse PM Response to get Worker Prompt
-        const workerInstruction = extractWorkerPrompt(taskResponse) || `Initialize project structure for: ${description}`;
+        // 3. Extract the Isolated Prompt
+        const initialWorkerInstruction = extractWorkerPrompt(taskResponse) || `Initialize structure for: ${description}`;
 
         // 4. Initialize Worker (Fresh Scope)
         const workerHistory = [];
-        const initialWorkerPrompt = `CONTEXT: None. \nINSTRUCTION: ${workerInstruction}`;
+        const initialWorkerPrompt = `CONTEXT: None (New Project). \nINSTRUCTION: ${initialWorkerInstruction}`;
         const workerResponse = await AIEngine.callWorker(workerHistory, initialWorkerPrompt);
 
         workerHistory.push({ role: 'user', parts: [{ text: initialWorkerPrompt }] });
         workerHistory.push({ role: 'model', parts: [{ text: workerResponse }] });
 
-        // Save State
+        // 5. Save State
         await StateManager.updateProject(projectId, {
-            userId, pmHistory, workerHistory, 
-            gdd: gddResponse, failureCount: 0
+            userId,
+            pmHistory,
+            workerHistory,
+            gdd: gddResponse,
+            failureCount: 0
         });
 
+        // Queue for Plugin
         StateManager.queueCommand(projectId, workerResponse);
-        res.json({ success: true, message: "Project Started", workerInstruction });
+
+        res.json({ success: true, message: "Project Initialized", gddPreview: gddResponse.substring(0, 200) });
 
     } catch (err) {
         console.error(err);
-        res.status(500).json({ error: "Init Failed" });
+        res.status(500).json({ error: "Initialization Failed" });
     }
 });
 
 /**
- * 2. FEEDBACK LOOP
- * Handles Termination and Scope Isolation
+ * 2. FEEDBACK LOOP (Restored Escalation & Termination)
  */
 app.post('/project/feedback', async (req, res) => {
     const { projectId, prompt, hierarchyContext, scriptContext, logContext, taskComplete } = req.body;
@@ -80,33 +97,32 @@ 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: PM Assigns Next Task ---
+    // ==========================================
+    // A. TASK COMPLETE -> SCOPE SWITCH
+    // ==========================================
     if (taskComplete) {
-        console.log(`[${projectId}] ✅ TASK COMPLETE. Calling PM.`);
-        
-        // 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.`;
+        console.log(`[${projectId}] ✅ TASK COMPLETE.`);
         
+        // 1. Report to PM
+        const summary = `Worker completed the previous task. Logs: ${logContext?.logs || "Clean"}. \nGenerate the NEXT task using 'WORKER_PROMPT:' format.`;
         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. Parse new instruction
-        const nextWorkerInstruction = extractWorkerPrompt(pmResponse);
-
-        if (!nextWorkerInstruction) {
-             // PM thinks project is done or failed to format
+        // 2. Get Next Instruction
+        const nextInstruction = extractWorkerPrompt(pmResponse);
+        if (!nextInstruction) {
              await StateManager.updateProject(projectId, { pmHistory: project.pmHistory, status: "IDLE" });
-             return res.json({ success: true, message: "Project Idle/Finished." });
+             return res.json({ success: true, message: "No further tasks generated. Project Idle." });
         }
 
-        // 3. NUKE WORKER (Scope Isolation)
-        // We clear history and give the new standalone prompt
-        console.log(`[${projectId}] 🧹 Nuking Worker for next task...`);
+        // 3. NUKE WORKER (Scope Reset)
+        console.log(`[${projectId}] 🧹 Nuking Worker for next task.`);
         const newWorkerHistory = [];
-        const newPrompt = `New Objective: ${nextWorkerInstruction}`;
-        
+        const newPrompt = `New Objective: ${nextInstruction}`;
         const workerResponse = await AIEngine.callWorker(newWorkerHistory, newPrompt);
+
         newWorkerHistory.push({ role: 'user', parts: [{ text: newPrompt }] });
         newWorkerHistory.push({ role: 'model', parts: [{ text: workerResponse }] });
 
@@ -116,71 +132,79 @@ app.post('/project/feedback', async (req, res) => {
             failureCount: 0
         });
 
-        // Send Clean Console command + Code
+        // Clear Console Command + New Code
         StateManager.queueCommand(projectId, "CLEAR_CONSOLE"); 
         StateManager.queueCommand(projectId, workerResponse);
 
         return res.json({ success: true, message: "Next Task Assigned" });
     }
 
-    // --- B. ERROR HANDLING & PM INTERVENTION ---
+    // ==========================================
+    // B. ERROR HANDLING & ESCALATION
+    // ==========================================
     let isFailure = false;
-    if (logContext?.logs && ["Error", "Exception", "failed"].some(k => logContext.logs.includes(k))) {
-        isFailure = true;
-        project.failureCount = (project.failureCount || 0) + 1;
+    if (logContext?.logs) {
+        const errs = ["Error", "Exception", "failed", "Stack Begin"];
+        if (errs.some(k => logContext.logs.includes(k))) {
+            isFailure = true;
+            project.failureCount = (project.failureCount || 0) + 1;
+        }
     }
 
-    // Standard Feedback Context
-    const fullInput = `USER: ${prompt || "Auto-Feedback"}` + formatContext({ hierarchyContext, scriptContext, logContext });
-    
-    // Check for Escalation (Failure > 2)
+    // Prepare Prompt
+    const fullInput = `USER: ${prompt || "Automatic Feedback"}` + formatContext({ hierarchyContext, scriptContext, logContext });
+
+    // --- ESCALATION LOGIC (Restored) ---
     if (project.failureCount > 2) {
-        console.log(`[${projectId}] 🚨 Escalating to PM...`);
+        console.log(`[${projectId}] 🚨 Escalating to PM (Failures: ${project.failureCount})...`);
         
-        // Ask PM for judgment
-        const pmGuidancePrompt = sysPrompts.pm_guidance_prompt.replace('{{LOGS}}', logContext?.logs);
-        const pmVerdict = await AIEngine.callPM(project.pmHistory, pmGuidancePrompt);
+        // 1. Ask PM for solution
+        const pmPrompt = sysPrompts.pm_guidance_prompt.replace('{{LOGS}}', logContext?.logs);
+        const pmVerdict = await AIEngine.callPM(project.pmHistory, pmPrompt);
 
-        // CHECK FOR TERMINATION ORDER
+        // 2. CHECK: Did PM order termination?
         if (pmVerdict.includes("[TERMINATE]")) {
-            console.log(`[${projectId}] 💀 PM Ordered Termination.`);
+            console.log(`[${projectId}] 💀 PM TERMINATED WORKER.`);
             
-            // Extract the fix from PM's verdict to use as the new 'Initial Prompt'
             const fixInstruction = pmVerdict.replace("[TERMINATE]", "").trim();
             
-            // Reset Worker completely
+            // Hard Reset
             const resetHistory = [];
-            const resetPrompt = `[SYSTEM]: You were terminated for incompetence. \nNew Objective: ${fixInstruction}`;
-            
+            const resetPrompt = `[SYSTEM]: Previous worker terminated. \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
-            });
-            
+            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.`;
+        } 
+        else {
+            // 3. Just Guidance (Soft Fix)
+            console.log(`[${projectId}] 💡 PM Provided Guidance.`);
+            const injection = `[PM GUIDANCE]: ${pmVerdict} \n\nApply this fix now.`;
             const workerResp = await AIEngine.callWorker(project.workerHistory, injection);
             
             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
+            // Reset count slightly so we don't spam PM, but keep watch
+            await StateManager.updateProject(projectId, { workerHistory: project.workerHistory, failureCount: 0 });
             await StateManager.queueCommand(projectId, workerResp);
-            return res.json({ success: true, message: "PM Guidance Sent." });
+            
+            return res.json({ success: true, message: "PM Guidance Applied." });
         }
     }
 
-    // --- C. STANDARD LOOP (Worker iterates) ---
+    // ==========================================
+    // C. STANDARD WORKER LOOP
+    // ==========================================
     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 }] });
         
@@ -193,21 +217,24 @@ app.post('/project/feedback', async (req, res) => {
         res.json({ success: true });
 
     } catch (err) {
-        console.error(err);
+        console.error("AI Error:", err);
         res.status(500).json({ error: "AI Failed" });
     }
 });
 
-// --- HUMAN OVERRIDE (Preserved) ---
+/**
+ * 3. HUMAN OVERRIDE (God Mode)
+ */
 app.post('/human/override', validateRequest, async (req, res) => {
     const { projectId, instruction, pruneHistory } = req.body;
     const project = await StateManager.getProject(projectId);
     
     const overrideMsg = `[SYSTEM OVERRIDE]: ${instruction}`;
     
-    // 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);
+    // Optional: Prune the argument if they are stuck
+    if (pruneHistory && project.workerHistory.length >= 2) {
+        project.workerHistory.pop(); // last model
+        project.workerHistory.pop(); // last user
     }
 
     const response = await AIEngine.callWorker(project.workerHistory, overrideMsg);
@@ -216,16 +243,40 @@ app.post('/human/override', validateRequest, async (req, res) => {
 
     await StateManager.updateProject(projectId, { workerHistory: project.workerHistory });
     await StateManager.queueCommand(projectId, response);
-    res.json({ success: true });
+    res.json({ success: true, message: "Override Executed" });
+});
+
+/**
+ * 4. WORKER KILL (Manual Reassignment)
+ */
+app.post('/worker/kill', validateRequest, async (req, res) => {
+    const { projectId } = req.body;
+    // Logic: Just reset the history with a "Try again" prompt
+    const project = await StateManager.getProject(projectId);
+    
+    const rebootPrompt = "[SYSTEM]: Worker process restarted. Attempt the task again from scratch.";
+    const response = await AIEngine.callWorker([{ role: 'user', parts: [{ text: rebootPrompt }] }], rebootPrompt);
+    
+    await StateManager.updateProject(projectId, {
+        workerHistory: [{ role: 'user', parts: [{ text: rebootPrompt }] }], // Nuke history
+        workerHistory: [{ role: 'model', parts: [{ text: response }] }],
+        failureCount: 0
+    });
+    
+    StateManager.queueCommand(projectId, response);
+    res.json({ success: true, message: "Worker Killed & Restarted" });
 });
 
+/**
+ * 5. PING (Plugin Polling)
+ */
 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" });
+             res.json({ action: "CLEAR_LOGS" });
         } else {
             res.json({ 
                 action: command.type, 
@@ -238,17 +289,6 @@ app.post('/project/ping', async (req, res) => {
     }
 });
 
-// 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;
-}
-
-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(`Backend Running on ${PORT}`); });
+app.listen(PORT, () => {
+    console.log(`AI Backend Running on ${PORT}`);
+});