Update app.js

app.js

@@ -1,6 +1,4 @@
-// server.js
-// ESM Node (package.json should contain "type": "module")
-// Install: npm install express body-parser cors @google/genai
+// server.js - ALIGNED WITH PLUGIN
 // Run: GEMINI_API_KEY=your_key node server.js
 
 import express from "express";
@@ -20,23 +18,19 @@ 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);
 
 /**
- * Action vocabulary — keep plugin and server in sync.
- * We also accept some common synonyms from the model and map them to canonical allowed actions.
+ * STRICT VOCABULARY
+ * Only actions that exist in the Plugin's ACTION_HANDLERS are allowed here.
+ * Removed: create_union, create_rig, apply_animation, unweld, apply_texture
  */
 const VALID_ACTIONS = [
   "create_part",
   "create_model",
-  "create_meshpart",
-  "create_complex_mesh",
-  "create_union",
+  "create_meshpart", 
   "create_script",
   "attach_script",
   "edit_script",
@@ -45,432 +39,222 @@ const VALID_ACTIONS = [
   "rotate_to",
   "set_parent",
   "delete",
-  "apply_texture",
   "weld",
-  "unweld",
-  "create_rig",
-  "apply_animation",
-  "feedback_request",
-  "list_workspace",
+  "list_workspace", // Plugin calls this workspaceSnapshot
   "finish"
 ];
 
 /**
- * Map of alternate action names the model might output -> canonical action.
- * Add more mappings here if you see similar synonyms from the model.
+ * SYNONYM MAPPING
+ * Maps what the AI *wants* to say to what the Plugin *can* do.
  */
 const ACTION_SYNONYMS = {
-  // common variants
-  "add_bone": "create_rig",
-  "add_bones": "create_rig",
-  "create_bone": "create_rig",
-  "attach_script_to": "attach_script",
-  "modify_script": "edit_script",
+  // Map complex mesh requests to simple meshparts
+  "create_complex_mesh": "create_meshpart",
+  "load_mesh": "create_meshpart",
+  
+  // Map common movement terms
   "move": "move_to",
+  "position": "move_to",
   "rotate": "rotate_to",
-  "set_parent_to": "set_parent",
-  // geometry synonyms
-  "union": "create_union",
-  "make_union": "create_union",
-  "mesh_part": "create_meshpart",
+  "set_rotation": "rotate_to",
+  
+  // Scripting synonyms
   "add_script": "create_script",
   "insert_script": "create_script",
+  "modify_script": "edit_script",
   "append_script": "attach_script",
-  "add_animation": "apply_animation"
+  
+  // Hierarchy
+  "group": "create_model", 
+  "parent": "set_parent",
+  "set_parent_to": "set_parent",
+  "join": "weld", -- "Join" usually implies welding in this simple context
+  
+  // Unsupported fallbacks (Safety)
+  "union": "create_model", -- Fallback: Group them instead of Unioning (prevents crash)
+  "create_union": "create_model",
+  "create_rig": "create_model" -- Fallback: Just make a model container
 };
 
-/**
- * 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;
-    // Then try case-insensitive match
+    
+    // Case-insensitive check
     if (!canonicalAction) {
       canonicalAction = VALID_ACTIONS.find(a => a.toLowerCase() === actionLower) || null;
     }
-    // Then try synonyms map
+    
+    // Synonym check
     if (!canonicalAction && ACTION_SYNONYMS[actionLower]) {
       canonicalAction = ACTION_SYNONYMS[actionLower];
     }
 
     if (!canonicalAction) {
-      // Not recognized — include the offending action in the error to help debugging
-      throw new Error(`Invalid action from model: ${actionRaw}`);
+      // If AI hallucinates an action, we force it to a safe fallback or error
+      // Instead of crashing, let's log it and skip or error.
+      throw new Error(`Invalid action '${actionRaw}'. Supported: ${VALID_ACTIONS.join(", ")}`);
     }
 
     const id = t.id || simpleId("cmd_");
     const params = t.params && typeof t.params === "object" ? t.params : {};
-    // Attach originalAction for traceability in history/logs
-    return { id, action: canonicalAction, originalAction: actionRaw, params, target_ref: t.target_ref || null };
+    
+    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) {
-  // Summarize project state (concise)
-  const historySample = (project.history || []).slice(-20).map(h => ({
-    commandId: h.commandId,
+  // Summarize project state
+  const historySample = (project.history || []).slice(-15).map(h => ({
     status: h.status,
-    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
+    action: h.originalAction || "unknown",
+    msg: h.message ? h.message.slice(0, 50) : "ok"
   }));
-  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
-  };
-
+  // We explicitly tell the AI about the Registry logic in the prompt
   const systemPrompt = `
-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).
-- If you need the plugin to evaluate the scene and return properties (for feedback), use actions "feedback_request" or "list_workspace".
-- 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 })}
+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 })}
 `;
 
   const resp = await ai.models.generateContent({
-    model: "gemini-2.5-flash",
+    model: "gemini-2.0-flash", // Updated to latest flash if available, or use 1.5-flash
     contents: systemPrompt,
-    temperature: 0.0,
-    maxOutputTokens: 2000
+    generationConfig: { responseMimeType: "application/json" } // Force JSON mode
   });
 
-  const text = resp?.text ?? (resp?.data?.[0]?.text ?? "");
+  const text = resp?.text ? resp.text() : (resp?.response?.text() ?? "");
+  
   let arr;
   try {
-    arr = JSON.parse(text);
+    // Clean markdown code blocks if present
+    const cleanText = text.replace(/```json/g, "").replace(/```/g, "").trim();
+    arr = JSON.parse(cleanText);
   } catch (err) {
-    // Try to extract substring
-    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));
-    }
+    console.error("Model Output:", text);
+    throw new Error("Failed to parse JSON from AI.");
   }
 
   return validateAndPrepareTasks(arr);
 }
 
-/**
- * Create project endpoint
- * Body: { description: string, projectId?: string }
- */
+// --- EXPRESS ROUTES (Same as before, simplified) ---
+
 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_");
-    if (projects.has(projectId)) return res.status(400).json({ error: "projectId already exists" });
-
     const project = {
       id: projectId,
-      description,
+      description: req.body.description || "New Project",
       status: "queued",
       tasks: [],
       commandQueue: [],
       pendingResults: new Map(),
-      running: false,
-      history: [], // { commandId, status, message, extra, target_ref, originalAction, ts }
-      _refs: {}    // mapping: target_ref -> { commandId, extra, ts }
+      history: [],
+      _refs: {}
     };
-
     projects.set(projectId, project);
-
-    // Start background orchestrator (non-blocking)
-    runProject(project).catch((err) => {
-      project.status = "error";
-      console.error("runProject error:", err);
-    });
-
+    runProject(project); // Background run
     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;
-  if (!prompt || typeof prompt !== "string") return res.status(400).json({ error: "prompt required" });
-
+  // Append new prompt to description acts as "memory" for this simple prototype
+  project.description += `\nUser Update: ${prompt}`;
+  
+  // Re-run generation logic for the new prompt
   try {
-    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
+    const newTasks = await generateTasks({ ...project, description: prompt }); // Only send the *new* prompt as the task trigger
     project.tasks.push(...newTasks);
-
-    return res.json({ appended: newTasks.length, tasks: newTasks });
-  } catch (err) {
-    console.error("prompt endpoint error:", err);
-    return res.status(500).json({ error: err.message });
+    project.commandQueue.push(...newTasks); // Push directly to queue if already running
+    return res.json({ tasks: newTasks });
+  } catch(e) {
+    return res.status(500).json({error: e.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-2.5-flash",
-      contents: prompt,
-      temperature: 0.0,
-      maxOutputTokens: 1500
-    });
-
-    return res.json({ text: resp?.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) {
-    const cmd = project.commandQueue.shift();
-    return res.json(cmd);
+    return res.json(project.commandQueue.shift());
   }
   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, 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, // we'll try to attach if we can find the task in history/tasks
-    ts: Date.now()
-  };
-
-  // Attempt to find the originalAction from project's tasks or prior mapping
-  // (task may have been dispatched earlier; search tasks and history)
-  const possibleTask = (project.tasks || []).find(t => t.id === commandId) || (project.commandQueue || []).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) {
+  
+  const { commandId, status, message, target_ref } = req.body;
+  
+  // Log history
+  project.history.push({ commandId, status, message, timestamp: Date.now() });
+  
+  // Resolve waiting promise (if runProject is waiting)
+  if (project.pendingResults.has(commandId)) {
+    project.pendingResults.get(commandId).resolve({ status, message, target_ref });
     project.pendingResults.delete(commandId);
-    waiter.resolve({ status, message, extra, target_ref });
-    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
-  });
+  
+  return res.json({ ok: true });
 });
 
-/**
- * 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.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);
-    }
-
-    // Iterate tasks
-    for (const task of project.tasks) {
-      // push to queue
-      project.commandQueue.push(task);
-
-      // record that we dispatched this task (for easier traceability)
-      project.history = project.history || [];
-      project.history.push({
-        commandId: task.id,
-        status: "dispatched",
-        message: null,
-        extra: null,
-        target_ref: task.target_ref || null,
-        originalAction: task.originalAction || null,
-        ts: Date.now()
-      });
-
-      // Wait for plugin result for this task
-      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"}`);
-      }
-
-      // If task had target_ref & plugin returned target_ref, map it
-      if (task.target_ref && result.target_ref) {
-        project._refs = project._refs || {};
-        project._refs[task.target_ref] = result.target_ref;
-      }
-    }
-
-    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;
+  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;
+     }
   }
+
+  // In this simplified version, we just let the /next endpoint drain the queue.
+  // We don't strictly "block" here, making it more robust for connection drops.
 }
 
-app.listen(PORT, () => {
-  console.log(`BloxBuddy backend listening on port ${PORT}`);
-});
+app.listen(PORT, () => console.log(`BloxBuddy Brain running on ${PORT}`));