Update app.js

app.js

@@ -1,137 +1,166 @@
 import express from 'express';
+import bodyParser from 'body-parser';
 import cors from 'cors';
+import { StateManager, initDB } from './stateManager.js'; 
+import { AIEngine } from './aiEngine.js';
+import crypto from "crypto";
 import dotenv from 'dotenv';
-import OpenAI from "openai";
-import { BedrockRuntimeClient, ConverseCommand, ConverseStreamCommand } from "@aws-sdk/client-bedrock-runtime";
-import { NodeHttpHandler } from "@smithy/node-http-handler";
 
 dotenv.config();
+initDB();
+const supabase = StateManager.getSupabaseClient(); 
 const app = express();
 const PORT = process.env.PORT || 7860;
-
 app.use(cors());
-app.use(express.json({ limit: '50mb' }));
+app.use(bodyParser.json({ limit: '50mb' }));
 
-// --- SYSTEM PROMPT DEFINITIONS ---
-const CLAUDE_SYSTEM_PROMPT = "You are a pro. Provide elite, high-level technical responses.";
-const GPT_SYSTEM_PROMPT = "You are a worker. Be concise, efficient, and get the job done.";
+const WORKER_PHASES = ["Worker: Analyzing Request...", "Worker: Reading Context...", "Worker: Checking Hierarchy...", "Worker: Thinking..."];
+const PM_PHASES = ["Manager: Reviewing...", "Manager: Formulating Strategy...", "Manager: Delegating...", "Manager: Thinking..."];
 
-const bedrockClient = new BedrockRuntimeClient({
-    region: "us-east-1" ,
-   requestHandler: new NodeHttpHandler({
-        http2Handler: undefined, 
-    }) 
-});
+function startStatusLoop(projectId, type = 'worker') {
+    const phases = type === 'pm' ? PM_PHASES : WORKER_PHASES;
+    let index = 0;
+    StateManager.setStatus(projectId, phases[0]);
+    const interval = setInterval(() => {
+        index++;
+        if (index < phases.length) StateManager.setStatus(projectId, phases[index]);
+        else clearInterval(interval);
+    }, 1500); 
+    return () => clearInterval(interval);
+}
 
-const azureOpenAI = new OpenAI({
-    apiKey: "7U3m9NRkE38ThSWTr92hMgQ4hDCUFI9MAnFNrCgRL7MhdvckfTXwJQQJ99CBACHYHv6XJ3w3AAAAACOGV22P",
-    baseURL: `https://hollowpad-resource.cognitiveservices.azure.com/openai/deployments/gpt-5-mini`,
-    defaultQuery: { "api-version": "2024-05-01-preview" },
-    defaultHeaders: { "api-key": "7U3m9NRkE38ThSWTr92hMgQ4hDCUFI9MAnFNrCgRL7MhdvckfTXwJQQJ99CBACHYHv6XJ3w3AAAAACOGV22P" }
-});
+async function checkMinimumCredits(userId, type = 'basic') {
+    const { data } = await supabase.from('users').select('credits').eq('id', userId).single();
+    const credits = data?.credits?.[type] || 0;
+    if (credits < 50) throw new Error(`Insufficient ${type} credits.`);
+}
 
-// Standard Generation
-app.post('/api/generate', async (req, res) => {
-    const { model, prompt, system_prompt} = req.body;
+async function deductUserCredits(userId, amount, type = 'basic') {
     try {
-        if (model === "claude") {
-            const command = new ConverseCommand({
-                modelId: "arn:aws:bedrock:us-east-1:106774395747:inference-profile/global.anthropic.claude-sonnet-4-6",
-                system: [{ text: system_prompt || CLAUDE_SYSTEM_PROMPT }], 
-                messages: [{ role: "user", content: [{ text: prompt }] }],
-                inferenceConfig: { maxTokens: 48000, temperature: 1 },
-                additionalModelRequestFields: { 
-                    thinking: { type: "adaptive" },
-                    output_config: { effort: "high" }
-                }
-            });
-            const response = await bedrockClient.send(command);
-            const text = response.output.message.content.find(b => b.text)?.text;
-            res.json({ success: true, data: text });
-        } else {
-            const response = await azureOpenAI.chat.completions.create({
-                model: "gpt-5-mini",
-                messages: [
-                    { role: "system", content: system_prompt || GPT_SYSTEM_PROMPT },
-                    { role: "user", content: prompt }
-                ],
-                reasoning_effort: "high"
-            });
-            res.json({ success: true, data: response.choices[0].message.content });
-        }
-    } catch (err) {
-        console.error(`❌ [${model.toUpperCase()} ERROR]:`, err.message);
-        res.status(500).json({ success: false, error: err.message });
-    }
-});
+        const { data } = await supabase.from('users').select('credits').eq('id', userId).single();
+        const newVal = Math.max(0, (data?.credits?.[type] || 0) - amount);
+        await supabase.from('users').update({ credits: { ...data.credits, [type]: newVal } }).eq('id', userId);
+    } catch (e) { console.error("Credit Error:", e.message); }
+}
 
