mergestorm-mcp 0.2.26 → 0.2.28

package/dist/lib/tools/settings-get.js

@@ -0,0 +1,33 @@
+import { CommandError, getSettings, } from "mergestorm/client";
+/**
+ * One line an agent can act on without opening the data: is Cyclone allowed
+ * to patch, and is it even connected.
+ */
+export function settingsSummary(settings) {
+    const autoPatch = settings.auto_patch_enabled ? "on" : "off";
+    const automations = [
+        settings.auto_resolve_conflicts_enabled ? "auto_resolve_conflicts on" : null,
+        settings.auto_fix_ci_enabled ? "auto_fix_ci on" : null,
+    ].filter((label) => label !== null);
+    const autoPatchLabel = [`auto_patch ${autoPatch}`, ...automations].join(" · ");
+    const cyclone = settings.cyclone_connected
+        ? "Cyclone connected"
+        : "Cyclone not connected";
+    if (typeof settings.stacks_ready !== "boolean")
+        return `${autoPatchLabel} · ${cyclone}`;
+    const stacks = settings.stacks_ready
+        ? "stacks, merge queue and Auto land ready"
+        : "stacks, merge queue and Auto land not ready (install Mergestorm Surge)";
+    return `${autoPatchLabel} · ${cyclone} (auto patch) · ${stacks}`;
+}
+export async function settingsGet(cfg) {
+    const settings = await getSettings(cfg);
+    if (!settings) {
+        throw new CommandError("Settings are not available (offline or API too old). " +
+            "Try again or open https://mergestorm.ai/settings");
+    }
+    return {
+        summary: settingsSummary(settings),
+        data: { ...settings },
+    };
+}

package/dist/lib/tools/settings-set.d.ts

@@ -0,0 +1,11 @@
+import { type Config, type SettingsPatch } from "mergestorm/client";
+import type { ToolPayload } from "./types.js";
+/** Read-only on `/api/v1/settings`; the API owns them, agents never write them. */
+export declare const SETTINGS_READ_ONLY_KEYS: readonly ["cyclone_connected", "github_connected"];
+/**
+ * Build a PATCH body from raw tool args. Only the Bearer-writable allowlist
+ * passes through; read-only keys and empty patches are usage errors so the
+ * failure is the caller's wording, never a silent no-op.
+ */
+export declare function settingsPatchFromArgs(args: Record<string, unknown>): SettingsPatch;
+export declare function settingsSet(args: Record<string, unknown>, cfg?: Config): Promise<ToolPayload>;

package/dist/lib/tools/settings-set.js

@@ -0,0 +1,62 @@
+import { CommandError, BEARER_SETTINGS, SETTINGS_WRITABLE_KEYS, patchSettings, } from "mergestorm/client";
+import { settingsSummary } from "./settings-get.js";
+/** Read-only on `/api/v1/settings`; the API owns them, agents never write them. */
+export const SETTINGS_READ_ONLY_KEYS = [
+    "cyclone_connected",
+    "github_connected",
+];
+/**
+ * Build a PATCH body from raw tool args. Only the Bearer-writable allowlist
+ * passes through; read-only keys and empty patches are usage errors so the
+ * failure is the caller's wording, never a silent no-op.
+ */
+export function settingsPatchFromArgs(args) {
+    for (const key of SETTINGS_READ_ONLY_KEYS) {
+        if (args[key] !== undefined) {
+            throw new CommandError(`${key} is read-only and cannot be set.`, 2, "usage");
+        }
+    }
+    const patch = {};
+    for (const key of SETTINGS_WRITABLE_KEYS) {
+        const value = args[key];
+        if (value === undefined)
+            continue;
+        const row = BEARER_SETTINGS.find((row) => row.key === key);
+        if ("kind" in row && (row.kind === "seconds" || row.kind === "count")) {
+            if (typeof value !== "number" ||
+                !Number.isInteger(value) ||
+                value < row.min ||
+                value > row.max) {
+                const unit = row.kind === "seconds" ? " of seconds" : "";
+                throw new CommandError(`${key} takes a whole number${unit} from ${row.min} through ${row.max}.`, 2, "usage");
+            }
+            Object.assign(patch, { [key]: value });
+            continue;
+        }
+        if ("kind" in row) {
+            const valid = row.kind === "logins" || row.kind === "paths"
+                ? Array.isArray(value) && value.every((entry) => typeof entry === "string")
+                : typeof value === "string" && row.values.includes(value);
+            if (!valid)
+                throw new CommandError(`Invalid value for ${key}.`, 2, "usage");
+            Object.assign(patch, { [key]: value });
+            continue;
+        }
+        if (typeof value !== "boolean") {
+            throw new CommandError(`${key} takes a boolean.`, 2, "usage");
+        }
+        Object.assign(patch, { [key]: value });
+    }
+    if (Object.keys(patch).length === 0) {
+        throw new CommandError(`At least one settings key is required: ${SETTINGS_WRITABLE_KEYS.join(", ")}.`, 2, "usage");
+    }
+    return patch;
+}
+export async function settingsSet(args, cfg) {
+    const patch = settingsPatchFromArgs(args);
+    const settings = await patchSettings(patch, cfg);
+    return {
+        summary: settingsSummary(settings),
+        data: { ...settings },
+    };
+}

