@mindstudio-ai/remy 0.1.4 → 0.1.6

package/dist/actions/buildFromInitialSpec.md

@@ -2,4 +2,6 @@ This is an automated action triggered by the user pressing "Build" in the editor
 
 The user has reviewed the spec and is ready to build. Build everything in one turn: methods, tables, interfaces, manifest updates, and scenarios, using the spec as the master plan.
 
-When code generation is complete, call `setProjectOnboardingState({ state: "onboardingFinished" })`.
+When code generation is complete, verify your work: use `runScenario` to seed test data, then use `runMethod` to confirm a method works, then use `runAutomatedBrowserTest` to smoke-test the main UI flow. The dev database is a disposable snapshot, so don't worry about being destructive. Fix any errors before finishing.
+
+When everything is working, call `setProjectOnboardingState({ state: "onboardingFinished" })`.

package/dist/compiled/design.md

@@ -12,6 +12,17 @@ good on Dribbble, Behance, or Mobbin, it's not done.
 MindStudio apps are end-user products. The interface is the product. Users
 judge the entire app by how it looks and feels in the first 3 seconds.
 
+## Design System from the Spec
+
+The spec file `src/interfaces/@brand/visual.md` may contain `typography` and
+`colors` YAML blocks that define the app's fonts and color palette. When
+these are present, always use them. Load fonts from the URLs in the `fonts`
+section. Set up a lightweight theme layer early (CSS variables or a small
+tokens file) so colors and type styles are defined once and referenced
+everywhere. This makes the design easy to update later without hunting
+through components. Keep it simple: a handful of CSS variables for colors
+and a few reusable text style classes or utilities for typography.
+
 ## Be Distinctive
 
 AI-generated interfaces tend to converge on the same generic look: safe

package/dist/headless.js

@@ -1,7 +1,7 @@
 // src/headless.ts
 import { createInterface } from "readline";
-import fs14 from "fs";
-import path7 from "path";
+import fs15 from "fs";
+import path8 from "path";
 
 // src/config.ts
 import fs2 from "fs";
@@ -940,8 +940,8 @@ var promptUserTool = {
               },
               type: {
                 type: "string",
-                enum: ["select", "text", "file", "color"],
-                description: 'select: pick from options (or options + free-form "other"). text: free-form input. file: file/image upload, returns CDN URL(s) that can be referenced directly or curled onto disk. color: color picker (returns hex).'
+                enum: ["select", "checklist", "text", "file", "color"],
+                description: "select: pick one from a list. checklist: pick one or more from a list. text: free-form input. file: file/image upload, returns CDN URL(s) that can be referenced directly or curled onto disk. color: color picker (returns hex)."
               },
               helpText: {
                 type: "string",
@@ -972,15 +972,15 @@ var promptUserTool = {
                     }
                   ]
                 },
