mergestorm-mcp 0.2.21 → 0.2.23

package/README.md

@@ -1,6 +1,6 @@
 # mergestorm-mcp
 
-Stdio MCP server for Mergestorm. Tools: `whoami`, `credits`, `review_list`, `review_submit`, `review_wait`, `review_wait_pr`, `review_dismiss`, `issue_create`, `stack_adopt`, `stack_list`, `stack_publish`, `stack_publish_status`, `stack_set`, `stack_status`, `stack_wait`, `queue_status`, `settings_get`, `settings_set`.
+Stdio MCP server for Mergestorm. Tools: `whoami`, `credits`, `review_list`, `review_submit`, `review_wait`, `review_wait_pr`, `review_dismiss`, `issue_create`, `stack_adopt`, `stack_list`, `stack_publish`, `stack_publish_status`, `stack_set`, `stack_status`, `stack_wait`, `queue_status`, `settings_get`, `settings_set`, `repo_settings_get`, `repo_settings_set`.
 
 Every tool declares MCP `annotations` for read-only access, destructive changes, idempotence, and external systems. Reads are read-only; submission, adoption, dismissal, and policy changes are writes. Tools that can change existing policy, topology, or review gates are marked potentially destructive even when some inputs only preview or read. Annotations describe effects; the client still controls approval and authorization.
 

package/dist/index.js

@@ -6,7 +6,7 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 // src/server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z as z5 } from "zod";
-import { CommandError as CommandError13, BEARER_SETTINGS as BEARER_SETTINGS2 } from "mergestorm/client";
+import { CommandError as CommandError14, BEARER_SETTINGS as BEARER_SETTINGS2 } from "mergestorm/client";
 
 // src/brand-icons.ts
 var MARK_RECTS = [
@@ -897,8 +897,70 @@ async function settingsSet(args, cfg) {
   };
 }
 
