@sideboard-ai/core 0.1.46 → 0.1.49

package/dist/mcp/run-stdio.cjs

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+
 "use strict";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -3300,7 +3301,7 @@ var init_coordinator_prompt = __esm({
       "- list_run_scripts / run_dev_script / stop_dev_script \u2014 start/stop named run scripts",
       "Inspect / review / PRs:",
       "- get_diff \u2014 compact diff summary",
-      "- request_review \u2014 open a Review chat tab on a worktree thread (merge-readiness recommendation); then wait_for_turn / get_turn_result on the returned id",
+      '- request_review \u2014 open a Review chat tab on a worktree thread (attaches .sideboard/review.md when present, else local guidelines; sends "Review."); then wait_for_turn / get_turn_result on the returned id',
       "- Ask the worktree agent via send_to_thread to open a draft PR with `gh pr create --draft -R <origin-owner/name>` (workspace `github:` slug / that worktree's origin \u2014 never upstream). Do not open PRs from the orchestrator yourself.",
       "Human-only (do not attempt): merge, ready-for-review land, purge_thread.",
       "Thread links in replies: when mentioning a chat/thread for the user, include a markdown link `[Title](sideboard://thread/<id>)` using the full id (or the link field from create_thread / list_threads). Sideboard renders these as clickable opens.",
@@ -7540,22 +7541,149 @@ var import_node_fs19 = require("fs");
 var import_node_path18 = require("path");
 init_global_workspace();
 init_thread_store();
+
+// src/review/review-request-template.ts
+var REVIEW_REQUEST_TEMPLATE = `# Review guidelines:
+
+You are reviewing a proposed code change so a human can decide whether it is **ready to merge / land**. Findings matter, but the primary deliverable is a clear readiness recommendation \u2014 not a laundry list of style notes.
+
+## Required outcome
+
+Start your reply with a **Recommendation** section using exactly one of:
+
+- **Approve** \u2014 ready to merge as-is (or with only trivial nits the author can ignore).
+- **Approve with nits** \u2014 ready to merge; list only optional polish that should not block.
+- **Request changes** \u2014 not ready; blocking issues must be fixed first.
+- **Needs more information** \u2014 cannot judge readiness yet (missing context, incomplete diff, unclear intent).
+
+In 1\u20133 sentences, say **why** \u2014 grounded in correctness, risk, test coverage, and scope \u2014 not vibes. If you request changes, name the blockers explicitly.
+
+People running this review are asking \u201Ccan we ship this?\u201D Treat that as the question you answer first.
+
+## Findings
+
+Below are guidelines for determining whether an issue is worth flagging to the original author.
+
+These are not the final word. More specific guidelines elsewhere (developer message, user message, a file, etc.) override these.
+
+Flag something as a bug / blocking finding only when:
+
+1. It meaningfully impacts the accuracy, performance, security, or maintainability of the code.
+2. The bug is discrete and actionable (not a vague codebase-wide complaint or a bundle of unrelated issues).
+3. Fixing it does not demand rigor absent from the rest of the codebase.
+4. The issue was introduced by this change (do not flag pre-existing bugs unless they are newly exposed by this PR).
+5. The author would likely fix it if made aware.
+6. It does not rely on unstated assumptions about the codebase or author intent.
+7. Speculative breakage is not enough \u2014 identify the other code that is provably affected.
+8. It is clearly not just an intentional change by the author.
+
+When flagging an issue, include a short accompanying comment:
+
+1. Clear about why it is a problem.
+2. Severity must match reality \u2014 do not inflate.
+3. Brief: at most one paragraph; avoid unnecessary line breaks in prose.
+4. No code chunks longer than 3 lines; wrap code in inline ticks or a fenced block.
+5. Call out scenarios / environments / inputs needed to hit the bug when severity depends on them.
+6. Matter-of-fact tone \u2014 helpful assistant, not accusatory or effusive.
+7. Skimmable on first read.
+8. No empty flattery (\u201CGreat job\u2026\u201D, \u201CThanks for\u2026\u201D).
+
+HOW MANY FINDINGS TO RETURN:
+
+List every finding the author would fix if they knew about it. If nothing qualifies, say so and still give the Recommendation. Do not stop at the first finding.
+
+GUIDELINES:
+
+- Ignore trivial style unless it obscures meaning or violates documented standards.
+- One comment per distinct issue (or a short multi-line range if needed).
+- Use \`\`\`suggestion blocks ONLY for concrete replacement code (minimal lines; no commentary inside the block).
+- In every \`\`\`suggestion block, preserve the exact leading whitespace of the replaced lines (spaces vs tabs, number of spaces).
+- Do NOT introduce or remove outer indentation levels unless that is the actual fix.
+- Separate **blocking** findings from **nits**. Only blocking findings should drive Request changes.
+
+The report appears in chat (and can become Sideboard diff comments). Avoid unnecessary location chatter in the body; keep line ranges as short as possible (prefer \u22645\u201310 lines).
+
+## Getting the diff
+
+Use Sideboard's diff for this thread's worktree. Prefer the \`get_diff\` MCP tool (pass this thread's ref) for a compact summary, then read specific files with Read/Glob as needed. In the Sideboard desktop app, the Changes panel shows the same worktree diff.
+
+If the user asks you to address or read line comments they added in the Changes / file diff UI, those arrive as \`diff-comment\` attachments on the next turn \u2014 follow them precisely.
+
+## Fallback: if you don't have access to the Sideboard diff tool
+
+If you don't have access to \`get_diff\`, use the following git commands to get the diff:
+
+\`\`\`bash
+# Get the merge base between this branch and the target
+MERGE_BASE=$(git merge-base origin/main HEAD)
+
+# Get the committed diff against the merge base
+git diff $MERGE_BASE HEAD
+
+# Get any uncommitted changes (staged and unstaged)
+git diff HEAD
+\`\`\`
+
+Review the combination of both outputs: the first shows all committed changes on this branch relative to the target, and the second shows any uncommitted work in progress.
+
+No need to mention in your report whether or not you used one of the fallback strategies; it's usually irrelevant.
+
+## Output format
+
+**1. Recommendation first** (required), then **2. Findings** (may be empty).
+
+Only report ONE finding per unique issue.
+
+<example>
+## Recommendation
+
+**Request changes** \u2014 The empty-input crash on load will break first-run users; fix that before merge. The unused helper is a nit and can wait.
+
+## Findings
+
+### **#1 Empty input causes crash** (blocking)
+
+If the input field is empty when the page loads, the app will crash.
+
+File: src/client/frontends/desktop/ui/Input.tsx
+
+### **#2 Dead code** (nit)
+
+The getUserData function is now unused. It should be deleted.
+
+File: src/client/frontends/desktop/core/UserData.ts
+</example>
+
+<example>
+## Recommendation
+
+**Approve** \u2014 Diff is scoped, behavior looks correct, and there are no blocking issues. Safe to merge.
+</example>
+`;
+
+// src/review/request-review.ts
+var REPO_REVIEW_PATH = ".sideboard/review.md";
+var REPO_REVIEW_NAME = "review.md";
 var REVIEW_REQUEST_PATH = ".sideboard/attachments/Review request.md";
 var REVIEW_REQUEST_NAME = "Review request.md";
-var REVIEW_REQUEST_PREFILL = `Please review the changes in this workspace and recommend whether they are ready to merge.
-
-Start with a **Recommendation**: Approve, Approve with nits, Request changes, or Needs more information \u2014 and say why in 1\u20133 sentences. Then list blocking findings vs nits (findings may be empty).`;
-function buildReviewRequestAttachment(content) {
-  return {
-    id: (0, import_node_crypto3.randomUUID)(),
-    name: REVIEW_REQUEST_NAME,
-    kind: "file",
-    path: REVIEW_REQUEST_PATH,
-    content
-  };
+var REVIEW_REQUEST_PREFILL = "Review.";
+var ATTACHMENTS_GITIGNORE = `# Sideboard review / composer attachments (local only)
+*
+!.gitignore
+`;
+var LEGACY_REVIEW_TEMPLATE_MARKERS = [
+  "You are acting as a reviewer for a proposed code change made by another engineer.",
+  "HOW MANY FINDINGS TO RETURN:"
+];
+function shouldRefreshReviewRequestTemplate(content) {
+  const trimmed = content.trim();
+  if (!trimmed) return true;
+  if (/##\s*Recommendation|ready to merge|Approve with nits|Request changes/i.test(trimmed)) {
+    return false;
+  }
+  return LEGACY_REVIEW_TEMPLATE_MARKERS.every((m) => trimmed.includes(m));
 }
-function readExistingReviewRequestFile(worktreePath) {
-  const abs = (0, import_node_path18.join)(worktreePath, REVIEW_REQUEST_PATH);
+function readTextIfPresent(abs) {
   if (!(0, import_node_fs19.existsSync)(abs)) return null;
   try {
     const content = (0, import_node_fs19.readFileSync)(abs, "utf8");
@@ -7564,6 +7692,54 @@ function readExistingReviewRequestFile(worktreePath) {
     return null;
   }
 }
+function ensureAttachmentsGitignore(worktreePath) {
+  const gitignoreAbs = (0, import_node_path18.join)(worktreePath, ".sideboard", "attachments", ".gitignore");
+  if ((0, import_node_fs19.existsSync)(gitignoreAbs)) return;
+  (0, import_node_fs19.mkdirSync)((0, import_node_path18.dirname)(gitignoreAbs), { recursive: true });
+  (0, import_node_fs19.writeFileSync)(gitignoreAbs, ATTACHMENTS_GITIGNORE, "utf8");
+}
+function resolveReviewGuidelines(worktreePath) {
+  const repoAbs = (0, import_node_path18.join)(worktreePath, REPO_REVIEW_PATH);
+  const repoContent = readTextIfPresent(repoAbs);
+  if (repoContent) {
+    return {
+      path: REPO_REVIEW_PATH,
+      name: REPO_REVIEW_NAME,
+      content: repoContent,
+      source: "repo"
+    };
+  }
+  const localAbs = (0, import_node_path18.join)(worktreePath, REVIEW_REQUEST_PATH);
+  const localContent = readTextIfPresent(localAbs);
+  if (localContent && !shouldRefreshReviewRequestTemplate(localContent)) {
+    return {
+      path: REVIEW_REQUEST_PATH,
+      name: REVIEW_REQUEST_NAME,
+      content: localContent,
+      source: "local"
+    };
+  }
+  ensureAttachmentsGitignore(worktreePath);
+  (0, import_node_fs19.mkdirSync)((0, import_node_path18.dirname)(localAbs), { recursive: true });
+  (0, import_node_fs19.writeFileSync)(localAbs, REVIEW_REQUEST_TEMPLATE, "utf8");
+  return {
+    path: REVIEW_REQUEST_PATH,
+    name: REVIEW_REQUEST_NAME,
+    content: REVIEW_REQUEST_TEMPLATE,
+    source: "stock"
+  };
+}
+function buildReviewRequestAttachment(content, opts) {
+  const path = opts?.path ?? REVIEW_REQUEST_PATH;
+  const name = opts?.name ?? (path === REPO_REVIEW_PATH ? REPO_REVIEW_NAME : REVIEW_REQUEST_NAME);
+  return {
+    id: (0, import_node_crypto3.randomUUID)(),
+    name,
+    kind: "file",
+    path,
+    content
+  };
+}
 async function requestReview(threadRef, send) {
   const from = findThreadByRef(threadRef);
   if (!from) throw new Error(`Thread not found: ${threadRef}`);
@@ -7575,12 +7751,16 @@ async function requestReview(threadRef, send) {
   if (from.status === "archived") {
     throw new Error(`Thread is archived: ${from.id}`);
   }
-  const existing = readExistingReviewRequestFile(from.worktreePath);
-  const attachments = existing ? [buildReviewRequestAttachment(existing)] : [];
+  const guidelines = resolveReviewGuidelines(from.worktreePath);
   const tab = createChatTab({
     fromThreadId: from.id,
     title: "Review",
-    attachments
+    attachments: [
+      buildReviewRequestAttachment(guidelines.content, {
+        path: guidelines.path,
+        name: guidelines.name
+      })
+    ]
   });
   const started = await send(tab.id, REVIEW_REQUEST_PREFILL);
   return { tab: started, from };
@@ -8964,7 +9144,7 @@ var IMAGE_MIME_BY_EXT = {
   ico: "image/x-icon"
 };
 var ATTACHMENTS_DIR = ".sideboard/attachments";
-var ATTACHMENTS_GITIGNORE = `# Sideboard review / composer attachments (local only)
+var ATTACHMENTS_GITIGNORE2 = `# Sideboard review / composer attachments (local only)
 *
 !.gitignore
 `;
@@ -8985,7 +9165,7 @@ function ensureAttachmentsDir(worktreePath) {
   (0, import_node_fs23.mkdirSync)(dir, { recursive: true });
   const gi = (0, import_node_path22.join)(dir, ".gitignore");
   if (!(0, import_node_fs23.existsSync)(gi)) {
-    (0, import_node_fs23.writeFileSync)(gi, ATTACHMENTS_GITIGNORE, "utf8");
+    (0, import_node_fs23.writeFileSync)(gi, ATTACHMENTS_GITIGNORE2, "utf8");
   }
   return dir;
 }
@@ -9769,9 +9949,11 @@ var Orchestrator = class {
       this.emit({ type: "error", threadId, message: `context compact failed: ${message}` });
       thread = this.requireThread(threadId);
     }
+    const sentAttachments = thread.attachments.length > 0 ? [...thread.attachments] : void 0;
     appendMessage(threadId, {
       role: "user",
       text: prompt,
+      ...sentAttachments ? { attachments: sentAttachments } : {},
       ts: (/* @__PURE__ */ new Date()).toISOString()
     });
     thread = this.requireThread(threadId);
@@ -9779,7 +9961,7 @@ var Orchestrator = class {
       thread.worktreePath,
       prompt,
       {
-        attachments: thread.attachments
+        attachments: sentAttachments ?? thread.attachments
       }
     );
     const orchestrationReminder = isOrchestratorThread(thread) ? coordinatorTurnReminder({
@@ -11139,7 +11321,7 @@ async function startMcpServer() {
   );
   server.tool(
     "request_review",
-    "Start a merge-readiness Review on a worktree agent thread (same as the desktop Review button). Opens a new Review chat tab, optionally attaches .sideboard/attachments/Review request.md when present, and asks for Approve / Approve with nits / Request changes / Needs more information. Pass a worktree thread ref \u2014 not the orchestrator. Then wait_for_turn / get_turn_result on the returned review tab id.",
+    'Start a merge-readiness Review on a worktree agent thread (same as the desktop Review button). Opens a new Review chat tab, attaches .sideboard/review.md when present (else local Review request.md / stock template), and sends "Review." Expect Approve / Approve with nits / Request changes / Needs more information. Pass a worktree thread ref \u2014 not the orchestrator. Then wait_for_turn / get_turn_result on the returned review tab id.',
     { ref: import_zod.z.string().describe("Worktree thread id/ref to review") },
     async ({ ref }) => {
       try {