package/dist/lib/tools/stack-actions.d.ts

@@ -0,0 +1,4 @@
+import { type Config } from "mergestorm/client";
+import type { ToolPayload } from "./types.js";
+export declare function stackRestack(stackId: string, cfg?: Config): Promise<ToolPayload>;
+export declare function stackEnqueue(stackId: string, cfg?: Config, chatId?: string | null): Promise<ToolPayload>;

package/dist/lib/tools/stack-actions.js

@@ -0,0 +1,22 @@
+import { enqueueStack, loadConfig, restackStack, stackWatchObligation } from "mergestorm/client";
+import { chatTaskNote, trackInChat } from "./chat-task.js";
+import { withWatchText } from "./stack-wait.js";
+export async function stackRestack(stackId, cfg) {
+    const result = await restackStack(stackId, cfg);
+    const watch = stackWatchObligation({ stackId, terminal: null, unread: true, freshCursor: true });
+    return {
+        summary: withWatchText(watch, `Restacked stack ${stackId}: its layer branches were rebased onto their parents and pushed`),
+        data: { stack_id: stackId, result, watch },
+    };
+}
+export async function stackEnqueue(stackId, cfg, chatId) {
+    const resolved = cfg ?? (await loadConfig());
+    const result = await enqueueStack(stackId, resolved);
+    const watch = stackWatchObligation({ stackId, terminal: null, unread: true, freshCursor: true });
+    const task = chatId ? await trackInChat(resolved, chatId, { kind: "stack", stackId }) : null;
+    const summary = withWatchText(watch, `Sent stack ${stackId} to the Mergestorm merge queue`);
+    return {
+        summary: task ? `${summary} ${chatTaskNote(task)}` : summary,
+        data: { stack_id: stackId, result, watch, ...(task ? { background_task: task } : {}) },
+    };
+}

package/dist/lib/tools/stack-adopt.d.ts

@@ -0,0 +1,44 @@
+import { type Config } from "mergestorm/client";
+import { z } from "zod";
+import type { ToolPayload } from "./types.js";
+export declare const stackAdoptSchema: {
+    owner: z.ZodString;
+    repo: z.ZodString;
+    pr_number: z.ZodNumber;
+    auto_land: z.ZodOptional<z.ZodBoolean>;
+    auto_review: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    auto_patch: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    auto_resolve_conflicts: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    auto_fix_ci: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+};
+declare const inputSchema: z.ZodObject<{
+    owner: z.ZodString;
+    repo: z.ZodString;
+    pr_number: z.ZodNumber;
+    auto_land: z.ZodOptional<z.ZodBoolean>;
+    auto_review: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    auto_patch: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    auto_resolve_conflicts: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    auto_fix_ci: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    owner: string;
+    repo: string;
+    pr_number: number;
+    auto_patch?: boolean | null | undefined;
+    auto_review?: boolean | null | undefined;
+    auto_land?: boolean | undefined;
+    auto_resolve_conflicts?: boolean | null | undefined;
+    auto_fix_ci?: boolean | null | undefined;
+}, {
+    owner: string;
+    repo: string;
+    pr_number: number;
+    auto_patch?: boolean | null | undefined;
+    auto_review?: boolean | null | undefined;
+    auto_land?: boolean | undefined;
+    auto_resolve_conflicts?: boolean | null | undefined;
+    auto_fix_ci?: boolean | null | undefined;
+}>;
+export type StackAdoptInput = z.infer<typeof inputSchema>;
+export declare function stackAdopt(input: StackAdoptInput, cfg?: Config): Promise<ToolPayload>;
+export {};

