Update app.js

app.js

@@ -1,4 +1,6 @@
-// server.js - ALIGNED WITH PLUGIN & FIXED SYNTAX
+// server.js
+// ESM Node (package.json should contain "type": "module")
+// Install: npm install express body-parser cors @google/genai
 // Run: GEMINI_API_KEY=your_key node server.js
 
 import express from "express";
@@ -18,18 +20,21 @@ const app = express();
 app.use(cors());
 app.use(bodyParser.json({ limit: "2mb" }));
 
+/**
+ * In-memory store (prototype). For production, replace with persistent storage.
+ */
 const projects = new Map();
 
 const simpleId = (prefix = "") => prefix + Math.random().toString(36).slice(2, 9);
 
 /**
- * STRICT VOCABULARY
- * Only actions that exist in the Plugin's ACTION_HANDLERS are allowed here.
+ * === CHANGED SECTION START ===
+ * Action vocabulary — Strictly aligned with what plugin.lua actually supports.
  */
 const VALID_ACTIONS = [
   "create_part",
   "create_model",
-  "create_meshpart", 
+  "create_meshpart",
   "create_script",
   "attach_script",
   "edit_script",
@@ -39,13 +44,13 @@ const VALID_ACTIONS = [
   "set_parent",
   "delete",
   "weld",
-  "list_workspace",
+  "list_workspace", // Plugin calls this workspaceSnapshot
   "finish"
 ];
 
 /**
- * SYNONYM MAPPING
- * Maps what the AI *wants* to say to what the Plugin *can* do.
+ * Map of alternate action names -> canonical action.
+ * FIX: Removed unsupported synonyms (like create_rig) and mapped them to supported ones.
  */
 const ACTION_SYNONYMS = {
   // Map complex mesh requests to simple meshparts
@@ -68,182 +73,396 @@ const ACTION_SYNONYMS = {
   "group": "create_model", 
   "parent": "set_parent",
   "set_parent_to": "set_parent",
-  "join": "weld", // Fixed: JS comment syntax
+  "join": "weld", 
   
-  // Unsupported fallbacks (Safety)
-  "union": "create_model", // Fixed: JS comment syntax
+  // Unsupported fallbacks (Safety Mappings)
+  "union": "create_model", // Fallback: Group them instead of Unioning
   "create_union": "create_model",
-  "create_rig": "create_model" // Fixed: JS comment syntax
+  "create_rig": "create_model", // Fallback: Just make a model container
+  "add_bone": "create_part" // Fallback: Make a part instead of a bone
 };
+/** === CHANGED SECTION END === */
 
+/**
+ * Validate/prepare model output tasks (ensure allowed actions, add ids).
+ * Also maps synonyms to canonical actions (records the originalAction in the returned object).
+ */
 function validateAndPrepareTasks(arr) {
   if (!Array.isArray(arr)) throw new Error("Model output must be a JSON array of tasks.");
   return arr.map((t) => {
     if (!t || typeof t !== "object") throw new Error("Each task must be an object.");
     if (!t.action) throw new Error("Each task must have an action field.");
 
+    // Normalize action: trim and coerce to string
     let actionRaw = String(t.action).trim();
     const actionLower = actionRaw.toLowerCase();
 
+    // Map synonyms (case-insensitive)
     let canonicalAction = null;
+    // First try exact match against VALID_ACTIONS (case-sensitive)
     if (VALID_ACTIONS.includes(actionRaw)) canonicalAction = actionRaw;
-    
-    // Case-insensitive check
+    // Then try case-insensitive match
     if (!canonicalAction) {
       canonicalAction = VALID_ACTIONS.find(a => a.toLowerCase() === actionLower) || null;
     }
-    
-    // Synonym check
+    // Then try synonyms map
     if (!canonicalAction && ACTION_SYNONYMS[actionLower]) {
       canonicalAction = ACTION_SYNONYMS[actionLower];
     }
 
     if (!canonicalAction) {
-      throw new Error(`Invalid action '${actionRaw}'. Supported: ${VALID_ACTIONS.join(", ")}`);
+      // Not recognized — include the offending action in the error to help debugging
+      throw new Error(`Invalid action from model: ${actionRaw}`);
     }
 
     const id = t.id || simpleId("cmd_");
     const params = t.params && typeof t.params === "object" ? t.params : {};
-    
-    return { 
-        id, 
-        action: canonicalAction, 
-        originalAction: actionRaw, 
-        params, 
-        target_ref: t.target_ref || null 
-    };
+    // Attach originalAction for traceability in history/logs
+    return { id, action: canonicalAction, originalAction: actionRaw, params, target_ref: t.target_ref || null };
   });
 }
 
+/**
+ * generateTasks(project)
+ * Uses Gemini to convert description + project state into an ordered JSON array of tasks.
+ */
 async function generateTasks(project) {
-  const historySample = (project.history || []).slice(-15).map(h => ({
+  // Summarize project state (concise)
+  const historySample = (project.history || []).slice(-20).map(h => ({
+    commandId: h.commandId,
     status: h.status,
-    action: h.originalAction || "unknown",
-    msg: h.message ? h.message.slice(0, 50) : "ok"
+    message: h.message ? (typeof h.message === "string" ? (h.message.length > 120 ? h.message.slice(0, 117) + "..." : h.message) : null) : null,
+    originalAction: h.originalAction || null,
+    target_ref: h.target_ref || null,
+    ts: h.ts
   }));
-  
+  const refsKeys = Object.keys(project._refs || {}).slice(0, 200);
+  const queuedCount = project.commandQueue ? project.commandQueue.length : 0;
+  const tasksCount = project.tasks ? project.tasks.length : 0;
   const status = project.status || "unknown";
 
+  const stateSummary = {
+    projectId: project.id,
+    status,
+    queuedCount,
+    tasksCount,
+    recentHistory: historySample,
+    refsSummary: refsKeys
+  };
+
+  /** === CHANGED SECTION START: Updated System Prompt === */
   const systemPrompt = `
-You are a Roblox Studio Assistant. Convert user descriptions into JSON tasks.
-
-AVAILABLE ACTIONS:
-${VALID_ACTIONS.join(", ")}
-
-RULES:
-1. **References:** When creating an object, ALWAYS assign a unique "target_ref" (e.g., "ref_wall_1").
-2. **Chaining:** When moving/modifying that object later, use "target_ref": "ref_wall_1" in the params.
-3. **Hierarchy:** To put a Part inside a Model:
-   - Task 1: create_model (target_ref: "ref_grp")
-   - Task 2: create_part (target_ref: "ref_part")
-   - Task 3: set_parent (target_ref: "ref_part", params: { parent_ref: "ref_grp" })
-4. **Math:** Use numbers for positions. Roblox Y is Up.
-5. **Output:** Return ONLY a JSON Array. No markdown.
-
-Current Context:
-${JSON.stringify({ history: historySample, status }, null, 2)}
-
-User Request:
-${JSON.stringify({ description: project.description })}
+You are a precise assistant that converts a high-level Roblox project description into an ordered JSON array of low-level editor tasks. Be spatially aware: reason about coordinates (x,y,z), sizes, rotations (euler degrees as {x,y,z}), orientations, and parent/child relationships. For every object you create, assign a stable "target_ref" string (short alphanumeric) that later tasks can reference.
+
+Return ONLY valid JSON — a single array, no commentary, no extra text.
+
+Allowed actions (use exactly these): ${VALID_ACTIONS.join(", ")}.
+
+Task object shape:
+{
+  "action": "<action>",
+  "params": { ... },           // numbers, strings, booleans, objects with numeric x,y,z, etc.
+  "target_ref": "<optional-ref>" // for create_* actions include this for reference
+}
+
+Important rules:
+- Spatial parameters use explicit numeric fields: position: { x, y, z }, size: { x, y, z }, rotation: { x, y, z } (degrees).
+- When referencing an earlier-created object, use params.target_ref exactly as the ref string you returned earlier.
+- Do not reference Roblox-specific paths (like Workspace.Model.Part).
+- Use only the allowed actions listed above (exactly those names).
+- End the sequence with an action "finish" when the project is complete.
+
+EXISTING PROJECT STATE (read-only; use to decide next tasks):
+${JSON.stringify(stateSummary, null, 2)}
+
+Now produce tasks for this project:
+${JSON.stringify({ id: project.id, description: project.description })}
 `;
+  /** === CHANGED SECTION END === */
 
-  // Use gemini-1.5-flash or 2.0-flash depending on what you have access to.
-  // 1.5-flash is very stable.
   const resp = await ai.models.generateContent({
-    model: "gemini-2.5-pro", 
+    model: "gemini-1.5-flash", // Changed to 1.5-flash for better stability
     contents: systemPrompt,
-    generationConfig: { responseMimeType: "application/json" }
+    generationConfig: { responseMimeType: "application/json" } // Force JSON mode
   });
 
   const text = resp?.text ? resp.text() : (resp?.response?.text() ?? "");
-  
   let arr;
   try {
-    const cleanText = text.replace(/```json/g, "").replace(/```/g, "").trim();
-    arr = JSON.parse(cleanText);
+    arr = JSON.parse(text);
   } catch (err) {
-    console.error("Model Output:", text);
-    throw new Error("Failed to parse JSON from AI.");
+    // Try to extract substring if JSON mode fails (fallback)
+    const start = text.indexOf("[");
+    const end = text.lastIndexOf("]");
+    if (start >= 0 && end > start) {
+      arr = JSON.parse(text.slice(start, end + 1));
+    } else {
+      throw new Error("Could not parse JSON from model output: " + text.slice(0, 1000));
+    }
   }
 
   return validateAndPrepareTasks(arr);
 }
 
-// --- EXPRESS ROUTES ---
-
+/**
+ * Create project endpoint
+ * Body: { description: string, projectId?: string }
+ */
 app.post("/projects", async (req, res) => {
   try {
+    const description = req.body.description;
+    if (!description || typeof description !== "string") {
+      return res.status(400).json({ error: "description string required in body" });
+    }
     const projectId = req.body.projectId || simpleId("proj_");
+    // Removed strict check if exists, just reset if it does, easier for plugin reconnects
+    
     const project = {
       id: projectId,
-      description: req.body.description || "New Project",
+      description,
       status: "queued",
       tasks: [],
       commandQueue: [],
       pendingResults: new Map(),
-      history: [],
-      _refs: {}
+      running: false,
+      history: [], 
+      _refs: {}    
     };
+
     projects.set(projectId, project);
-    runProject(project); 
+
+    // Start background orchestrator (non-blocking)
+    runProject(project).catch((err) => {
+      project.status = "error";
+      console.error("runProject error:", err);
+    });
+
     return res.status(202).json({ projectId, status: "accepted" });
   } catch (err) {
+    console.error("projects POST error", err);
     return res.status(500).json({ error: err.message });
   }
 });
 
+/**
+ * Tweak / prompt endpoint — includes project context so the model knows what has been done.
+ * Body: { prompt: string }
+ */
 app.post("/projects/:projectId/prompt", async (req, res) => {
   const project = projects.get(req.params.projectId);
   if (!project) return res.status(404).json({ error: "project not found" });
-  
   const prompt = req.body.prompt;
-  project.description += `\nUser Update: ${prompt}`;
-  
+  if (!prompt || typeof prompt !== "string") return res.status(400).json({ error: "prompt required" });
+
   try {
-    const newTasks = await generateTasks({ ...project, description: prompt });
+    // Create a temporary project context for the AI that includes the new prompt
+    const contextSummary = {
+      id: project.id,
+      status: project.status,
+      queuedCount: project.commandQueue.length,
+      tasksCount: project.tasks.length,
+      recentHistory: (project.history || []).slice(-50).map(h => ({ commandId: h.commandId, status: h.status, target_ref: h.target_ref, originalAction: h.originalAction })),
+      refsKeys: Object.keys(project._refs || {}).slice(0, 200)
+    };
+
+    const pseudoProject = {
+      id: project.id,
+      description: `${project.description}\n\n---\nContextSummary: ${JSON.stringify(contextSummary)}\n\nUserTweak: ${prompt}`
+    };
+
+    const newTasks = await generateTasks(pseudoProject);
+
+    // Append tasks to the project's task list
     project.tasks.push(...newTasks);
+    // Push directly to queue so the running loop picks them up
     project.commandQueue.push(...newTasks);
-    return res.json({ tasks: newTasks });
-  } catch(e) {
-    return res.status(500).json({error: e.message});
+
+    return res.json({ appended: newTasks.length, tasks: newTasks });
+  } catch (err) {
+    console.error("prompt endpoint error:", err);
+    return res.status(500).json({ error: err.message });
   }
 });
 
+/**
+ * Direct model endpoint for manual calls (returns Gemini text)
+ * Body: { prompt: string }
+ */
+app.post("/model", async (req, res) => {
+  try {
+    const prompt = req.body.prompt;
+    if (!prompt || typeof prompt !== "string") return res.status(400).json({ error: "prompt required" });
+
+    const resp = await ai.models.generateContent({
+      model: "gemini-1.5-flash",
+      contents: prompt,
+    });
+    
+    const text = resp?.text ? resp.text() : "";
+    return res.json({ text });
+  } catch (err) {
+    console.error("/model error", err);
+    return res.status(500).json({ error: err.message });
+  }
+});
+
+/**
+ * Plugin polling: GET next command or 204 if none
+ */
 app.get("/projects/:projectId/next", (req, res) => {
   const project = projects.get(req.params.projectId);
   if (!project) return res.status(404).json({ error: "project not found" });
+
   if (project.commandQueue.length > 0) {
-    return res.json(project.commandQueue.shift());
+    const cmd = project.commandQueue.shift();
+    return res.json(cmd);
   }
   return res.status(204).end();
 });
 
+/**
+ * Plugin posts execution result. This records history and resolves waiters.
+ * Body: { commandId, status: "ok"|"error", message?: string, extra?: any, target_ref?: string }
+ */
 app.post("/projects/:projectId/result", (req, res) => {
   const project = projects.get(req.params.projectId);
   if (!project) return res.status(404).json({ error: "project not found" });
-  
-  const { commandId, status, message, target_ref } = req.body;
-  
-  project.history.push({ commandId, status, message, timestamp: Date.now() });
-  
-  if (project.pendingResults.has(commandId)) {
-    project.pendingResults.get(commandId).resolve({ status, message, target_ref });
+
+  const { commandId, status, message, extra, target_ref } = req.body;
+  if (!commandId || !status) return res.status(400).json({ error: "commandId and status required" });
+
+  // Record in history
+  const entry = {
+    commandId,
+    status,
+    message: message || null,
+    extra: extra || null,
+    target_ref: target_ref || null,
+    originalAction: null, 
+    ts: Date.now()
+  };
+
+  // Attempt to find the originalAction from project's tasks
+  const possibleTask = (project.tasks || []).find(t => t.id === commandId);
+  if (possibleTask && possibleTask.originalAction) entry.originalAction = possibleTask.originalAction;
+
+  project.history = project.history || [];
+  project.history.push(entry);
+
+  // Map target_ref if present and OK
+  if (target_ref && status === "ok") {
+    project._refs = project._refs || {};
+    project._refs[target_ref] = { commandId, extra, ts: Date.now() };
+  }
+
+  // Resolve pending waiter if present
+  const waiter = project.pendingResults.get(commandId);
+  if (waiter) {
     project.pendingResults.delete(commandId);
+    waiter.resolve({ status, message, extra, target_ref });
+    return res.json({ ok: true });
   }
-  
-  return res.json({ ok: true });
+
+  // Otherwise accept and return
+  return res.json({ ok: true, note: "recorded result (no pending waiter)" });
+});
+
+/**
+ * Status endpoint
+ */
+app.get("/status/:projectId", (req, res) => {
+  const project = projects.get(req.params.projectId);
+  if (!project) return res.status(404).json({ error: "project not found" });
+  return res.json({
+    id: project.id,
+    status: project.status,
+    queuedCommands: project.commandQueue.length,
+    totalTasks: project.tasks.length,
+    refs: project._refs || {},
+    historyLength: (project.history || []).length
+  });
 });
 
+/**
+ * Simple list of projects (debug)
+ */
+app.get("/projects", (req, res) => {
+  const list = Array.from(projects.values()).map((p) => ({
+    id: p.id,
+    description: p.description,
+    status: p.status,
+    queuedCommands: p.commandQueue.length,
+    tasks: p.tasks.length
+  }));
+  return res.json(list);
+});
+
+/**
+ * Orchestrator per project
+ * - If no tasks: generate from description
+ * - Iterate tasks, push to commandQueue, wait for plugin result, then continue
+ */
 async function runProject(project) {
-  if (project.tasks.length === 0 && project.description) {
-     try {
-       project.tasks = await generateTasks(project);
-       project.commandQueue.push(...project.tasks);
-     } catch (e) {
-       console.error("Gen Error:", e);
-       return;
-     }
+  if (project.running) return;
+  project.running = true;
+  project.status = "running";
+
+  try {
+    // If no tasks, generate initial plan
+    if (!project.tasks || project.tasks.length === 0) {
+      project.tasks = await generateTasks(project);
+    }
+
+    // Push all initial tasks to the queue
+    // (Note: In your original logic, you might have wanted to push them one by one.
+    // Here we push them to queue so the polling endpoint can serve them)
+    project.commandQueue.push(...project.tasks);
+
+    // If you want the orchestrator to BLOCK and wait for results before marking 'complete', we do this:
+    // (This loops through the local list, not the queue, because the queue gets drained by the plugin)
+    for (const task of project.tasks) {
+      // We need to wait until the plugin reports back for THIS task ID.
+      // The plugin might pick it up from commandQueue at any time.
+      
+      const result = await new Promise((resolve, reject) => {
+        const timeoutMs = 3 * 60 * 1000; // 3 minutes
+        let timedOut = false;
+        const timeout = setTimeout(() => {
+          timedOut = true;
+          project.pendingResults.delete(task.id);
+          reject(new Error("Command timed out: " + task.id));
+        }, timeoutMs);
+
+        project.pendingResults.set(task.id, {
+          resolve: (payload) => {
+            if (timedOut) return;
+            clearTimeout(timeout);
+            resolve(payload);
+          },
+          reject: (err) => {
+            if (timedOut) return;
+            clearTimeout(timeout);
+            reject(err);
+          }
+        });
+      });
+
+      // If failure, mark and stop
+      if (result.status !== "ok") {
+        project.status = "failed";
+        throw new Error(`Command ${task.id} failed: ${result.message ?? "no message"}`);
+      }
+    }
+
+    project.status = "complete";
+  } catch (err) {
+    console.error("Project run error for", project.id, err);
+    if (project.status !== "failed") project.status = "error";
+  } finally {
+    project.running = false;
   }
 }
 
-app.listen(PORT, () => console.log(`BloxBuddy Brain running on ${PORT}`));
+app.listen(PORT, () => {
+  console.log(`BloxBuddy backend listening on port ${PORT}`);
+});