@muggleai/works 4.3.0 → 4.4.0

package/dist/{chunk-23NOSJFH.js → chunk-PMI2DI3V.js}

@@ -2837,7 +2837,7 @@ var LocalExecutionContextInputSchema = z.object({
   electronAppVersion: z.string().optional().describe("Electron app version used for local run"),
   mcpServerVersion: z.string().optional().describe("MCP server version used for local run"),
   localExecutionCompletedAt: z.number().int().positive().describe("Epoch milliseconds when local run completed"),
-  uploadedAt: z.number().int().positive().optional().describe("Epoch milliseconds when uploaded to cloud")
+  uploadedAt: z.number().int().positive().describe("Epoch milliseconds when uploaded to cloud")
 });
 var LocalRunUploadInputSchema = z.object({
   projectId: MuggleEntityIdSchema.describe("Project ID (UUID) for the local run"),
@@ -5985,6 +5985,281 @@ async function startStdioServer(server) {
   process.on("SIGTERM", () => shutdown("SIGTERM"));
   process.on("SIGINT", () => shutdown("SIGINT"));
 }
+
+// src/cli/pr-section/selectors.ts
+var ONE_LINER_BUDGET = 160;
+function selectHero(report) {
+  const firstFailed = report.tests.find(
+    (t) => t.status === "failed"
+  );
+  if (firstFailed) {
+    const step = firstFailed.steps.find((s) => s.stepIndex === firstFailed.failureStepIndex);
+    if (step) {
+      return {
+        screenshotUrl: step.screenshotUrl,
+        testName: firstFailed.name,
+        kind: "failure"
+      };
+    }
+  }
+  const firstPassedWithSteps = report.tests.find(
+    (t) => t.status === "passed" && t.steps.length > 0
+  );
+  if (firstPassedWithSteps) {
+    const lastStep = firstPassedWithSteps.steps[firstPassedWithSteps.steps.length - 1];
+    return {
+      screenshotUrl: lastStep.screenshotUrl,
+      testName: firstPassedWithSteps.name,
+      kind: "final"
+    };
+  }
+  return null;
+}
+function buildOneLiner(report) {
+  const total = report.tests.length;
+  if (total === 0) {
+    return "No acceptance tests were executed.";
+  }
+  const failed = report.tests.filter((t) => t.status === "failed");
+  if (failed.length === 0) {
+    return `All ${total} acceptance tests passed.`;
+  }
+  const first = failed[0];
+  const prefix = `${failed.length} of ${total} failed \u2014 "${first.name}" broke at step ${first.failureStepIndex}: `;
+  const available = ONE_LINER_BUDGET - prefix.length - 1;
+  const error = first.error.length > available ? first.error.slice(0, Math.max(0, available - 1)) + "\u2026" : first.error;
+  return `${prefix}${error}.`;
+}
+
+// src/cli/pr-section/render.ts
+var DASHBOARD_URL_BASE = "https://www.muggle-ai.com/muggleTestV0/dashboard/projects";
+var ROW_THUMB_WIDTH = 120;
+var DETAIL_THUMB_WIDTH = 200;
+var HERO_WIDTH = 480;
+function thumbnail(url, width) {
+  return `<a href="${url}"><img src="${url}" width="${width}"></a>`;
+}
+function counts(report) {
+  const passed = report.tests.filter((t) => t.status === "passed").length;
+  const failed = report.tests.filter((t) => t.status === "failed").length;
+  return { passed, failed, text: `**${passed} passed / ${failed} failed**` };
+}
+function renderSummary(report) {
+  const { text: countsLine } = counts(report);
+  const oneLiner = buildOneLiner(report);
+  const hero = selectHero(report);
+  const dashboard = `${DASHBOARD_URL_BASE}/${report.projectId}/scripts`;
+  const lines = [
+    countsLine,
+    "",
+    oneLiner,
+    ""
+  ];
+  if (hero) {
+    lines.push(
+      `<a href="${hero.screenshotUrl}"><img src="${hero.screenshotUrl}" width="${HERO_WIDTH}" alt="${hero.testName}"></a>`,
+      ""
+    );
+  }
+  lines.push(`[View project dashboard on muggle-ai.com](${dashboard})`);
+  return lines.join("\n");
+}
+function renderRow(test) {
+  const link = `[${test.name}](${test.viewUrl})`;
+  if (test.status === "passed") {
+    const lastStep = test.steps[test.steps.length - 1];
+    const thumb2 = lastStep ? thumbnail(lastStep.screenshotUrl, ROW_THUMB_WIDTH) : "\u2014";
+    return `| ${link} | \u2705 PASSED | ${thumb2} |`;
+  }
+  const failStep = test.steps.find((s) => s.stepIndex === test.failureStepIndex);
+  const thumb = failStep ? thumbnail(failStep.screenshotUrl, ROW_THUMB_WIDTH) : "\u2014";
+  return `| ${link} | \u274C FAILED \u2014 ${test.error} | ${thumb} |`;
+}
+function renderFailureDetails(test) {
+  const stepCount = test.steps.length;
+  const header2 = `<details>
+<summary>\u{1F4F8} <strong>${test.name}</strong> \u2014 ${stepCount} steps (failed at step ${test.failureStepIndex})</summary>
+
+| # | Action | Screenshot |
+|---|--------|------------|`;
+  const rows = test.steps.map((step) => renderFailureStepRow(step, test)).join("\n");
+  return `${header2}
+${rows}
+
+</details>`;
+}
+function renderFailureStepRow(step, test) {
+  const isFailure = step.stepIndex === test.failureStepIndex;
+  const marker = isFailure ? `${step.stepIndex} \u26A0\uFE0F` : String(step.stepIndex);
+  const action = isFailure ? `${step.action} \u2014 **${test.error}**` : step.action;
+  return `| ${marker} | ${action} | ${thumbnail(step.screenshotUrl, DETAIL_THUMB_WIDTH)} |`;
+}
+function renderRowsTable(report) {
+  if (report.tests.length === 0) {
+    return "_No tests were executed._";
+  }
+  const header2 = "| Test Case | Status | Evidence |\n|-----------|--------|----------|";
+  const rows = report.tests.map(renderRow).join("\n");
+  return `${header2}
+${rows}`;
+}
+function renderBody(report, opts) {
+  const sections = [
+    "## E2E Acceptance Results",
+    "",
+    renderSummary(report),
+    "",
+    renderRowsTable(report)
+  ];
+  const failures = report.tests.filter((t) => t.status === "failed");
+  if (failures.length > 0) {
+    if (opts.inlineFailureDetails) {
+      sections.push("", ...failures.map(renderFailureDetails));
+    } else {
+      sections.push(
+        "",
+        "_Full step-by-step evidence in the comment below \u2014 the PR description was too large to inline it._"
+      );
+    }
+  }
+  return sections.join("\n");
+}
+function renderComment(report) {
+  const failures = report.tests.filter((t) => t.status === "failed");
+  if (failures.length === 0) {
+    return "";
+  }
+  const sections = [
+    "## E2E acceptance evidence (overflow)",
+    "",
+    "_This comment was posted because the full step-by-step evidence did not fit in the PR description._",
+    "",
+    ...failures.map(renderFailureDetails)
+  ];
+  return sections.join("\n");
+}
+
+// src/cli/pr-section/overflow.ts
+function splitWithOverflow(report, opts) {
+  const inlineBody = renderBody(report, { inlineFailureDetails: true });
+  const inlineBytes = Buffer.byteLength(inlineBody, "utf-8");
+  if (inlineBytes <= opts.maxBodyBytes) {
+    return { body: inlineBody, comment: null };
+  }
+  const spilledBody = renderBody(report, { inlineFailureDetails: false });
+  const comment = renderComment(report);
+  return {
+    body: spilledBody,
+    comment: comment.length > 0 ? comment : null
+  };
+}
+var StepSchema = z.object({
+  stepIndex: z.number().int().nonnegative(),
+  action: z.string().min(1),
+  screenshotUrl: z.string().url()
+});
+var PassedTestSchema = z.object({
+  name: z.string().min(1),
+  testCaseId: z.string().min(1),
+  testScriptId: z.string().min(1).optional(),
+  runId: z.string().min(1),
+  viewUrl: z.string().url(),
+  status: z.literal("passed"),
+  steps: z.array(StepSchema)
+});
+var FailedTestSchema = z.object({
+  name: z.string().min(1),
+  testCaseId: z.string().min(1),
+  testScriptId: z.string().min(1).optional(),
+  runId: z.string().min(1),
+  viewUrl: z.string().url(),
+  status: z.literal("failed"),
+  steps: z.array(StepSchema),
+  failureStepIndex: z.number().int().nonnegative(),
+  error: z.string().min(1),
+  artifactsDir: z.string().min(1).optional()
+});
+var TestResultSchema = z.discriminatedUnion("status", [
+  PassedTestSchema,
+  FailedTestSchema
+]);
+var E2eReportSchema = z.object({
+  projectId: z.string().min(1),
+  tests: z.array(TestResultSchema)
+});
+
+// src/cli/pr-section/index.ts
+function buildPrSection(report, opts) {
+  return splitWithOverflow(report, opts);
+}
+
+// src/cli/build-pr-section.ts
+var DEFAULT_MAX_BODY_BYTES = 6e4;
+async function readAll(stream) {
+  const chunks = [];
+  for await (const chunk of stream) {
+    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+  }
+  return Buffer.concat(chunks).toString("utf-8");
+}
+function errMsg(e) {
+  return e instanceof Error ? e.message : String(e);
+}
+async function runBuildPrSection(opts) {
+  let raw;
+  try {
+    raw = await readAll(opts.stdin);
+  } catch (err) {
+    opts.stderrWrite(`build-pr-section: failed to read stdin: ${errMsg(err)}
+`);
+    return 1;
+  }
+  let json;
+  try {
+    json = JSON.parse(raw);
+  } catch (err) {
+    opts.stderrWrite(`build-pr-section: failed to parse stdin as JSON: ${errMsg(err)}
+`);
+    return 1;
+  }
+  let report;
+  try {
+    report = E2eReportSchema.parse(json);
+  } catch (err) {
+    if (err instanceof ZodError) {
+      opts.stderrWrite(
+        `build-pr-section: report validation failed:
+${err.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n")}
+`
+      );
+    } else {
+      opts.stderrWrite(`build-pr-section: report validation failed: ${errMsg(err)}
+`);
+    }
+    return 1;
+  }
+  const result = buildPrSection(report, { maxBodyBytes: opts.maxBodyBytes });
+  opts.stdoutWrite(JSON.stringify({ body: result.body, comment: result.comment }));
+  return 0;
+}
+async function buildPrSectionCommand(options) {
+  const maxBodyBytes = options.maxBodyBytes ? Number(options.maxBodyBytes) : DEFAULT_MAX_BODY_BYTES;
+  if (!Number.isFinite(maxBodyBytes) || maxBodyBytes <= 0) {
+    process.stderr.write(`build-pr-section: --max-body-bytes must be a positive number
+`);
+    process.exitCode = 1;
+    return;
+  }
+  const code = await runBuildPrSection({
+    stdin: process.stdin,
+    stdoutWrite: (s) => process.stdout.write(s),
+    stderrWrite: (s) => process.stderr.write(s),
+    maxBodyBytes
+  });
+  if (code !== 0) {
+    process.exitCode = code;
+  }
+}
 var logger7 = getLogger();
 var ELECTRON_APP_DIR2 = "electron-app";
 var CURSOR_SKILLS_DIR = ".cursor";
@@ -7362,6 +7637,7 @@ function createProgram() {
   program.command("login").description("Authenticate with Muggle AI (uses device code flow)").option("--key-name <name>", "Name for the API key").option("--key-expiry <expiry>", "API key expiry: 30d, 90d, 1y, never", "90d").action(loginCommand);
   program.command("logout").description("Clear stored credentials").action(logoutCommand);
   program.command("status").description("Show authentication status").action(statusCommand);
+  program.command("build-pr-section").description("Render a muggle-do PR body evidence block from an e2e report on stdin").option("--max-body-bytes <n>", "Max UTF-8 byte budget for the PR body (default 60000)").action(buildPrSectionCommand);
   program.action(() => {
     helpCommand();
   });

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { runCli } from './chunk-23NOSJFH.js';
+import { runCli } from './chunk-PMI2DI3V.js';
 
 // src/cli/main.ts
 runCli().catch((error) => {

package/dist/index.js

@@ -1 +1 @@
-export { src_exports2 as commands, createChildLogger, createUnifiedMcpServer, e2e_exports as e2e, getConfig, getLocalQaTools, getLogger, getQaTools, local_exports as localQa, mcp_exports as mcp, e2e_exports as qa, server_exports as server, src_exports as shared } from './chunk-23NOSJFH.js';
+export { src_exports2 as commands, createChildLogger, createUnifiedMcpServer, e2e_exports as e2e, getConfig, getLocalQaTools, getLogger, getQaTools, local_exports as localQa, mcp_exports as mcp, e2e_exports as qa, server_exports as server, src_exports as shared } from './chunk-PMI2DI3V.js';

package/dist/plugin/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "muggle",
   "description": "Run real-browser end-to-end (E2E) acceptance tests on your web app from any AI coding agent. Generate test scripts from plain English, replay them on localhost, capture screenshots, and validate user flows like signup, checkout, and dashboards. Works across Claude Code, Cursor, Codex, and Windsurf.",
-  "version": "4.3.0",
+  "version": "4.4.0",
   "author": {
     "name": "Muggle AI",
     "email": "support@muggle-ai.com"

package/dist/plugin/.cursor-plugin/plugin.json

@@ -2,7 +2,7 @@
   "name": "muggle",
   "displayName": "Muggle AI",
   "description": "Ship quality products with AI-powered end-to-end (E2E) acceptance testing that validates your web app like a real user — from Claude Code and Cursor to PR.",
-  "version": "4.3.0",
+  "version": "4.4.0",
   "author": {
     "name": "Muggle AI",
     "email": "support@muggle-ai.com"

package/dist/plugin/skills/do/open-prs.md

@@ -27,90 +27,96 @@ For each repo with changes:
    - `## Goal` — the requirements goal
    - `## Acceptance Criteria` — bulleted list (omit section if empty)
    - `## Changes` — summary of what changed in this repo
-   - `## E2E Acceptance Results` — summary table (see format below)
+   - E2E acceptance evidence block from `muggle build-pr-section` (see "Rendering the E2E acceptance results block" below)
 4. **Create the PR** using `gh pr create --title "..." --body "..." --head <branch>` in the repo directory.
 5. **Capture the PR URL** and extract the PR number.
-6. **Post E2E acceptance evidence comment** with screenshots (see format below).
-
-## E2E acceptance results section format (PR body)
-
-```markdown
-## E2E Acceptance Results
-
-**X passed / Y failed**
-
-| Test Case | Status | Details |
-|-----------|--------|---------|
-| [Name]({viewUrl}) | ✅ PASSED | — |
-| [Name]({viewUrl}) | ❌ FAILED | {error} |
+6. **Post the overflow comment only if `muggle build-pr-section` emitted one** (see "Rendering the E2E acceptance results block" below). In the common case, no comment is posted.
+
+## Rendering the E2E acceptance results block
+
+Do **not** hand-write the `## E2E Acceptance Results` markdown. Use the `muggle build-pr-section` CLI, which renders a deterministic block and decides whether the evidence fits in the PR description or needs to spill into an overflow comment.
+
+### Step A: Build the report JSON
+
+Assemble the e2e-acceptance report you collected in `e2e-acceptance.md` into a JSON object with this shape:
+
+```json
+{
+  "projectId": "<project UUID>",
+  "tests": [
+    {
+      "name": "<test case name>",
+      "testCaseId": "<UUID>",
+      "testScriptId": "<UUID or omitted>",
+      "runId": "<UUID>",
+      "viewUrl": "<muggle-ai.com run URL>",
+      "status": "passed",
+      "steps": [
+        { "stepIndex": 0, "action": "<action>", "screenshotUrl": "<URL>" }
+      ]
+    },
+    {
+      "name": "<test case name>",
+      "testCaseId": "<UUID>",
+      "runId": "<UUID>",
+      "viewUrl": "<muggle-ai.com run URL>",
+      "status": "failed",
+      "failureStepIndex": 2,
+      "error": "<error message>",
+      "artifactsDir": "<path, optional>",
+      "steps": [
+        { "stepIndex": 0, "action": "<action>", "screenshotUrl": "<URL>" }
+      ]
+    }
+  ]
+}
 ```
 
-## E2E acceptance evidence comment format
+### Step B: Render the evidence block
 
-After creating the PR, post a comment with embedded screenshots:
+Pipe the JSON into `muggle build-pr-section`. It writes `{ "body": "...", "comment": "..." | null }` to stdout:
 
 ```bash
-gh pr comment <PR#> --body "$(cat <<'EOF'
-## 🧪 E2E acceptance evidence
-
-**X passed / Y failed**
-
-| Test Case | Status | Summary |
-|-----------|--------|---------|
-| [Login Flow]({viewUrl}) | ✅ PASSED | <a href="{lastStepScreenshotUrl}"><img src="{lastStepScreenshotUrl}" width="120"></a> |
-| [Checkout]({viewUrl}) | ❌ FAILED | <a href="{failureStepScreenshotUrl}"><img src="{failureStepScreenshotUrl}" width="120"></a> |
-
-<details>
-<summary>📸 <strong>Login Flow</strong> — 5 steps</summary>
-
-| # | Action | Screenshot |
-|---|--------|------------|
-| 1 | Navigate to `/login` | <a href="{screenshotUrl}"><img src="{screenshotUrl}" width="200"></a> |
-| 2 | Enter username | <a href="{screenshotUrl}"><img src="{screenshotUrl}" width="200"></a> |
-| 3 | Click "Sign In" | <a href="{screenshotUrl}"><img src="{screenshotUrl}" width="200"></a> |
+echo "$REPORT_JSON" | muggle build-pr-section > /tmp/muggle-pr-section.json
+```
 
-</details>
+The command exits nonzero on malformed input and writes a descriptive error to stderr — do not swallow that error, surface it to the user.
 
-<details>
-<summary>📸 <strong>Checkout</strong> — 4 steps (failed at step 3)</summary>
+### Step C: Build the PR body
 
-| # | Action | Screenshot |
-|---|--------|------------|
-| 1 | Add item to cart | <a href="{screenshotUrl}"><img src="{screenshotUrl}" width="200"></a> |
-| 2 | View cart | <a href="{screenshotUrl}"><img src="{screenshotUrl}" width="200"></a> |
-| 3 ⚠️ | Click confirm — **Element not found** | <a href="{screenshotUrl}"><img src="{screenshotUrl}" width="200"></a> |
+Build the PR body by concatenating, in order:
 
-</details>
-EOF
-)"
-```
+- `## Goal` — the requirements goal
+- `## Acceptance Criteria` — bulleted list (omit section if empty)
+- `## Changes` — summary of what changed in this repo
+- The `body` field from the CLI output (already contains its own `## E2E Acceptance Results` header)
 
-### Comment Building Rules
+### Step D: Create the PR, then post the overflow comment only if present
 
-1. **Summary table:**
-   - Show thumbnail (120px) of **last step** for passed tests
-   - Show thumbnail of **failure step** for failed tests
-   - Thumbnail links to full-size image
+1. Create the PR with `gh pr create --title "..." --body "..." --head <branch>`.
+2. Capture the PR URL and extract the PR number.
+3. If the CLI output's `comment` field is `null`, **do not post a comment** — everything is already in the PR description.
+4. If the CLI output's `comment` field is a non-null string, post it as a follow-up comment:
 
-2. **Collapsible details per test case:**
-   - Show all steps with 200px thumbnails
-   - Mark failure step with ⚠️ and inline error message
-   - Include step count in summary line
+   ```bash
+   gh pr comment <PR#> --body "$(cat <<'EOF'
+   <comment field contents>
+   EOF
+   )"
+   ```
 
-3. **HTML for thumbnails:**
-   - Use `<a href="{url}"><img src="{url}" width="N"></a>` for clickable thumbnails
-   - 120px width in summary table, 200px in details
+### Notes on fit vs. overflow
 
-4. **All tests get screenshots:**
-   - Passing tests show proof of success
-   - Failing tests highlight the failure point
+- **The common case is fit**: the full evidence (summary, per-test rows, collapsible failure details) lives in the PR description, no comment is posted.
+- **The overflow case** is triggered automatically when the full inline body would exceed the CLI's budget. In that case the PR description contains the summary, the per-test rows, and a pointer line; the full step-by-step failure details live in the follow-up comment.
+- You do not make the fit-vs-overflow decision — the CLI does. Never post the comment speculatively.
 
 ## Output
 
 **PRs Created:**
 - (repo name): (PR URL)
 
-**E2E acceptance evidence comments posted:**
+**E2E acceptance overflow comments posted:** (only include repos where an overflow comment was actually posted)
 - (repo name): comment posted to PR #(number)
 
 **Errors:** (any repos where PR creation or comment posting failed, with the error message)

package/dist/plugin/skills/muggle/SKILL.md

@@ -9,24 +9,24 @@ Use this as the top-level Muggle command router.
 
 ## Menu
 
-When user asks for "muggle" with no specific subcommand, show this command set:
+When user asks for "muggle" with no specific subcommand, use `AskQuestion` to present the command set as clickable options:
 
-- `/muggle:muggle-do` — autonomous dev pipeline
-- `/muggle:muggle-test` — change-driven E2E acceptance testing (local or remote, with PR posting)
-- `/muggle:muggle-test-feature-local` — local feature E2E acceptance testing
-- `/muggle:muggle-status` — health check
-- `/muggle:muggle-repair` — repair broken installation
-- `/muggle:muggle-upgrade` — upgrade local installation
+- "Test my changes — change-driven E2E acceptance testing (local or remote)" → `muggle-test`
+- "Test a feature on localhost — run a single E2E test locally" → `muggle-test-feature-local`
+- "Autonomous dev pipeline — requirements to PR" → `muggle-do`
+- "Health check — verify installation status" → `muggle-status`
+- "Repair — fix broken installation" → `muggle-repair`
+- "Upgrade — update to latest version" → `muggle-upgrade`
 
 ## Routing
 
-If the user intent clearly matches one command, route to that command behavior:
+If the user intent clearly matches one command, route directly — no menu needed:
 
-- status/health/check -> `muggle-status`
-- repair/fix/install broken -> `muggle-repair`
-- upgrade/update latest -> `muggle-upgrade`
-- test my changes/acceptance test my work/test before push/post E2E acceptance results to PR/test on staging/test on preview -> `muggle-test`
-- test localhost/validate single feature -> `muggle-test-feature-local`
-- build/implement from request -> `muggle-do`
+- status/health/check → `muggle-status`
+- repair/fix/install broken → `muggle-repair`
+- upgrade/update latest → `muggle-upgrade`
+- test my changes/acceptance test my work/test before push/post E2E acceptance results to PR/test on staging/test on preview → `muggle-test`
+- test localhost/validate single feature → `muggle-test-feature-local`
+- build/implement from request → `muggle-do`
 
-If intent is ambiguous, ask one concise clarification question.
+If intent is ambiguous, use `AskQuestion` with the most likely options rather than asking the user to type a clarification.