package/dist/lib/tools/stack-adopt.js

@@ -0,0 +1,55 @@
+import { adoptStack, CommandError, stackWatchObligation } from "mergestorm/client";
+import { z } from "zod";
+import { stackSetPatch } from "./stack-set.js";
+import { withWatchText } from "./stack-wait.js";
+export const stackAdoptSchema = {
+    owner: z.string().trim().min(1),
+    repo: z.string().trim().min(1),
+    pr_number: z.number().int().min(1),
+    auto_land: z.boolean().optional(),
+    auto_review: z.boolean().nullable().optional(),
+    auto_patch: z.boolean().nullable().optional(),
+    auto_resolve_conflicts: z.boolean().nullable().optional(),
+    auto_fix_ci: z.boolean().nullable().optional(),
+};
+const inputSchema = z.object(stackAdoptSchema);
+export async function stackAdopt(input, cfg) {
+    const parsed = inputSchema.safeParse(input);
+    if (!parsed.success) {
+        const message = "stack_adopt requires owner, repo, a positive pr_number, and valid policy values";
+        return { summary: message, data: { error: { code: "invalid_input", message } }, isError: true };
+    }
+    const { owner, repo, pr_number } = parsed.data;
+    try {
+        const result = await adoptStack(owner, repo, pr_number, cfg, stackSetPatch(parsed.data));
+        const summary = `Adopted stack for ${owner}/${repo}#${pr_number}`;
+        const stackId = typeof result === "object" && result !== null
+            ? result.stack?.id
+            : undefined;
+        if (typeof stackId !== "string" || !stackId) {
+            return { summary, data: { owner, repo, pr_number, result } };
+        }
+        const watch = stackWatchObligation({ stackId, terminal: null, unread: true, freshCursor: true });
+        return {
+            summary: withWatchText(watch, summary),
+            data: { owner, repo, pr_number, result, watch },
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            summary: message,
+            data: {
+                error: {
+                    code: err instanceof CommandError ? err.code ?? "stack_adopt_failed" : "stack_adopt_failed",
+                    message,
+                    ...(err instanceof CommandError ? { exit_code: err.exitCode } : {}),
+                    ...(err instanceof CommandError && err.reason !== undefined ? { reason: err.reason } : {}),
+                    ...(err instanceof CommandError && err.retryAfterSeconds !== undefined
+                        ? { retry_after_seconds: err.retryAfterSeconds } : {}),
+                },
+            },
+            isError: true,
+        };
+    }
+}

package/dist/lib/tools/stack-list.d.ts

@@ -0,0 +1,3 @@
+import { type Config } from "mergestorm/client";
+import type { ToolPayload } from "./types.js";
+export declare function stackList(cfg?: Config): Promise<ToolPayload>;

package/dist/lib/tools/stack-list.js

@@ -0,0 +1,30 @@
+import { isCommandErrorCode, listMergeQueueEntries, listStacks, } from "mergestorm/client";
+import { stackSummary } from "./stack-summary.js";
+export async function stackList(cfg) {
+    try {
+        const stacks = await listStacks(cfg);
+        const entries = await listMergeQueueEntries(cfg);
+        return {
+            summary: stacks.length === 0
+                ? "No stacks"
+                : stacks.map((stack) => stackSummary(stack, entries)).join("\n"),
+            data: { stacks },
+        };
+    }
+    catch (err) {
+        if (isCommandErrorCode(err, "rate_limited")) {
+            return {
+                summary: err.message,
+                data: {
+                    error: {
+                        code: "rate_limited",
+                        message: err.message,
+                        retry_after_seconds: err.retryAfterSeconds,
+                    },
+                },
+                isError: true,
+            };
+        }
+        throw err;
+    }
+}

package/dist/lib/tools/stack-publish.d.ts