-                description: "Options for select type. Each can be a string or { label, description }."
+                description: "Options for select and checklist types. Each can be a string or { label, description }."
               },
               multiple: {
                 type: "boolean",
-                description: "For select: allow picking multiple options (returns array). For file: allow multiple uploads (returns array of URLs). Defaults to false."
+                description: "For file type: allow multiple uploads (returns array of URLs). Defaults to false."
               },
               allowOther: {
                 type: "boolean",
-                description: 'For select type: adds an "Other" option with a free-form text input. Defaults to false.'
+                description: 'For select and checklist types: adds an "Other" option that lets the user type a custom answer. Use this instead of adding a separate follow-up text field for custom input. Defaults to false.'
               },
               format: {
                 type: "string",
@@ -1032,11 +1032,11 @@ var promptUserTool = {
     const questions = input.questions;
     const lines = questions.map((q) => {
       let line = `- ${q.question}`;
-      if (q.type === "select") {
+      if (q.type === "select" || q.type === "checklist") {
         const opts = (q.options || []).map(
           (o) => typeof o === "string" ? o : o.label
         );
-        line += q.multiple ? ` (pick one or more: ${opts.join(" / ")})` : ` (${opts.join(" / ")})`;
+        line += q.type === "checklist" ? ` (pick one or more: ${opts.join(" / ")})` : ` (${opts.join(" / ")})`;
       } else if (q.type === "file") {
         line += " (upload file)";
       } else if (q.type === "color") {
@@ -1251,14 +1251,26 @@ var writeFileTool = {
       required: ["path", "content"]
     }
   },
-  streaming: {
-    transform: async (partial) => {
-      const oldContent = await fs10.readFile(partial.path, "utf-8").catch(() => "");
-      const lineCount = partial.content.split("\n").length;
-      return `Writing ${partial.path} (${lineCount} lines)
+  streaming: /* @__PURE__ */ (() => {
+    let lastLineCount = 0;
+    let lastPath = "";
+    return {
+      transform: async (partial) => {
+        if (partial.path !== lastPath) {
+          lastLineCount = 0;
+          lastPath = partial.path;
+        }
+        const lines = partial.content.split("\n");
+        if (lines.length <= lastLineCount) {
+          return null;
+        }
+        lastLineCount = lines.length;
+        const oldContent = await fs10.readFile(partial.path, "utf-8").catch(() => "");
+        return `Writing ${partial.path} (${lines.length} lines)
 ${unifiedDiff(partial.path, oldContent, partial.content)}`;
-    }
-  },
+      }
+    };
+  })(),
   async execute(input) {
     try {
       await fs10.mkdir(path6.dirname(input.path), { recursive: true });
@@ -1794,6 +1806,312 @@ var askMindStudioSdkTool = {
   }
 };
 
+// src/tools/code/runScenario.ts
+var runScenarioTool = {
+  definition: {
+    name: "runScenario",
+    description: "Run a scenario to seed the dev database with test data. Truncates all tables first, then executes the seed function and impersonates the scenario roles. Blocks until complete. Scenario IDs are defined in mindstudio.json. If it fails, check .logs/tunnel.log or .logs/requests.ndjson for details.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        scenarioId: {
+          type: "string",
+          description: "The scenario ID from mindstudio.json."
+        }
+      },
+      required: ["scenarioId"]
+    }
+  },
+  async execute() {
+    return "ok";
+  }
+};
+
+// src/tools/code/runMethod.ts
+var runMethodTool = {
+  definition: {
+    name: "runMethod",
+    description: "Run a method in the dev environment and return the result. Use for testing methods after writing or modifying them. Returns output, captured console output, errors with stack traces, and duration. If it fails, check .logs/tunnel.log or .logs/requests.ndjson for more details.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        method: {
+          type: "string",
+          description: 'The method export name (camelCase, e.g. "listHaikus").'
+        },
+        input: {
+          type: "object",
+          description: "The input payload to pass to the method. Omit for methods that take no input."
+        }
+      },
+      required: ["method"]
+    }
+  },
+  async execute() {
+    return "ok";
+  }
+};
+
+// src/tools/code/screenshot.ts
+var screenshotTool = {
+  definition: {
+    name: "screenshot",
+    description: "Capture a screenshot of the app preview. Returns a CDN URL with dimensions. Useful for visually checking the current state after UI changes or when debugging layout issues.",
+    inputSchema: {
+      type: "object",
+      properties: {}
+    }
+  },
+  async execute() {
+    return "ok";
+  }
+};
+
+// src/subagents/runner.ts
+async function runSubAgent(config) {
+  const {
+    system,
+    task,
+    tools,
+    externalTools,
+    executeTool: executeTool2,
+    apiConfig,
+    model,
+    signal,
+    parentToolId,
+    onEvent,
+    resolveExternalTool
+  } = config;
+  const emit2 = (e) => {
+    onEvent({ ...e, parentToolId });
+  };
+  const messages = [{ role: "user", content: task }];
+  while (true) {
+    if (signal?.aborted) {
+      return "Error: cancelled";
+    }
+    let assistantText = "";
+    const toolCalls = [];
+    let stopReason = "end_turn";
+    try {
+      for await (const event of streamChat({
+        ...apiConfig,
+        model,
+        system,
+        messages,
+        tools,
+        signal
+      })) {
+        if (signal?.aborted) {
+          break;
+        }
+        switch (event.type) {
+          case "text":
+            assistantText += event.text;
+            emit2({ type: "text", text: event.text });
+            break;
+          case "thinking":
+            emit2({ type: "thinking", text: event.text });
+            break;
+          case "tool_use":
+            toolCalls.push({
+              id: event.id,
+              name: event.name,
+              input: event.input
+            });
+            emit2({
+              type: "tool_start",
+              id: event.id,
+              name: event.name,
+              input: event.input
+            });
+            break;
+          case "done":
+            stopReason = event.stopReason;
+            break;
+          case "error":
+            return `Error: ${event.error}`;
+        }
+      }
+    } catch (err) {
+      if (!signal?.aborted) {
+        throw err;
+      }
+    }
+    if (signal?.aborted) {
+      return "Error: cancelled";
+    }
+    messages.push({
+      role: "assistant",
+      content: assistantText,
+      toolCalls: toolCalls.length > 0 ? toolCalls : void 0
+    });
+    if (stopReason !== "tool_use" || toolCalls.length === 0) {
+      return assistantText;
+    }
+    log.info("Sub-agent executing tools", {
+      parentToolId,
+      count: toolCalls.length,
+      tools: toolCalls.map((tc) => tc.name)
+    });
+    const results = await Promise.all(
+      toolCalls.map(async (tc) => {
+        if (signal?.aborted) {
+          return { id: tc.id, result: "Error: cancelled", isError: true };
+        }
+        try {
+          let result;
+          if (externalTools.has(tc.name) && resolveExternalTool) {
+            result = await resolveExternalTool(tc.id, tc.name, tc.input);
+          } else {
+            result = await executeTool2(tc.name, tc.input);
+          }
+          const isError = result.startsWith("Error");
+          emit2({
+            type: "tool_done",
+            id: tc.id,
+            name: tc.name,
+            result,
+            isError
+          });
+          return { id: tc.id, result, isError };
+        } catch (err) {
+          const errorMsg = `Error: ${err.message}`;
+          emit2({
+            type: "tool_done",
+            id: tc.id,
+            name: tc.name,
+            result: errorMsg,
+            isError: true
+          });
+          return { id: tc.id, result: errorMsg, isError: true };
+        }
+      })
+    );
+    for (const r of results) {
+      messages.push({
+        role: "user",
+        content: r.result,
+        toolCallId: r.id,
+        isToolError: r.isError
+      });
+    }
+  }
+}
+
+// src/subagents/browserAutomation/tools.ts
+var BROWSER_TOOLS = [
+  {
+    name: "browserCommand",
+    description: "Interact with the app's live preview by sending browser commands. Commands execute sequentially with an animated cursor. Always start with a snapshot to see the current state and get ref identifiers. The result includes a snapshot field with the final page state after all steps complete. On error, the failing step has an error field and execution stops. Timeout: 120s.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        steps: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              command: {
+                type: "string",
+                enum: ["snapshot", "click", "type", "wait", "evaluate"],
+                description: "snapshot: accessibility tree of the page (waits for network to settle). click: click an element (animated cursor, full event sequence). type: type text into input (one char at a time, works with React/Vue/Svelte). wait: wait for an element to appear (polls 100ms, waits for network). evaluate: run JS in the page."
+              },
+              ref: {
+                type: "string",
+                description: "Element ref from the last snapshot (most reliable targeting)."
+              },
+              text: {
+                type: "string",
+                description: "For click/wait: match by accessible name or visible text. For type: the text to type."
+              },
+              role: {
+                type: "string",
+                description: "ARIA role to match (used with text for role+text targeting)."
+              },
+              label: {
+                type: "string",
+                description: "Find an input by its associated label text."
+              },
+              selector: {
+                type: "string",
+                description: "CSS selector fallback (last resort)."
+              },
+              clear: {
+                type: "boolean",
+                description: "For type: clear the field before typing."
+              },
+              timeout: {
+                type: "number",
+                description: "For wait: timeout in ms (default 5000)."
+              },
+              script: {
+                type: "string",
+                description: "For evaluate: JavaScript to run in the page."
+              }
+            },
+            required: ["command"]
+          }
+        }
+      },
+      required: ["steps"]
+    }
+  },
+  {
+    name: "screenshot",
+    description: "Capture a screenshot of the current page. Returns a CDN URL with dimensions.",
+    inputSchema: {
+      type: "object",
+      properties: {}
+    }
+  }
+];
+var BROWSER_EXTERNAL_TOOLS = /* @__PURE__ */ new Set(["browserCommand", "screenshot"]);
+
+// src/subagents/browserAutomation/prompt.ts
+import fs13 from "fs";
+import path7 from "path";
+var base = import.meta.dirname ?? path7.dirname(new URL(import.meta.url).pathname);
+var local = path7.join(base, "prompt.md");
+var PROMPT_PATH = fs13.existsSync(local) ? local : path7.join(base, "subagents", "browserAutomation", "prompt.md");
+var BROWSER_AUTOMATION_PROMPT = fs13.readFileSync(PROMPT_PATH, "utf-8").trim();
+
+// src/subagents/browserAutomation/index.ts
+var browserAutomationTool = {
+  definition: {
+    name: "runAutomatedBrowserTest",
+    description: "Run an automated browser test against the live preview. The test agent always starts on the main page, so include navigation instructions if the test involves a sub-page. The browser uses the current user roles and dev database state, so run a scenario first if you need specific data or roles. Use after writing or modifying frontend code, to reproduce user-reported issues, or to test end-to-end flows.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        task: {
+          type: "string",
+          description: "What to test, in natural language. Include how to navigate to the relevant page and what data/roles to expect."
+        }
+      },
+      required: ["task"]
+    }
+  },
+  async execute(input, context) {
+    if (!context) {
+      return "Error: browser automation requires execution context (only available in headless mode)";
+    }
+    return runSubAgent({
+      system: BROWSER_AUTOMATION_PROMPT,
+      task: input.task,
+      tools: BROWSER_TOOLS,
+      externalTools: BROWSER_EXTERNAL_TOOLS,
+      executeTool: async () => "Error: no local tools in browser automation",
+      apiConfig: context.apiConfig,
+      model: context.model,
+      signal: context.signal,
+      parentToolId: context.toolCallId,
+      onEvent: context.onEvent,
+      resolveExternalTool: context.resolveExternalTool
+    });
+  }
+};
+
 // src/tools/index.ts
 function getSpecTools() {
   return [readSpecTool, writeSpecTool, editSpecTool, listSpecFilesTool];
@@ -1808,7 +2126,11 @@ function getCodeTools() {
     globTool,
     listDirTool,
     editsFinishedTool,
-    askMindStudioSdkTool
+    askMindStudioSdkTool,
+    runScenarioTool,
+    runMethodTool,
+    screenshotTool,
+    browserAutomationTool
   ];
   if (isLspConfigured()) {
     tools.push(lspDiagnosticsTool, restartProcessTool);
@@ -1857,20 +2179,20 @@ function getToolByName(name) {
   ];
   return allTools.find((t) => t.definition.name === name);
 }
-function executeTool(name, input) {
+function executeTool(name, input, context) {
   const tool = getToolByName(name);
   if (!tool) {
     return Promise.resolve(`Error: Unknown tool "${name}"`);
   }
-  return tool.execute(input);
+  return tool.execute(input, context);
 }
 
 // src/session.ts
-import fs13 from "fs";
+import fs14 from "fs";
 var SESSION_FILE = ".remy-session.json";
 function loadSession(state) {
   try {
-    const raw = fs13.readFileSync(SESSION_FILE, "utf-8");
+    const raw = fs14.readFileSync(SESSION_FILE, "utf-8");
     const data = JSON.parse(raw);
     if (Array.isArray(data.messages) && data.messages.length > 0) {
       state.messages = sanitizeMessages(data.messages);
@@ -1912,7 +2234,7 @@ function sanitizeMessages(messages) {
 }
 function saveSession(state) {
   try {
-    fs13.writeFileSync(
+    fs14.writeFileSync(
       SESSION_FILE,
       JSON.stringify({ messages: state.messages }, null, 2),
       "utf-8"
@@ -1923,7 +2245,7 @@ function saveSession(state) {
 function clearSession(state) {
   state.messages = [];
   try {
-    fs13.unlinkSync(SESSION_FILE);
+    fs14.unlinkSync(SESSION_FILE);
   } catch {
   }
 }
@@ -2099,7 +2421,11 @@ var EXTERNAL_TOOLS = /* @__PURE__ */ new Set([
   "presentSyncPlan",
   "presentPublishPlan",
   "presentPlan",
-  "confirmDestructiveAction"
+  "confirmDestructiveAction",
+  "runScenario",
+  "runMethod",
+  "browserCommand",
+  "screenshot"
 ]);
 function createAgentState() {
   return { messages: [] };
@@ -2205,6 +2531,9 @@ async function runTurn(params) {
       }
       if (transform) {
         const result = await transform(partial);
+        if (result === null) {
+          return;
+        }
         log.debug("Streaming content tool: emitting tool_input_delta", {
           id,
           name,
@@ -2276,7 +2605,7 @@ async function runTurn(params) {
             const tool = getToolByName(event.name);
             const wasStreamed = acc?.started ?? false;
             const isInputStreaming = !!tool?.streaming?.partialInput;
-            log.debug("Received tool_use", {
+            log.info("Tool call received", {
               id: event.id,
               name: event.name,
               wasStreamed,
@@ -2346,16 +2675,23 @@ async function runTurn(params) {
           let result;
           if (EXTERNAL_TOOLS.has(tc.name) && resolveExternalTool) {
             saveSession(state);
-            log.debug("Waiting for external tool result", {
+            log.info("Waiting for external tool result", {
               name: tc.name,
               id: tc.id
             });
             result = await resolveExternalTool(tc.id, tc.name, tc.input);
           } else {
-            result = await executeTool(tc.name, tc.input);
+            result = await executeTool(tc.name, tc.input, {
+              apiConfig,
+              model,
+              signal,
+              onEvent,
+              resolveExternalTool,
+              toolCallId: tc.id
+            });
           }
           const isError = result.startsWith("Error");
-          log.debug("Tool completed", {
+          log.info("Tool completed", {
             name: tc.name,
             elapsed: `${Date.now() - toolStart}ms`,
             isError,
@@ -2399,10 +2735,10 @@ async function runTurn(params) {
 }
 
 // src/headless.ts
-var BASE_DIR = import.meta.dirname ?? path7.dirname(new URL(import.meta.url).pathname);
-var ACTIONS_DIR = path7.join(BASE_DIR, "actions");
+var BASE_DIR = import.meta.dirname ?? path8.dirname(new URL(import.meta.url).pathname);
+var ACTIONS_DIR = path8.join(BASE_DIR, "actions");
 function loadActionPrompt(name) {
-  return fs14.readFileSync(path7.join(ACTIONS_DIR, `${name}.md`), "utf-8").trim();
+  return fs15.readFileSync(path8.join(ACTIONS_DIR, `${name}.md`), "utf-8").trim();
 }
 function emit(event, data) {
   process.stdout.write(JSON.stringify({ event, ...data }) + "\n");
@@ -2435,20 +2771,32 @@ async function startHeadless(opts = {}) {
   function onEvent(e) {
     switch (e.type) {
       case "text":
-        emit("text", { text: e.text });
+        emit("text", {
+          text: e.text,
+          ...e.parentToolId && { parentToolId: e.parentToolId }
+        });
         break;
       case "thinking":
-        emit("thinking", { text: e.text });
+        emit("thinking", {
+          text: e.text,
+          ...e.parentToolId && { parentToolId: e.parentToolId }
+        });
         break;
       case "tool_input_delta":
-        emit("tool_input_delta", { id: e.id, name: e.name, result: e.result });
+        emit("tool_input_delta", {
+          id: e.id,
+          name: e.name,
+          result: e.result,
+          ...e.parentToolId && { parentToolId: e.parentToolId }
+        });
         break;
       case "tool_start":
         emit("tool_start", {
           id: e.id,
           name: e.name,
           input: e.input,
-          ...e.partial && { partial: true }
+          ...e.partial && { partial: true },
+          ...e.parentToolId && { parentToolId: e.parentToolId }
         });
         break;
       case "tool_done":
@@ -2456,7 +2804,8 @@ async function startHeadless(opts = {}) {
           id: e.id,
           name: e.name,
           result: e.result,
-          isError: e.isError
+          isError: e.isError,
+          ...e.parentToolId && { parentToolId: e.parentToolId }
         });
         break;
       case "turn_started":