+// src/tools/repo-settings.ts
+import {
+  CommandError as CommandError10,
+  REPO_SETTINGS_KEYS,
+  listRepoSettings,
+  patchRepoSettings
+} from "mergestorm/client";
+var ARG_BY_KEY = {
+  auto_patch_enabled: "auto_patch",
+  auto_review_enabled: "auto_review",
+  auto_land_default: "auto_land"
+};
+function parseRepo(raw) {
+  const match = typeof raw === "string" ? /^([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+)$/.exec(raw.trim()) : null;
+  if (!match) throw new CommandError10("repo takes <owner>/<repo>.", 2, "usage");
+  return { owner: match[1], repo: match[2] };
+}
+function words(value) {
+  return value === null ? "inherit" : value ? "on" : "off";
+}
+function repoSettingsSummary(entry) {
+  return `${entry.owner}/${entry.repo}: ${REPO_SETTINGS_KEYS.map((key) => `${ARG_BY_KEY[key]} ${words(entry[key])}`).join(" \xB7 ")}`;
+}
+function repoSettingsPatchFromArgs(args) {
+  const patch = {};
+  for (const key of REPO_SETTINGS_KEYS) {
+    const value = args[ARG_BY_KEY[key]];
+    if (value === void 0) continue;
+    if (value !== null && typeof value !== "boolean") {
+      throw new CommandError10(`${ARG_BY_KEY[key]} takes true, false, or null.`, 2, "usage");
+    }
+    patch[key] = value;
+  }
+  if (Object.keys(patch).length === 0) {
+    throw new CommandError10(
+      `At least one of ${Object.values(ARG_BY_KEY).join(", ")} is required.`,
+      2,
+      "usage"
+    );
+  }
+  return patch;
+}
+async function repoSettingsGet(args, cfg) {
+  const wanted = args.repo === void 0 ? null : parseRepo(args.repo);
+  const all = await listRepoSettings(cfg);
+  if (!wanted) {
+    return {
+      summary: all.length === 0 ? "No repositories are connected to this account." : all.map(repoSettingsSummary).join("\n"),
+      data: { repos: all }
+    };
+  }
+  const slug = `${wanted.owner}/${wanted.repo}`.toLowerCase();
+  const entry = all.find((candidate) => `${candidate.owner}/${candidate.repo}`.toLowerCase() === slug);
+  if (!entry) throw new CommandError10(`${wanted.owner}/${wanted.repo} is not connected to this account.`);
+  return { summary: repoSettingsSummary(entry), data: { ...entry } };
+}
+async function repoSettingsSet(args, cfg) {
+  const { owner, repo } = parseRepo(args.repo);
+  const entry = await patchRepoSettings(owner, repo, repoSettingsPatchFromArgs(args), cfg);
+  return { summary: repoSettingsSummary(entry), data: { ...entry } };
+}
+
 // src/tools/stack-adopt.ts
-import { adoptStack, CommandError as CommandError10, stackWatchObligation as stackWatchObligation4 } from "mergestorm/client";
+import { adoptStack, CommandError as CommandError11, stackWatchObligation as stackWatchObligation4 } from "mergestorm/client";
 import { z as z3 } from "zod";
 
 // src/tools/stack-set.ts
@@ -1008,11 +1070,11 @@ async function stackAdopt(input, cfg) {
       summary: message,
       data: {
         error: {
-          code: err instanceof CommandError10 ? err.code ?? "stack_adopt_failed" : "stack_adopt_failed",
+          code: err instanceof CommandError11 ? err.code ?? "stack_adopt_failed" : "stack_adopt_failed",
           message,
-          ...err instanceof CommandError10 ? { exit_code: err.exitCode } : {},
-          ...err instanceof CommandError10 && err.reason !== void 0 ? { reason: err.reason } : {},
-          ...err instanceof CommandError10 && err.retryAfterSeconds !== void 0 ? { retry_after_seconds: err.retryAfterSeconds } : {}
+          ...err instanceof CommandError11 ? { exit_code: err.exitCode } : {},
+          ...err instanceof CommandError11 && err.reason !== void 0 ? { reason: err.reason } : {},
+          ...err instanceof CommandError11 && err.retryAfterSeconds !== void 0 ? { retry_after_seconds: err.retryAfterSeconds } : {}
         }
       },
       isError: true
@@ -1083,7 +1145,7 @@ async function stackList(cfg) {
 
 // src/tools/stack-publish.ts
 import {
-  CommandError as CommandError11,
+  CommandError as CommandError12,
   publishWorkingBranch,
   stackWatchObligation as stackWatchObligation5,
   workingBranchPublication
@@ -1112,9 +1174,9 @@ function failure(err, fallback) {
     summary: message,
     data: {
       error: {
-        code: err instanceof CommandError11 ? err.code ?? fallback : fallback,
+        code: err instanceof CommandError12 ? err.code ?? fallback : fallback,
         message,
-        ...err instanceof CommandError11 && err.retryAfterSeconds !== void 0 ? { retry_after_seconds: err.retryAfterSeconds } : {}
+        ...err instanceof CommandError12 && err.retryAfterSeconds !== void 0 ? { retry_after_seconds: err.retryAfterSeconds } : {}
       }
     },
     isError: true
@@ -1246,7 +1308,7 @@ async function stackStatus(stackId, cfg) {
 
 // src/tools/whoami.ts
 import {
-  CommandError as CommandError12,
+  CommandError as CommandError13,
   apiBase,
   configPath,
   getMe as getMe2,
@@ -1257,7 +1319,7 @@ async function whoami(cfg, serverVersion) {
   const resolved = cfg ?? await loadConfig7();
   const key = resolveApiKey(resolved);
   if (!key) {
-    throw new CommandError12(
+    throw new CommandError13(
       "No API key. Run `mergestorm login` (agents: `mergestorm login --start`, then `--finish`) or set MERGESTORM_API_KEY.",
       1,
       "missing_api_key"
@@ -1265,7 +1327,7 @@ async function whoami(cfg, serverVersion) {
   }
   const me = await getMe2(resolved);
   if (!me) {
-    throw new CommandError12("Live account details unavailable. Could not verify account with /me.");
+    throw new CommandError13("Live account details unavailable. Could not verify account with /me.");
   }
   const data = {
     key_prefix: me.key.prefix,
@@ -1327,6 +1389,7 @@ var MCP_STACK_WATCH_INSTRUCTIONS = [
   "- merge_failed, gh_error, and ci_timeout bounces turn Auto land off, and stack autoLandOff then reads reason bounced with that queue entry's id; any other autoLandOff reason (user, archive, watcher, cancelled, landed) is not a bounce to undo. The watching agent turns Auto land back on with stack_set auto_land: true once it has handled that bounce, at most once per bounce and 3 times per watch; mergestorm-bounce-watch has the conditions.",
   `- A stack whose layers are all merged into mg-stack-N but which has no open land PR (the branch was deleted, or the land PR cannot be opened) returns attention: blocker "No open land PR for mg-stack-N ...", repair kind land_pr_unavailable. Do not patch or push; tell the human to restore the branch from the closed land PR's head or close the stack.`,
   '- While stack autoLandOff reads reason bounced, the watch returns attention: blocker "Auto land off after <kind> bounce", the bounce in issues[], repair kind auto_land_off.',
+  '- While stack autoLandOff reads reason cancelled or watcher and the current PR has no live blocker of its own (a live blocker is reported first, with its own repair), the watch returns attention: blocker "Auto land switched off: <why>", repair kind auto_land_switched_off. No bounce did it and the layers need no change: do not patch, push or turn Auto land back on yourself; tell the human, who decides whether to turn it back on.',
   '- A stack whose review unit was abandoned (a human moved its bottom PR off mg-stack-N) returns attention: blocker "Review unit abandoned: based on <base>", repair kind unit_abandoned. Do not patch or retarget; ask the human whether to re-root it. If at least two PRs remain open, tell them that mg stack adopt owner/repo#<bottom PR> re-roots it on a new review unit. With only one open PR, re-adopting will not create a review unit, so tell them to close and resubmit it to create a fresh stack.',
   `- Auto land records why it is waiting (stack autoLandWait: reason, prNumber, headSha, since). The watch returns attention on that PR when the wait cannot clear on its own: a failing check Auto land reads live on GitHub, even while the ledger shows CI green (blocker "CI failed \u2014 Auto land reads a failing check on GitHub at this head", repair kind ci_failure); a check pending for 45 minutes (repair kind ci_pending); no approving Vortex review for 30 minutes with no Vortex run working (repair kind vortex_not_green); and a promote GitHub refused 3 times with merge_failed, after which Auto land stops retrying that head (repair kind promote_failed). It also returns attention when GitHub refuses to let Mergestorm read the head's check runs or commit statuses (blocker "Mergestorm cannot read ... on this head", repair kind ci_unreadable: do not patch or push; tell the human to grant the Mergestorm GitHub App the permission the repair names), and when any other wait reason has held for 45 minutes, a land gate left pending or running on the land PR included (blocker "Auto land has waited <N>m: <reason in plain words>", repair kind auto_land_waiting: read stack_status, fix what a commit on the named branch can fix, otherwise tell the human what Auto land waits for and since when). A more specific blocker on that PR is named first. A new head clears the wait.`,
   `- While the stack has a live merge queue entry, stack_wait carries queueWait (the entry's wait reason, how long it has been held, and the stack queued ahead of it) and the status line names it. The watch returns attention, blocker "Merge queue stuck: ..." and repair kind queue_stalled, when the entry (or the entry ahead of it) has been held for 45 minutes without landing or bouncing, or has sat queued for 45 minutes with nothing working on it or ahead of it.`,
@@ -1340,7 +1403,7 @@ var MCP_STACK_WATCH_INSTRUCTIONS = [
 
 // src/server.ts
 var MCP_SERVER_NAME = "mergestorm";
-var MCP_SERVER_VERSION = "0.2.21";
+var MCP_SERVER_VERSION = "0.2.23";
 var MCP_SERVER_INSTRUCTIONS = [
   MCP_STACK_DONE_INSTRUCTIONS,
   MCP_PR_LOOP_INSTRUCTIONS,
@@ -1359,14 +1422,14 @@ function ok(payload) {
   };
 }
 function fail(err) {
-  const message = err instanceof CommandError13 ? err.code ? `Mergestorm request failed (${err.code}${err.reason ? `, reason ${err.reason}` : ""}): ${err.message}.` : err.message : err instanceof Error ? err.message : String(err);
+  const message = err instanceof CommandError14 ? err.code ? `Mergestorm request failed (${err.code}${err.reason ? `, reason ${err.reason}` : ""}): ${err.message}.` : err.message : err instanceof Error ? err.message : String(err);
   return ok({
     isError: true,
     summary: message,
     data: {
       error: {
         message: err instanceof Error ? err.message : String(err),
-        ...err instanceof CommandError13 ? {
+        ...err instanceof CommandError14 ? {
           exit_code: err.exitCode,
           ...err.code !== void 0 ? { code: err.code } : {},
           ...err.reason !== void 0 ? { reason: err.reason } : {},
@@ -1659,7 +1722,7 @@ function createMergestormMcpServer() {
     "stack_status",
     {
       title: "Get stack status",
-      description: `Fetch one owned Mergestorm stack with enriched checks and agent state, plus attention, issues, and currentCandidate from the same blocker rules as stack_wait, read against that stack's own merge queue. trunkBranch is mg-stack-<n> for an adopted 2+ PR stack and matches the bottom open PR's GitHub base; an mg-park-* parentBranch is a freeze. Neither is drift to fix. repair names the concrete fix for attention; landGatePending is a wait, not attention. held names a blocker no agent run clears while Vortex or Cyclone is still busy on that PR (actAfter agents_idle, waitingOn); repair then describes the fix to plan, not to apply yet. Auto land off after a merge_failed, gh_error, or ci_timeout bounce (the stack's autoLandOff reads reason bounced) returns attention with the blocker "Auto land off after <kind> bounce", the bounce in issues[], and a repair of kind auto_land_off: fix the cause, then turn Auto land back on or enqueue. A Vortex request_changes handoff at the live head returns attention with blocker "Vortex findings need a person" and repair kind vortex_findings; verify its findings against the live head.` + STACK_WATCH_RESULT_NOTE,
+      description: `Fetch one owned Mergestorm stack with enriched checks and agent state, plus attention, issues, and currentCandidate from the same blocker rules as stack_wait, read against that stack's own merge queue. trunkBranch is mg-stack-<n> for an adopted 2+ PR stack and matches the bottom open PR's GitHub base; an mg-park-* parentBranch is a freeze. Neither is drift to fix. repair names the concrete fix for attention; landGatePending is a wait, not attention. held names a blocker no agent run clears while Vortex or Cyclone is still busy on that PR (actAfter agents_idle, waitingOn); repair then describes the fix to plan, not to apply yet. Auto land off after a merge_failed, gh_error, or ci_timeout bounce (the stack's autoLandOff reads reason bounced) returns attention with the blocker "Auto land off after <kind> bounce", the bounce in issues[], and a repair of kind auto_land_off: fix the cause, then turn Auto land back on or enqueue. auto_land_switched_off (returned only when the PR has no live blocker of its own): Auto land was switched off without a bounce (queue entry cancelled, or nothing left to land); do not patch, push or turn it back on yourself, tell the human. A Vortex request_changes handoff at the live head returns attention with blocker "Vortex findings need a person" and repair kind vortex_findings; verify its findings against the live head.` + STACK_WATCH_RESULT_NOTE,
       inputSchema: {
         stack_id: z5.string().min(1)
       },
@@ -1677,7 +1740,7 @@ function createMergestormMcpServer() {
     "stack_wait",
     {
       title: "Wait for stack attention",
-      description: `Wait for a stack to need attention. Returns a mergestorm.stack_watch/v1 envelope; timeout_s: 0 returns one snapshot and timeout_s: 1-45 waits up to that many seconds, returning the current status (waiting or in_progress) if a snapshot was read and no attention is found. A timeout with either of those statuses is not a failure; waiting and in_progress end this slice, and the next call is stack_wait again with the same cursor. A timeout of failed means no assessment was produced. A stack that no longer exists returns status failed with watch.done true (reason not_found) and is not an error. While Cyclone or Vortex is still working on the blocked PR it returns in_progress, not attention, with busy[] naming the PR, blocker, and agent; agents carries that PR's vortexStatus, cycloneStatus, vortexReview, and busy flags. A blocker no agent run clears (a merge conflict vs the live parent, a restack Conflict or Restack failed, a Draft PR, a seam review pending with no review running, "Seam review stuck in reviewing, no review running", "Seam re-review pending, no review running", "Seam verdict is for an older head, no review running", or a review skipped for review quota) is still named during that in_progress, in blocker, prNumber, headSha, and issues[], with actAfter: "agents_idle" and waitingOn listing the busy agents: plan the fix, and act when a snapshot after the agents finish returns attention, re-reading the blocker then. Blockers the agents can change keep blocker and actAfter null. Attention never calls for changing a PR's GitHub base. When present, repair names the concrete fix for attention (restack_conflict and merge_conflict carry liveParent, never mg-park-*). For the three stuck-seam blockers, repair kind seam_review_stuck: do not patch or push; tell the human to click Continue, which re-queues the seam review at the live head. A pending land gate (landGatePending) returns in_progress, not attention. Auto land off after a merge_failed, gh_error, or ci_timeout bounce (the stack's autoLandOff reads reason bounced) returns attention with the blocker "Auto land off after <kind> bounce", the bounce in issues[], and a repair of kind auto_land_off: fix the cause, then turn Auto land back on or enqueue. A Vortex request_changes handoff at the live head returns attention with blocker "Vortex findings need a person" and repair kind vortex_findings; verify its findings against the live head.` + STACK_WATCH_RESULT_NOTE,
+      description: `Wait for a stack to need attention. Returns a mergestorm.stack_watch/v1 envelope; timeout_s: 0 returns one snapshot and timeout_s: 1-45 waits up to that many seconds, returning the current status (waiting or in_progress) if a snapshot was read and no attention is found. A timeout with either of those statuses is not a failure; waiting and in_progress end this slice, and the next call is stack_wait again with the same cursor. A timeout of failed means no assessment was produced. A stack that no longer exists returns status failed with watch.done true (reason not_found) and is not an error. While Cyclone or Vortex is still working on the blocked PR it returns in_progress, not attention, with busy[] naming the PR, blocker, and agent; agents carries that PR's vortexStatus, cycloneStatus, vortexReview, and busy flags. A blocker no agent run clears (a merge conflict vs the live parent, a restack Conflict or Restack failed, a Draft PR, a seam review pending with no review running, "Seam review stuck in reviewing, no review running", "Seam re-review pending, no review running", "Seam verdict is for an older head, no review running", or a review skipped for review quota) is still named during that in_progress, in blocker, prNumber, headSha, and issues[], with actAfter: "agents_idle" and waitingOn listing the busy agents: plan the fix, and act when a snapshot after the agents finish returns attention, re-reading the blocker then. Blockers the agents can change keep blocker and actAfter null. Attention never calls for changing a PR's GitHub base. When present, repair names the concrete fix for attention (restack_conflict and merge_conflict carry liveParent, never mg-park-*). For the three stuck-seam blockers, repair kind seam_review_stuck: do not patch or push; tell the human to click Continue, which re-queues the seam review at the live head. A pending land gate (landGatePending) returns in_progress, not attention. Auto land off after a merge_failed, gh_error, or ci_timeout bounce (the stack's autoLandOff reads reason bounced) returns attention with the blocker "Auto land off after <kind> bounce", the bounce in issues[], and a repair of kind auto_land_off: fix the cause, then turn Auto land back on or enqueue. auto_land_switched_off (returned only when the PR has no live blocker of its own): Auto land was switched off without a bounce (queue entry cancelled, or nothing left to land); do not patch, push or turn it back on yourself, tell the human. A Vortex request_changes handoff at the live head returns attention with blocker "Vortex findings need a person" and repair kind vortex_findings; verify its findings against the live head.` + STACK_WATCH_RESULT_NOTE,
       inputSchema: stackWaitSchema,
       annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
     },
@@ -1708,6 +1771,43 @@ function createMergestormMcpServer() {
       }
     }
   );
+  addTool(
+    "repo_settings_get",
+    {
+      title: "Get repository settings",
+      description: "Read the repository-level Auto patch, Auto review and Auto land values for the repositories connected to this account. Each value is true, false, or null; null means not set, so the account setting applies. Auto patch and Auto review precedence is the stack override (stack_set), then the repository value, then the account setting (settings_get). The Auto land repository value only seeds new stacks at adoption; it does not override an existing stack. Pass repo as owner/repo for one repository, or omit it for all.",
+      inputSchema: { repo: z5.string().min(3).optional() },
+      annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    async (args) => {
+      try {
+        return ok(await repoSettingsGet(args ?? {}));
+      } catch (err) {
+        return fail(err);
+      }
+    }
+  );
+  addTool(
+    "repo_settings_set",
+    {
+      title: "Update repository settings",
+      description: "Set Auto patch (Cyclone), Auto review (Vortex) or the Auto land default for every stack and pull request in one repository connected to this account, and return the stored result. true or false sets the repository value; null clears it so the account setting applies again. A stack override (stack_set) still wins for that stack. auto_patch and auto_review apply to open stacks without an override from their next decision; nothing is cancelled or re-queued. auto_land only seeds new stacks. Only the account that connected the repository can change it. Never changes account settings.",
+      inputSchema: {
+        repo: z5.string().min(3),
+        auto_patch: z5.boolean().nullable().optional(),
+        auto_review: z5.boolean().nullable().optional(),
+        auto_land: z5.boolean().nullable().optional()
+      },
+      annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true }
+    },
+    async (args) => {
+      try {
+        return ok(await repoSettingsSet(args ?? {}));
+      } catch (err) {
+        return fail(err);
+      }
+    }
+  );
   addTool(
     "settings_get",
     {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mergestorm-mcp",
-  "version": "0.2.21",
+  "version": "0.2.23",
   "description": "Mergestorm MCP server — identity, review, and read-only stack tools over stdio",
   "license": "MIT",
   "type": "module",
@@ -29,7 +29,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.30.0",
-    "mergestorm": "0.3.54",
+    "mergestorm": "0.3.58",
     "zod": "^3.24.2"
   },
   "devDependencies": {