@@ -0,0 +1,78 @@
+import { publishWorkingBranch, workingBranchPublication, type Config } from "mergestorm/client";
+import { z } from "zod";
+import type { ToolPayload } from "./types.js";
+export declare const stackPublishSchema: {
+    base: z.ZodOptional<z.ZodString>;
+    extend: z.ZodOptional<z.ZodBoolean>;
+    title: z.ZodOptional<z.ZodString>;
+    body: z.ZodOptional<z.ZodString>;
+    replace_head: z.ZodOptional<z.ZodString>;
+    auto_land: z.ZodOptional<z.ZodBoolean>;
+    cwd: z.ZodOptional<z.ZodString>;
+    owner: z.ZodOptional<z.ZodString>;
+    repo: z.ZodOptional<z.ZodString>;
+    branch: z.ZodOptional<z.ZodString>;
+};
+export declare const stackPublishStatusSchema: {
+    cwd: z.ZodOptional<z.ZodString>;
+    owner: z.ZodOptional<z.ZodString>;
+    repo: z.ZodOptional<z.ZodString>;
+    branch: z.ZodOptional<z.ZodString>;
+};
+declare const publishInput: z.ZodObject<{
+    base: z.ZodOptional<z.ZodString>;
+    extend: z.ZodOptional<z.ZodBoolean>;
+    title: z.ZodOptional<z.ZodString>;
+    body: z.ZodOptional<z.ZodString>;
+    replace_head: z.ZodOptional<z.ZodString>;
+    auto_land: z.ZodOptional<z.ZodBoolean>;
+    cwd: z.ZodOptional<z.ZodString>;
+    owner: z.ZodOptional<z.ZodString>;
+    repo: z.ZodOptional<z.ZodString>;
+    branch: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    title?: string | undefined;
+    owner?: string | undefined;
+    body?: string | undefined;
+    repo?: string | undefined;
+    cwd?: string | undefined;
+    branch?: string | undefined;
+    auto_land?: boolean | undefined;
+    base?: string | undefined;
+    extend?: boolean | undefined;
+    replace_head?: string | undefined;
+}, {
+    title?: string | undefined;
+    owner?: string | undefined;
+    body?: string | undefined;
+    repo?: string | undefined;
+    cwd?: string | undefined;
+    branch?: string | undefined;
+    auto_land?: boolean | undefined;
+    base?: string | undefined;
+    extend?: boolean | undefined;
+    replace_head?: string | undefined;
+}>;
+declare const statusInput: z.ZodObject<{
+    cwd: z.ZodOptional<z.ZodString>;
+    owner: z.ZodOptional<z.ZodString>;
+    repo: z.ZodOptional<z.ZodString>;
+    branch: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    owner?: string | undefined;
+    repo?: string | undefined;
+    cwd?: string | undefined;
+    branch?: string | undefined;
+}, {
+    owner?: string | undefined;
+    repo?: string | undefined;
+    cwd?: string | undefined;
+    branch?: string | undefined;
+}>;
+export type StackPublishInput = z.infer<typeof publishInput>;
+export type StackPublishStatusInput = z.infer<typeof statusInput>;
+type PublishDeps = Parameters<typeof publishWorkingBranch>[1];
+type StatusDeps = Parameters<typeof workingBranchPublication>[1];
+export declare function stackPublish(input: StackPublishInput, cfg?: Config, deps?: PublishDeps): Promise<ToolPayload>;
+export declare function stackPublishStatus(input: StackPublishStatusInput, cfg?: Config, deps?: StatusDeps): Promise<ToolPayload>;
+export {};

package/dist/lib/tools/stack-publish.js

