Update app.js

app.js

@@ -20,16 +20,11 @@ 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);
 
 /**
- * === CHANGED SECTION START ===
- * Action vocabulary — Strictly aligned with what plugin.lua actually supports.
+ * STRICT VOCABULARY - Matched to Plugin
  */
 const VALID_ACTIONS = [
   "create_part",
@@ -44,182 +39,146 @@ const VALID_ACTIONS = [
   "set_parent",
   "delete",
   "weld",
-  "list_workspace", // Plugin calls this workspaceSnapshot
+  "list_workspace",
   "finish"
 ];
 
-/**
- * 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
   "create_complex_mesh": "create_meshpart",
   "load_mesh": "create_meshpart",
-  
-  // Map common movement terms
   "move": "move_to",
   "position": "move_to",
   "rotate": "rotate_to",
   "set_rotation": "rotate_to",
-  
-  // Scripting synonyms
   "add_script": "create_script",
   "insert_script": "create_script",
   "modify_script": "edit_script",
   "append_script": "attach_script",
-  
-  // Hierarchy
   "group": "create_model", 
   "parent": "set_parent",
   "set_parent_to": "set_parent",
   "join": "weld", 
-  
-  // Unsupported fallbacks (Safety Mappings)
-  "union": "create_model", // Fallback: Group them instead of Unioning
+  "union": "create_model", 
   "create_union": "create_model",
-  "create_rig": "create_model", // Fallback: Just make a model container
-  "add_bone": "create_part" // Fallback: Make a part instead of a bone
+  "create_rig": "create_model", 
+  "add_bone": "create_part" 
 };
-/** === 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;
-    // Then try case-insensitive match
     if (!canonicalAction) {
       canonicalAction = VALID_ACTIONS.find(a => a.toLowerCase() === actionLower) || null;
     }
-    // Then try synonyms map
     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}`);
+      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 };
   });
 }
 
-/**
- * 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,
     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
   }));
   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
+    refsSummary: refsKeys,
+    recentHistory: historySample
   };
 
-  /** === CHANGED SECTION START: Updated System 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.
+You are a precise Roblox Studio Assistant.
+Allowed actions: ${VALID_ACTIONS.join(", ")}.
 
-Return ONLY valid JSON — a single array, no commentary, no extra text.
+RULES:
+1. **References:** When creating an object, ALWAYS assign a unique "target_ref" (e.g., "ref_wall_1").
+2. **Chaining:** When moving/modifying later, use "target_ref": "ref_wall_1".
+3. **Hierarchy:** To put a Part inside a Model: create_model (ref_grp) -> create_part (ref_part) -> set_parent (target_ref: ref_part, params: { parent_ref: ref_grp }).
+4. **Math:** Use numbers. Position {x,y,z}. Rotation {x,y,z} (degrees).
+5. **Output:** Return ONLY a JSON Array.
 
-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):
+EXISTING STATE:
 ${JSON.stringify(stateSummary, null, 2)}
 
-Now produce tasks for this project:
-${JSON.stringify({ id: project.id, description: project.description })}
+User Request:
+${JSON.stringify({ description: project.description })}
 `;
-  /** === CHANGED SECTION END === */
 
+  // Using 1.5-pro as the closest valid "Pro" model. 
+  // If you strictly need "gemini-2.5-pro", allow the string, but note it might 404 if not enabled on your account.
   const resp = await ai.models.generateContent({
-    model: "gemini-2.5-pro", // Changed to 1.5-flash for better stability
+    model: "gemini-2.5-pro", 
     contents: systemPrompt,
-    generationConfig: { responseMimeType: "application/json" } // Force JSON mode
+    generationConfig: { responseMimeType: "application/json" }
   });
 
-  const text = resp?.text ? resp.text() : (resp?.response?.text() ?? "");
+  // === FIX: Robust Response Text Extraction ===
+  let text = "";
+  if (resp && typeof resp.text === 'string') {
+     // SDK returned text property directly
+     text = resp.text; 
+  } else if (resp && typeof resp.text === 'function') {
+     // SDK returned text method
+     text = resp.text();
+  } else if (resp?.response?.text) {
+     // Nested response object
+     text = typeof resp.response.text === 'function' ? resp.response.text() : resp.response.text;
+  } else {
+     // Fallback for raw data structure
+     text = resp?.data?.candidates?.[0]?.content?.parts?.[0]?.text || "";
+  }
+  // ============================================
+
   let arr;
   try {
-    arr = JSON.parse(text);
+    // Sanitize markdown if still present
+    const cleanText = text.replace(/```json/g, "").replace(/```/g, "").trim();
+    arr = JSON.parse(cleanText);
   } catch (err) {
-    // Try to extract substring if JSON mode fails (fallback)
+    // Fallback extraction
     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("AI Output was:", text);
+      throw new Error("Could not parse JSON from model output.");
     }
   }
 
   return validateAndPrepareTasks(arr);
 }
 
-/**
- * Create project endpoint
- * Body: { description: string, projectId?: string }
- */
+// --- ENDPOINTS ---
+
 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,
+      description: req.body.description || "New Project",
       status: "queued",
       tasks: [],
       commandQueue: [],
@@ -231,7 +190,6 @@ app.post("/projects", async (req, res) => {
 
     projects.set(projectId, project);
 
-    // Start background orchestrator (non-blocking)
     runProject(project).catch((err) => {
       project.status = "error";
       console.error("runProject error:", err);
@@ -239,193 +197,96 @@ app.post("/projects", async (req, res) => {
 
     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" });
+  project.description += `\nUser Update: ${prompt}`;
 
   try {
-    // 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
+    const newTasks = await generateTasks({ ...project, description: prompt });
     project.tasks.push(...newTasks);
-    // Push directly to queue so the running loop picks them up
     project.commandQueue.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 });
-  }
-});
-
-/**
- * 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-pro",
-      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) {
-    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
+  
+  // History recording
   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() };
+    project._refs[target_ref] = { commandId, 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 });
+    waiter.resolve({ status, message, target_ref });
     return res.json({ ok: true });
   }
 
-  // Otherwise accept and return
-  return res.json({ ok: true, note: "recorded result (no pending waiter)" });
+  return res.json({ ok: true });
 });
 
-/**
- * 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
+    queued: project.commandQueue.length,
+    refs: project._refs || {}
   });
 });
 
-/**
- * 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);
     }
-
-    // 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)
+    // Blocking wait logic
     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
+        const timeoutMs = 3 * 60 * 1000; 
         let timedOut = false;
         const timeout = setTimeout(() => {
           timedOut = true;
@@ -447,16 +308,14 @@ async function runProject(project) {
         });
       });
 
-      // If failure, mark and stop
       if (result.status !== "ok") {
         project.status = "failed";
-        throw new Error(`Command ${task.id} failed: ${result.message ?? "no message"}`);
+        throw new Error(`Command ${task.id} failed: ${result.message}`);
       }
     }
-
     project.status = "complete";
   } catch (err) {
-    console.error("Project run error for", project.id, err);
+    console.error("Project run error:", err);
     if (project.status !== "failed") project.status = "error";
   } finally {
     project.running = false;