-// Streaming Generation
-app.post('/api/stream', async (req, res) => {
-    const { model, prompt, system_prompt, images } = req.body;
-    console.log(`[STREAM] Request for ${model}`);
+const formatContext = ({ hierarchyContext, scriptContext, logContext }) => {
+    let out = "";
+    if (scriptContext) out += `\n[SCRIPT]: ${scriptContext.targetName}\n[SOURCE]: ${scriptContext.scriptSource}`;
+    if (logContext) out += `\n[LOGS]: ${logContext.logs}`;
+    if (hierarchyContext) out += `\n[HIERARCHY]: ${hierarchyContext}`;
+    return out;
+};
 
-    res.setHeader('Content-Type', 'text/plain; charset=utf-8');
-    res.setHeader('Transfer-Encoding', 'chunked');
-    res.setHeader('X-Accel-Buffering', 'no'); 
-    res.flushHeaders();
+const extractTags = (text) => ({
+    pmQuestion: text.match(/\[ASK_PM:\s*(.*?)\]/s)?.[1],
+    pmRoute: text.match(/\[ROUTE_TO_PM:\s*(.*?)\]/s)?.[1],
+    workerPrompt: text.match(/WORKER_PROMPT:\s*(.*)/s)?.[1]
+});
 
+async function runAsyncFeedback(projectId, userId, fullInput, images = []) {
     try {
-        if (model === "claude") {
-            let contentBlock = [{ text: prompt }];
-            if (images && images.length > 0) {
-                const imageBlocks = images.map(imgStr => {
-                    const base64Data = imgStr.replace(/^data:image\/\w+;base64,/, "");
-                    return { image: { format: 'png', source: { bytes: Buffer.from(base64Data, 'base64') } } };
-                });
-                contentBlock = [...imageBlocks, ...contentBlock];
-            }
-
-            const command = new ConverseStreamCommand({
-                modelId: "arn:aws:bedrock:us-east-1:106774395747:inference-profile/global.anthropic.claude-sonnet-4-6",
-                system: [{ text: system_prompt || CLAUDE_SYSTEM_PROMPT }],
-                messages: [{ role: "user", content: contentBlock }],
-                inferenceConfig: { maxTokens: 48000, temperature: 1 },
-                additionalModelRequestFields: { thinking: { type: "adaptive" }, output_config: { effort: "high" } }
-            });
-
-            const response = await bedrockClient.send(command);
-            for await (const chunk of response.stream) {
-                if (chunk.contentBlockDelta) {
-                    const delta = chunk.contentBlockDelta.delta;
-                    if (delta.reasoningContent?.text) res.write(`__THINK__${delta.reasoningContent.text}`);
-                    else if (delta.text) res.write(delta.text);
-                }
-            }
-            res.end();
+        const project = await StateManager.getProject(projectId);
+        StateManager.clearSnapshot(projectId);
+        
+        // --- STEP 1: WORKER ---
+        let stopStatus = startStatusLoop(projectId, 'worker');
+        let workerPass1 = "";
+        const result1 = await AIEngine.callWorkerStream(
+            project.workerHistory, fullInput, 
+            (thought) => { stopStatus(); StateManager.setStatus(projectId, "Worker: Thinking..."); StateManager.appendSnapshotOnly(projectId, thought); },
+            (chunk) => { stopStatus(); StateManager.setStatus(projectId, "Worker: Coding..."); workerPass1 += chunk; StateManager.appendStream(projectId, chunk); },
+            images
+        );
+        stopStatus();
+
+        const tags = extractTags(workerPass1);
+        if (tags.pmQuestion || tags.pmRoute) {
+            // Commit Pass 1
+            await StateManager.addHistory(projectId, 'worker', 'user', fullInput);
+            await StateManager.addHistory(projectId, 'worker', 'model', workerPass1);
+            await StateManager.queueCommand(projectId, workerPass1);
+
+            // --- STEP 2: PROJECT MANAGER ---
+            StateManager.clearSnapshot(projectId);
+            stopStatus = startStatusLoop(projectId, 'pm');
+            const pmInput = tags.pmRoute ? `[ROUTED TASK]: ${tags.pmRoute}` : `[QUESTION]: ${tags.pmQuestion}`;
+            let pmText = "";
+            await AIEngine.callPMStream(
+                project.pmHistory, pmInput,
+                (thought) => { stopStatus(); StateManager.setStatus(projectId, "Manager: Thinking..."); StateManager.appendSnapshotOnly(projectId, thought); },
+                (chunk) => { stopStatus(); StateManager.setStatus(projectId, "Manager: Architecting..."); pmText += chunk; StateManager.appendSnapshotOnly(projectId, chunk); }
+            );
+            stopStatus();
+
+            await StateManager.addHistory(projectId, 'pm', 'user', pmInput);
+            await StateManager.addHistory(projectId, 'pm', 'model', pmText);
+            await StateManager.queueCommand(projectId, pmText);
+
+            // Notify Worker of PM Answer
+            const pmAnswerVisible = `[PM RESPONSE]:\n${pmText}`;
+            await StateManager.addHistory(projectId, 'worker', 'model', pmAnswerVisible);
+
+            // --- STEP 3: WORKER FINAL PASS ---
+            const nextTask = extractTags(pmText).workerPrompt || "Proceed with implementation.";
+            StateManager.clearSnapshot(projectId);
+            stopStatus = startStatusLoop(projectId, 'worker');
+            let workerPass2 = "";
+            const currentHistory = await StateManager.getProject(projectId); // Refresh history
+            await AIEngine.callWorkerStream(
+                currentHistory.workerHistory, nextTask,
+                (thought) => { stopStatus(); StateManager.appendSnapshotOnly(projectId, thought); },
+                (chunk) => { stopStatus(); workerPass2 += chunk; StateManager.appendStream(projectId, chunk); }
+            );
+            stopStatus();
+            await StateManager.addHistory(projectId, 'worker', 'model', workerPass2);
+            await StateManager.queueCommand(projectId, workerPass2);
         } else {
-            let messagesPayload = [{ role: "system", content: system_prompt || GPT_SYSTEM_PROMPT }];
-            if (images && images.length > 0) {
-                let userContent = [{ type: "text", text: prompt }];
-                images.forEach(img => userContent.push({ type: "image_url", image_url: { url: img } }));
-                messagesPayload.push({ role: "user", content: userContent });
-            } else {
-                messagesPayload.push({ role: "user", content: prompt });
-            }
-
-            const stream = await azureOpenAI.chat.completions.create({
-                model: "gpt-5-mini",
-                messages: messagesPayload,
-                reasoning_effort: "high",
-                stream: true,
-            });
-
-            for await (const chunk of stream) {
-                const delta = chunk.choices[0]?.delta;
-                if (delta?.reasoning_content) res.write(`__THINK__${delta.reasoning_content}`);
-                else if (delta?.content) res.write(delta.content);
-            }
-            res.end();
+            await StateManager.addHistory(projectId, 'worker', 'user', fullInput);
+            await StateManager.addHistory(projectId, 'worker', 'model', workerPass1);
+            await StateManager.queueCommand(projectId, workerPass1);
         }
+
+        await StateManager.updateProject(projectId, { status: "idle" });
+        await deductUserCredits(userId, 10); // Standard cost
     } catch (err) {
-        console.error(`❌ [STREAM ERROR]:`, err.message);
-        res.write(`ERROR: ${err.message}`);
-        res.end();
+        console.error("Feedback Loop Failed:", err.message);
+        StateManager.setStatus(projectId, "Error: " + err.message);
+        await StateManager.updateProject(projectId, { status: "error" });
     }
+}
+
+app.post('/project/feedback', async (req, res) => {
+    const { userId, projectId, prompt, hierarchyContext, scriptContext, logContext, images } = req.body;
+    try {
+        const project = await StateManager.getProject(projectId);
+        if (!project || project.userId !== userId) return res.status(403).json({ error: "Auth Error" });
+        await checkMinimumCredits(userId, 'basic');
+        await StateManager.updateProject(projectId, { status: "working" });
+        res.json({ success: true });
+        const context = formatContext({ hierarchyContext, scriptContext, logContext });
+        runAsyncFeedback(projectId, userId, `USER: ${prompt || "Auto Feedback"}${context}`, images || []);
+    } catch (err) { res.status(500).json({ error: err.message }); }
+});
+
+app.post('/project/ping', async (req, res) => {
+    const { projectId, userId, isFrontend } = req.body;
+    const project = await StateManager.getProject(projectId);
+    if (!project || project.userId !== userId) return res.json({ action: "IDLE" });
+    if (isFrontend) return res.json({ status: StateManager.getStatus(projectId), snapshot: StateManager.getSnapshot(projectId) });
+    const command = await StateManager.popCommand(projectId);
+    const stream = StateManager.popStream(projectId);
+    let resData = { action: stream ? "STREAM_APPEND" : "IDLE", stream };
+    if (command) { resData.action = command.type; resData.target = command.payload; resData.code = command.payload; }
+    res.json(resData);
+});
+
+// Standard Handlers
+app.post('/onboarding/create', async (req, res) => {
+    const { userId, description, answers } = req.body;
+    const projectId = `proj_${Date.now()}_${crypto.randomBytes(2).toString("hex")}`;
+    const grade = await AIEngine.gradeProject(description, answers);
+    await supabase.from('projects').insert({ id: projectId, user_id: userId, info: { title: grade.title, description, status: "idle" } });
+    res.json({ success: true, projectId, grade });
 });
 
-app.listen(PORT, '0.0.0.0', () => console.log(`Main AI Agents live on port ${PORT}`));
+app.listen(PORT, () => console.log(`AI Backend live on ${PORT}`));