@@ -0,0 +1,89 @@
+import { CommandError, publishWorkingBranch, stackWatchObligation, workingBranchPublication, } from "mergestorm/client";
+import { z } from "zod";
+import { withWatchText } from "./stack-wait.js";
+const target = {
+    cwd: z.string().trim().min(1).optional(),
+    owner: z.string().trim().min(1).optional(),
+    repo: z.string().trim().min(1).optional(),
+    branch: z.string().trim().min(1).optional(),
+};
+export const stackPublishSchema = {
+    ...target,
+    base: z.string().trim().min(1).optional(),
+    extend: z.boolean().optional(),
+    title: z.string().trim().min(1).max(256).optional(),
+    body: z.string().max(60_000).optional(),
+    replace_head: z.string().regex(/^[0-9a-f]{40}$/).optional(),
+    auto_land: z.boolean().optional(),
+};
+export const stackPublishStatusSchema = target;
+const publishInput = z.object(stackPublishSchema);
+const statusInput = z.object(stackPublishStatusSchema);
+function failure(err, fallback) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+        summary: message,
+        data: {
+            error: {
+                code: err instanceof CommandError ? err.code ?? fallback : fallback,
+                message,
+                ...(err instanceof CommandError && err.retryAfterSeconds !== undefined
+                    ? { retry_after_seconds: err.retryAfterSeconds } : {}),
+            },
+        },
+        isError: true,
+    };
+}
+function targetOf(input, cfg) {
+    return {
+        ...(input.cwd ? { cwd: input.cwd } : {}),
+        ...(input.owner ? { owner: input.owner } : {}),
+        ...(input.repo ? { repo: input.repo } : {}),
+        ...(input.branch ? { branch: input.branch } : {}),
+        ...(cfg ? { cfg } : {}),
+    };
+}
+export async function stackPublish(input, cfg, deps) {
+    const parsed = publishInput.safeParse(input);
+    if (!parsed.success || Boolean(parsed.data.owner) !== Boolean(parsed.data.repo)) {
+        const message = "stack_publish takes owner and repo together, and replace_head as a full 40-character commit SHA";
+        return { summary: message, data: { error: { code: "invalid_input", message } }, isError: true };
+    }
+    try {
+        const result = await publishWorkingBranch({
+            ...targetOf(parsed.data, cfg),
+            ...(parsed.data.base ? { base: parsed.data.base } : {}),
+            ...(parsed.data.extend ? { extend: true } : {}),
+            ...(parsed.data.title ? { title: parsed.data.title } : {}),
+            ...(parsed.data.body !== undefined ? { body: parsed.data.body } : {}),
+            ...(parsed.data.replace_head ? { replaceHead: parsed.data.replace_head } : {}),
+            ...(typeof parsed.data.auto_land === "boolean" ? { autoLand: parsed.data.auto_land } : {}),
+        }, deps);
+        const watch = stackWatchObligation({ stackId: result.stack.id, terminal: null, unread: true, freshCursor: true });
+        const moved = result.branchCreated ? "created" : result.branchUpdated ? "updated" : "already current";
+        return {
+            summary: withWatchText(watch, `Published ${result.owner}/${result.repo} ${result.branch} (${moved}) at ${result.head.sha}, PR #${result.pr.number} (${result.stacked ? `a layer stacked on ${result.baseBranch}` : `a single PR onto ${result.baseBranch}`}), stack ${result.stack.id}`),
+            data: { result, watch },
+        };
+    }
+    catch (err) {
+        return failure(err, "stack_publish_failed");
+    }
+}
+export async function stackPublishStatus(input, cfg, deps) {
+    const parsed = statusInput.safeParse(input);
+    if (!parsed.success || Boolean(parsed.data.owner) !== Boolean(parsed.data.repo)) {
+        const message = "stack_publish_status takes owner and repo together";
+        return { summary: message, data: { error: { code: "invalid_input", message } }, isError: true };
+    }
+    try {
+        const status = await workingBranchPublication(targetOf(parsed.data, cfg), deps);
+        return {
+            summary: `${status.owner}/${status.repo} ${status.branch}: ${status.state}${status.head ? ` at ${status.head.sha}` : ""}${status.pr ? `, PR #${status.pr.number}` : ""}${status.stack ? `, stack ${status.stack.id}` : ""}`,
+            data: { status },
+        };
+    }
+    catch (err) {
+        return failure(err, "stack_publish_status_failed");
+    }
+}

package/dist/lib/tools/stack-set.d.ts

@@ -0,0 +1,16 @@
+import { type Config, type StackPolicyPatch } from "mergestorm/client";
+import type { ToolPayload } from "./types.js";
+/**
+ * `stack_set` input. Every key is optional but at least one must be present.
+ * `auto_land` is boolean; `auto_review` / `auto_patch` are tri-state where
+ * `null` clears the per-stack override back to the account setting.
+ */
+export type StackSetInput = {
+    auto_land?: boolean;
+    auto_review?: boolean | null;
+    auto_patch?: boolean | null;
+    auto_resolve_conflicts?: boolean | null;
+    auto_fix_ci?: boolean | null;
+};
+export declare function stackSetPatch(input: StackSetInput): StackPolicyPatch;
+export declare function stackSet(stackId: string, input: StackSetInput, cfg?: Config): Promise<ToolPayload>;

package/dist/lib/tools/stack-set.js

@@ -0,0 +1,69 @@
+import { setStackPolicy, stackWatchObligation } from "mergestorm/client";
+import { withWatchText } from "./stack-wait.js";
+function triWord(value) {
+    return value === null ? "default" : value ? "on" : "off";
+}
+export function stackSetPatch(input) {
+    const patch = {};
+    if (typeof input.auto_land === "boolean")
+        patch.autoEnqueueWhenReady = input.auto_land;
+    if (input.auto_review !== undefined)
+        patch.autoReviewOverride = input.auto_review;
+    if (input.auto_patch !== undefined)
+        patch.autoPatchOverride = input.auto_patch;
+    if (input.auto_resolve_conflicts !== undefined) {
+        patch.autoResolveConflictsOverride = input.auto_resolve_conflicts;
+    }
+    if (input.auto_fix_ci !== undefined)
+        patch.autoFixCiOverride = input.auto_fix_ci;
+    return patch;
+}
+export async function stackSet(stackId, input, cfg) {
+    const patch = stackSetPatch(input);
+    if (Object.keys(patch).length === 0) {
+        return {
+            summary: "stack_set needs at least one of auto_land, auto_review, auto_patch, auto_resolve_conflicts, auto_fix_ci",
+            isError: true,
+            data: {
+                error: {
+                    code: "invalid_input",
+                    message: "Pass at least one of auto_land, auto_review, auto_patch, auto_resolve_conflicts, auto_fix_ci.",
+                    stack_id: stackId,
+                },
+            },
+        };
+    }
+    const result = await setStackPolicy(stackId, patch, cfg);
+    const parts = [];
+    if (typeof input.auto_land === "boolean") {
+        parts.push(`Auto land ${input.auto_land ? "on" : "off"}`);
+    }
+    if (input.auto_review !== undefined) {
+        parts.push(`auto-review ${triWord(input.auto_review)}`);
+    }
+    if (input.auto_patch !== undefined) {
+        parts.push(`auto-patch ${triWord(input.auto_patch)}`);
+    }
+    if (input.auto_resolve_conflicts !== undefined) {
+        parts.push(`auto-resolve-conflicts ${triWord(input.auto_resolve_conflicts)}`);
+    }
+    if (input.auto_fix_ci !== undefined) {
+        parts.push(`auto-fix-ci ${triWord(input.auto_fix_ci)}`);
+    }
+    const watch = stackWatchObligation({ stackId, terminal: null, unread: true, freshCursor: true });
+    return {
+        summary: withWatchText(watch, `${parts.join(", ")} for stack ${stackId}`),
+        data: {
+            stack_id: stackId,
+            ...(typeof input.auto_land === "boolean" ? { auto_land: input.auto_land } : {}),
+            ...(input.auto_review !== undefined ? { auto_review: input.auto_review } : {}),
+            ...(input.auto_patch !== undefined ? { auto_patch: input.auto_patch } : {}),
+            ...(input.auto_resolve_conflicts !== undefined
+                ? { auto_resolve_conflicts: input.auto_resolve_conflicts }
+                : {}),
+            ...(input.auto_fix_ci !== undefined ? { auto_fix_ci: input.auto_fix_ci } : {}),
+            result,
+            watch,
+        },
+    };
+}

package/dist/lib/tools/stack-status.d.ts

@@ -0,0 +1,3 @@
+import { type Config } from "mergestorm/client";
+import type { ToolPayload } from "./types.js";
+export declare function stackStatus(stackId: string, cfg?: Config): Promise<ToolPayload>;

package/dist/lib/tools/stack-status.js

@@ -0,0 +1,57 @@
+import { getEnrichedStack, listMergeQueueEntries, isCommandErrorCode, stackBlockers, stackTerminalReason, stackWatchObligation, } from "mergestorm/client";
+import { repairSummary, withWatchText } from "./stack-wait.js";
+import { stackSummary } from "./stack-summary.js";
+export async function stackStatus(stackId, cfg) {
+    try {
+        const stack = await getEnrichedStack(stackId, cfg);
+        if (!stack) {
+            const message = `Stack not found or not owned by the current user: ${stackId}`;
+            const watch = stackWatchObligation({ stackId, terminal: "not_found" });
+            return {
+                summary: withWatchText(watch, message),
+                data: {
+                    error: {
+                        code: "stack_not_found",
+                        message,
+                        stack_id: stackId,
+                    },
+                    watch,
+                },
+                isError: true,
+            };
+        }
+        const entries = await listMergeQueueEntries(cfg, { stackId: stack.id });
+        const { attention, held, issues, currentCandidate, busy, agents, repair, landGatePending, queueWait } = stackBlockers(stack, entries);
+        const watch = stackWatchObligation({
+            stackId: stack.id,
+            terminal: stackTerminalReason(stack),
+            cursor: { enrolledHeadSha: currentCandidate?.headSha ?? null },
+            attention: attention ? { prNumber: attention.prNumber, blocker: attention.blocker } : null,
+            freshCursor: true,
+        });
+        return {
+            summary: withWatchText(watch, `${stackSummary(stack, entries)}${repairSummary(repair)}`),
+            data: { stack, attention, held, issues, currentCandidate, busy, agents, repair, landGatePending, queueWait, watch },
+        };
+    }
+    catch (err) {
+        if (isCommandErrorCode(err, "rate_limited")) {
+            const watch = stackWatchObligation({
+                stackId, terminal: null, status: "rate_limited", retryAfterSeconds: err.retryAfterSeconds, freshCursor: true,
+            });
+            return {
+                summary: withWatchText(watch, err.message),
+                data: {
+                    error: {
+                        code: "rate_limited",
+                        message: err.message,
+                        retry_after_seconds: err.retryAfterSeconds,
+                    },
+                    watch,
+                },
+                isError: true,
+            };
+        }
+        throw err;
+    }
+}

package/dist/lib/tools/stack-summary.d.ts

@@ -0,0 +1,2 @@
+import { type MergeQueueEntryDto, type StackDto } from "mergestorm/client";
+export declare function stackSummary(stack: StackDto, entries?: MergeQueueEntryDto[]): string;

package/dist/lib/tools/stack-summary.js

@@ -0,0 +1,29 @@
+import { stackBlockers, stackBlockersSummary } from "mergestorm/client";
+export function stackSummary(stack, entries = []) {
+    const count = stack.layers.length;
+    const layerLabel = `${count} layer${count === 1 ? "" : "s"}`;
+    const states = [...new Set(stack.layers.map((layer) => layer.state))];
+    const currentState = states.length > 0
+        ? `restack: ${states.join(", ")}`
+        : stack.unit
+            ? `unit: ${stack.unit.state}`
+            : "no open layers";
+    const overrides = [];
+    if (typeof stack.autoReviewOverride === "boolean") {
+        overrides.push(`auto-review ${stack.autoReviewOverride ? "on" : "off"}`);
+    }
+    if (typeof stack.autoPatchOverride === "boolean") {
+        overrides.push(`auto-patch ${stack.autoPatchOverride ? "on" : "off"}`);
+    }
+    if (typeof stack.autoResolveConflictsOverride === "boolean") {
+        overrides.push(`auto-resolve-conflicts ${stack.autoResolveConflictsOverride ? "on" : "off"}`);
+    }
+    if (typeof stack.autoFixCiOverride === "boolean") {
+        overrides.push(`auto-fix-ci ${stack.autoFixCiOverride ? "on" : "off"}`);
+    }
+    if (stack.cycloneOwnerMatch) {
+        overrides.push(`cyclone-owner ${stack.cycloneOwnerMatch}`);
+    }
+    const { attention, held, issues, busy, landGatePending, queueWait } = stackBlockers(stack, entries);
+    return `${stack.owner}/${stack.repo} · ${layerLabel} · ${currentState} · auto-land ${stack.autoEnqueueWhenReady ? "on" : "off"}${overrides.map((label) => ` · ${label}`).join("")}${stackBlockersSummary(attention ?? held, issues, busy, landGatePending, attention ? null : held?.actAfter ?? null, queueWait)}`;
+}