mergestorm-mcp 0.2.26 → 0.2.28

package/dist/lib/tools/agent-request.d.ts

@@ -0,0 +1,6 @@
+import { type Config } from "mergestorm/client";
+import type { ToolPayload } from "./types.js";
+export declare function agentRequest(route: string, init: {
+    method: "GET" | "POST";
+    json?: Record<string, unknown>;
+}, cfg?: Config): Promise<ToolPayload>;

package/dist/lib/tools/agent-request.js

@@ -0,0 +1,25 @@
+import { apiFetch, CommandError, loadConfig } from "mergestorm/client";
+export async function agentRequest(route, init, cfg) {
+    const resolved = cfg ?? (await loadConfig());
+    const { status, body, retryAfterSeconds } = await apiFetch(resolved, route, { method: init.method, ...(init.json ? { json: init.json } : {}) });
+    const data = body && typeof body === "object" && !Array.isArray(body) ? body : { body };
+    if (status === 404 && data.error === undefined) {
+        throw new CommandError("This Mergestorm server does not offer that action yet.", 1, "not_found");
+    }
+    const message = typeof data.message === "string" ? data.message : `Mergestorm answered ${status}.`;
+    if (status >= 400) {
+        return {
+            summary: message,
+            isError: true,
+            data: {
+                ...data,
+                error: {
+                    code: typeof data.error === "string" ? data.error : `http_${status}`,
+                    message,
+                    ...(retryAfterSeconds !== undefined ? { retry_after_seconds: retryAfterSeconds } : {}),
+                },
+            },
+        };
+    }
+    return { summary: message, data };
+}

package/dist/lib/tools/chat-task.d.ts

@@ -0,0 +1,18 @@
+import { type Config } from "mergestorm/client";
+export type ChatTaskTarget = {
+    kind: "review";
+    owner: string;
+    repo: string;
+    prNumber: number;
+} | {
+    kind: "stack";
+    stackId: string;
+};
+export type ChatTask = {
+    id: string;
+    title: string;
+};
+export declare function breezeChatId(value: string | null | undefined): string | null;
+export declare function chatTaskOf(value: unknown): ChatTask | null;
+export declare function chatTaskNote(task: ChatTask): string;
+export declare function trackInChat(cfg: Config, chatId: string, target: ChatTaskTarget, signal?: AbortSignal): Promise<ChatTask | null>;

package/dist/lib/tools/chat-task.js

@@ -0,0 +1,28 @@
+import { apiFetch } from "mergestorm/client";
+const CHAT_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+export function breezeChatId(value) {
+    const trimmed = value?.trim() ?? "";
+    return CHAT_ID.test(trimmed) ? trimmed.toLowerCase() : null;
+}
+export function chatTaskOf(value) {
+    if (!value || typeof value !== "object")
+        return null;
+    const { id, title } = value;
+    return typeof id === "string" && typeof title === "string" ? { id, title } : null;
+}
+export function chatTaskNote(task) {
+    return `This chat tracks it as background task ${task.id} "${task.title}" and is told the result when it ends. If the user is waiting for the outcome, wait for it before you end the reply, then tell them what actually happened.`;
+}
+export async function trackInChat(cfg, chatId, target, signal) {
+    const json = target.kind === "review"
+        ? { chat_id: chatId, kind: "review", owner: target.owner, repo: target.repo, pr_number: target.prNumber }
+        : { chat_id: chatId, kind: "stack", stack_id: target.stackId };
+    try {
+        const response = await apiFetch(cfg, "/api/v1/stacks/chat-waits", { method: "POST", json, signal, timeoutMs: 10_000 });
+        const body = response.body;
+        return response.status === 200 ? chatTaskOf(body?.task) : null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/lib/tools/credits.d.ts

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

package/dist/lib/tools/credits.js

@@ -0,0 +1,38 @@
+import { CommandError, getMe, loadConfig } from "mergestorm/client";
+function formatMinutes(value) {
+    return value.toLocaleString("en-US", { maximumFractionDigits: 1 });
+}
+function surgeSummary(surge) {
+    if (!surge)
+        return "";
+    const wallet = `wallet ${formatMinutes(surge.walletMinutes)} min`;
+    if (surge.includedMinutes <= 0)
+        return `\nSurge: ${wallet}`;
+    return (`\nSurge: ${formatMinutes(surge.usedMinutes)} of ${formatMinutes(surge.includedMinutes)} included min this period` +
+        ` · ${wallet}`);
+}
+export async function credits(cfg) {
+    const resolved = cfg ?? (await loadConfig());
+    const me = await getMe(resolved);
+    if (!me) {
+        throw new CommandError("Credits are not available right now (Mergestorm API is offline, unreachable, or too old).");
+    }
+    if (!me.usage) {
+        throw new CommandError("Credits are not available on this server yet. Update the API or use the dashboard.");
+    }
+    const standard = me.usage.standard;
+    const remaining = standard.remaining ??
+        (standard.limit != null ? Math.max(0, standard.limit - standard.used) : null);
+    const bonusRemaining = me.usage.bonus?.remaining;
+    const surge = me.usage.surge;
+    const bonusSummary = bonusRemaining == null ? "" : ` · ${bonusRemaining} bonus remaining`;
+    return {
+        summary: remaining == null
+            ? `${standard.used} used · unlimited${bonusSummary}${surgeSummary(surge)}`
+            : `${standard.used} used · ${remaining} remaining${bonusSummary}${surgeSummary(surge)}`,
+        data: {
+            usage: me.usage,
+            resets_at: me.resets_at ?? null,
+        },
+    };
+}

package/dist/lib/tools/cyclone-job.d.ts

@@ -0,0 +1,28 @@
+import type { Config } from "mergestorm/client";
+import type { ToolPayload } from "./types.js";
+export declare const CYCLONE_TASKS: readonly ["fix_findings", "fix_ci", "resolve_conflicts", "build"];
+export type CycloneTask = (typeof CYCLONE_TASKS)[number];
+export declare const CYCLONE_JOB_WAIT_DEFAULT_S = 45;
+export declare const CYCLONE_JOB_WAIT_MAX_S = 100;
+export declare const CYCLONE_JOB_POLL_MS = 5000;
+export declare const CYCLONE_JOB_TERMINAL_STATES: readonly ["pushed", "completed", "failed"];
+export declare const CYCLONE_START_WAIT_NOTE = "Wait for it now: call cyclone_job with this dispatch_id and timeout_s 45, again while it is queued or running, then tell the user what Cyclone pushed or why it failed.";
+export declare const CYCLONE_JOB_STILL_RUNNING_NOTE = "Cyclone is not done. Call cyclone_job again with this dispatch_id and timeout_s 45, and report the result once it is pushed, completed or failed.";
+export type CycloneStartInput = {
+    task: CycloneTask;
+    owner: string;
+    repo: string;
+    pr_number?: number;
+    failing_check?: string;
+    brief?: string;
+};
+export declare function cycloneStart(input: CycloneStartInput, cfg?: Config, chatId?: string | null): Promise<ToolPayload>;
+export declare function isCycloneJobTerminal(job: Record<string, unknown>): boolean;
+export declare function cycloneJobSummary(job: Record<string, unknown>): string;
+export type CycloneJobWaitDeps = {
+    pollMs?: number;
+    now?: () => number;
+    sleep?: (ms: number, signal?: AbortSignal) => Promise<void>;
+    signal?: AbortSignal;
+};
+export declare function cycloneJob(dispatchId: string, cfg?: Config, timeoutS?: number, deps?: CycloneJobWaitDeps): Promise<ToolPayload>;

package/dist/lib/tools/cyclone-job.js

@@ -0,0 +1,71 @@
+import { agentRequest } from "./agent-request.js";
+import { chatTaskNote, chatTaskOf } from "./chat-task.js";
+export const CYCLONE_TASKS = ["fix_findings", "fix_ci", "resolve_conflicts", "build"];
+export const CYCLONE_JOB_WAIT_DEFAULT_S = 45;
+export const CYCLONE_JOB_WAIT_MAX_S = 100;
+export const CYCLONE_JOB_POLL_MS = 5_000;
+export const CYCLONE_JOB_TERMINAL_STATES = ["pushed", "completed", "failed"];
+export const CYCLONE_START_WAIT_NOTE = `Wait for it now: call cyclone_job with this dispatch_id and timeout_s ${CYCLONE_JOB_WAIT_DEFAULT_S}, again while it is queued or running, then tell the user what Cyclone pushed or why it failed.`;
+export const CYCLONE_JOB_STILL_RUNNING_NOTE = `Cyclone is not done. Call cyclone_job again with this dispatch_id and timeout_s ${CYCLONE_JOB_WAIT_DEFAULT_S}, and report the result once it is pushed, completed or failed.`;
+export async function cycloneStart(input, cfg, chatId) {
+    const payload = await agentRequest("/api/v1/agents/cyclone/jobs", {
+        method: "POST",
+        json: {
+            task: input.task,
+            owner: input.owner,
+            repo: input.repo,
+            ...(input.pr_number !== undefined ? { pr_number: input.pr_number } : {}),
+            ...(input.failing_check ? { failing_check: input.failing_check } : {}),
+            ...(input.brief ? { brief: input.brief } : {}),
+            ...(chatId ? { chat_id: chatId } : {}),
+        },
+    }, cfg);
+    if (payload.isError || typeof payload.data.dispatch_id !== "string" || isCycloneJobTerminal(payload.data))
+        return payload;
+    const task = chatTaskOf(payload.data.background_task);
+    return { ...payload, summary: `${payload.summary} ${task ? chatTaskNote(task) : CYCLONE_START_WAIT_NOTE}` };
+}
+export function isCycloneJobTerminal(job) {
+    return CYCLONE_JOB_TERMINAL_STATES.includes(job.state);
+}
+export function cycloneJobSummary(job) {
+    const target = job.pr_number ? `${job.owner}/${job.repo}#${job.pr_number}` : `${job.owner}/${job.repo}`;
+    const parts = [`Cyclone ${job.task ?? "job"} on ${target}: ${job.state}`];
+    if (typeof job.outcome === "string" && job.outcome)
+        parts[0] += ` (${job.outcome})`;
+    if (typeof job.result_sha === "string" && job.result_sha)
+        parts.push(`pushed ${job.result_sha.slice(0, 10)}`);
+    if (typeof job.detail === "string" && job.detail)
+        parts.push(job.detail);
+    return parts.join(". ");
+}
+function sleepFor(ms, signal) {
+    return new Promise((resolve) => {
+        if (signal?.aborted)
+            return resolve();
+        const timer = setTimeout(done, ms);
+        function done() {
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", done);
+            resolve();
+        }
+        signal?.addEventListener("abort", done, { once: true });
+    });
+}
+export async function cycloneJob(dispatchId, cfg, timeoutS = 0, deps = {}) {
+    const now = deps.now ?? Date.now;
+    const sleep = deps.sleep ?? sleepFor;
+    const deadline = now() + Math.min(Math.max(timeoutS, 0), CYCLONE_JOB_WAIT_MAX_S) * 1000;
+    const route = `/api/v1/agents/cyclone/jobs/${encodeURIComponent(dispatchId)}`;
+    for (;;) {
+        const payload = await agentRequest(route, { method: "GET" }, cfg);
+        if (payload.isError)
+            return payload;
+        if (isCycloneJobTerminal(payload.data))
+            return { ...payload, summary: cycloneJobSummary(payload.data) };
+        const left = deadline - now();
+        if (left <= 0 || deps.signal?.aborted)
+            return { ...payload, summary: `${cycloneJobSummary(payload.data)}. ${CYCLONE_JOB_STILL_RUNNING_NOTE}` };
+        await sleep(Math.min(deps.pollMs ?? CYCLONE_JOB_POLL_MS, left), deps.signal);
+    }
+}

package/dist/lib/tools/envelope.d.ts

@@ -0,0 +1,5 @@
+import { type ReviewEnvelopeFallbacks, type ReviewJobRow } from "mergestorm/client";
+import type { ToolPayload } from "./types.js";
+export declare const MCP_REVIEW_STATUSES: readonly ["no_changes", "queued", "in_progress", "completed", "failed", "quota_exceeded", "rate_limited"];
+export declare function payloadFromRow(row: ReviewJobRow | null, fallback?: ReviewEnvelopeFallbacks): ToolPayload;
+export declare function payloadFromRateLimit(err: unknown, jobId?: string | null): ToolPayload | null;

package/dist/lib/tools/envelope.js

@@ -0,0 +1,30 @@
+import { isCommandErrorCode, toReviewJobEnvelope, } from "mergestorm/client";
+export const MCP_REVIEW_STATUSES = [
+    "no_changes",
+    "queued",
+    "in_progress",
+    "completed",
+    "failed",
+    "quota_exceeded",
+    "rate_limited",
+];
+export function payloadFromRow(row, fallback = {}) {
+    const envelope = toReviewJobEnvelope(row, fallback);
+    const bits = [envelope.status];
+    if (envelope.verdict)
+        bits.push(envelope.verdict);
+    return {
+        summary: `${envelope.job_id ?? fallback.jobId ?? "review"} · ${bits.join(" · ")}`,
+        data: envelope,
+    };
+}
+export function payloadFromRateLimit(err, jobId) {
+    if (!isCommandErrorCode(err, "rate_limited"))
+        return null;
+    return payloadFromRow(null, {
+        jobId,
+        status: "rate_limited",
+        error: err.message,
+        retryAfterSeconds: err.retryAfterSeconds,
+    });
+}

package/dist/lib/tools/issue-create.d.ts

@@ -0,0 +1,47 @@
+import { openStackIssue, parseGithubOriginRepo, type Config } from "mergestorm/client";
+import { z } from "zod";
+import type { ToolPayload } from "./types.js";
+export declare const issueCreateSchema: {
+    title: z.ZodString;
+    body: z.ZodOptional<z.ZodString>;
+    labels: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    owner: z.ZodOptional<z.ZodString>;
+    repo: z.ZodOptional<z.ZodString>;
+    cwd: z.ZodOptional<z.ZodString>;
+};
+export declare const hostedIssueCreateSchema: {
+    title: z.ZodString;
+    body: z.ZodOptional<z.ZodString>;
+    labels: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    owner: z.ZodString;
+    repo: z.ZodString;
+};
+declare const inputSchema: z.ZodObject<{
+    title: z.ZodString;
+    body: z.ZodOptional<z.ZodString>;
+    labels: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    owner: z.ZodOptional<z.ZodString>;
+    repo: z.ZodOptional<z.ZodString>;
+    cwd: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    title: string;
+    owner?: string | undefined;
+    body?: string | undefined;
+    labels?: string[] | undefined;
+    repo?: string | undefined;
+    cwd?: string | undefined;
+}, {
+    title: string;
+    owner?: string | undefined;
+    body?: string | undefined;
+    labels?: string[] | undefined;
+    repo?: string | undefined;
+    cwd?: string | undefined;
+}>;
+export type IssueCreateInput = z.infer<typeof inputSchema>;
+export type IssueCreateDeps = {
+    openStackIssue?: typeof openStackIssue;
+    parseGithubOriginRepo?: typeof parseGithubOriginRepo;
+};
+export declare function issueCreate(input: IssueCreateInput, cfg?: Config, deps?: IssueCreateDeps): Promise<ToolPayload>;
+export {};

package/dist/lib/tools/issue-create.js

@@ -0,0 +1,53 @@
+import { CommandError, openStackIssue, parseGithubOriginRepo } from "mergestorm/client";
+import { z } from "zod";
+export const issueCreateSchema = {
+    title: z.string().trim().min(1).max(256),
+    body: z.string().max(60_000).optional(),
+    labels: z.array(z.string().trim().min(1).max(50)).max(10).optional(),
+    owner: z.string().trim().regex(/^[A-Za-z0-9_.-]{1,100}$/).optional(),
+    repo: z.string().trim().regex(/^[A-Za-z0-9_.-]{1,100}$/).optional(),
+    cwd: z.string().trim().min(1).optional(),
+};
+export const hostedIssueCreateSchema = {
+    title: issueCreateSchema.title,
+    body: issueCreateSchema.body,
+    labels: issueCreateSchema.labels,
+    owner: z.string().trim().regex(/^[A-Za-z0-9_.-]{1,100}$/),
+    repo: z.string().trim().regex(/^[A-Za-z0-9_.-]{1,100}$/),
+};
+const inputSchema = z.object(issueCreateSchema);
+export async function issueCreate(input, cfg, deps = {}) {
+    const parsed = inputSchema.safeParse(input);
+    if (!parsed.success || Boolean(parsed.data.owner) !== Boolean(parsed.data.repo)) {
+        const message = "issue_create needs a one-line title of at most 256 characters, and owner and repo together";
+        return { summary: message, data: { error: { code: "invalid_input", message } }, isError: true };
+    }
+    const { title, body, labels, owner, repo, cwd } = parsed.data;
+    try {
+        const target = owner && repo ? { owner, repo } : (deps.parseGithubOriginRepo ?? parseGithubOriginRepo)(cwd);
+        if (!target) {
+            const message = "Could not read a GitHub owner/repo from origin. Pass owner and repo.";
+            return { summary: message, data: { error: { code: "invalid_input", message } }, isError: true };
+        }
+        const issue = await (deps.openStackIssue ?? openStackIssue)({ owner: target.owner, repo: target.repo, title, body: body ?? "", labels: labels ?? [] }, cfg);
+        return {
+            summary: `${issue.created ? "Opened" : "Already open:"} ${target.owner}/${target.repo}#${issue.number} ${issue.url}. Put "Fixes #${issue.number}" in the commit or pull request body.`,
+            data: { owner: target.owner, repo: target.repo, ...issue },
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            summary: message,
+            data: {
+                error: {
+                    code: err instanceof CommandError ? err.code ?? "issue_create_failed" : "issue_create_failed",
+                    message,
+                    ...(err instanceof CommandError && err.retryAfterSeconds !== undefined
+                        ? { retry_after_seconds: err.retryAfterSeconds } : {}),
+                },
+            },
+            isError: true,
+        };
+    }
+}

package/dist/lib/tools/memory.d.ts

@@ -0,0 +1,68 @@
+import { MEMORY_KINDS, MEMORY_MODES, MEMORY_SCOPES, deleteMemory, getMemoryMode, listMemories, saveMemory, searchMemories, setMemoryMode, updateMemory, type Config, type MemoryItem } from "mergestorm/client";
+import { z } from "zod";
+import type { ToolPayload } from "./types.js";
+export declare const listMemoriesSchema: {
+    scope: z.ZodOptional<z.ZodEnum<["user", "repo"]>>;
+    repo: z.ZodOptional<z.ZodString>;
+    kind: z.ZodOptional<z.ZodEnum<["rule", "style", "preference", "fact", "project"]>>;
+};
+export declare const searchMemorySchema: {
+    query: z.ZodString;
+    repo: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+};
+export declare const rememberSchema: {
+    text: z.ZodString;
+    kind: z.ZodEnum<["rule", "style", "preference", "fact", "project"]>;
+    repo: z.ZodOptional<z.ZodString>;
+};
+export declare const updateMemorySchema: {
+    id: z.ZodString;
+    text: z.ZodString;
+    kind: z.ZodOptional<z.ZodEnum<["rule", "style", "preference", "fact", "project"]>>;
+};
+export declare const forgetMemorySchema: {
+    id: z.ZodString;
+};
+export declare const setMemoryModeSchema: {
+    memory_mode: z.ZodEnum<["off", "on_request", "all"]>;
+};
+export type MemoryApi = {
+    listMemories: typeof listMemories;
+    searchMemories: typeof searchMemories;
+    saveMemory: typeof saveMemory;
+    updateMemory: typeof updateMemory;
+    deleteMemory: typeof deleteMemory;
+    getMemoryMode: typeof getMemoryMode;
+    setMemoryMode: typeof setMemoryMode;
+};
+export declare function memoryLine(memory: MemoryItem): string;
+export declare function createMemoryToolHandlers(cfg: Config | undefined, chatId: string | null, api?: MemoryApi): {
+    list: (input: {
+        scope?: (typeof MEMORY_SCOPES)[number];
+        repo?: string;
+        kind?: (typeof MEMORY_KINDS)[number];
+    }) => Promise<ToolPayload>;
+    search: (input: {
+        query: string;
+        repo?: string;
+        limit?: number;
+    }) => Promise<ToolPayload>;
+    remember: (input: {
+        text: string;
+        kind: (typeof MEMORY_KINDS)[number];
+        repo?: string;
+    }) => Promise<ToolPayload>;
+    update: (input: {
+        id: string;
+        text: string;
+        kind?: (typeof MEMORY_KINDS)[number];
+    }) => Promise<ToolPayload>;
+    forget: (input: {
+        id: string;
+    }) => Promise<ToolPayload>;
+    getMode: () => Promise<ToolPayload>;
+    setMode: (input: {
+        memory_mode: (typeof MEMORY_MODES)[number];
+    }) => Promise<ToolPayload>;
+};

package/dist/lib/tools/memory.js

@@ -0,0 +1,74 @@
+import { CommandError, MEMORY_KINDS, MEMORY_MODES, MEMORY_SCOPES, MEMORY_SEARCH_LIMIT_MAX, deleteMemory, getMemoryMode, listMemories, saveMemory, searchMemories, setMemoryMode, updateMemory, } from "mergestorm/client";
+import { z } from "zod";
+const memoryId = z.string().uuid();
+const memoryText = z.string().trim().min(1).max(500);
+const repo = z.string().trim().min(3).max(200);
+export const listMemoriesSchema = {
+    scope: z.enum(MEMORY_SCOPES).optional(),
+    repo: repo.optional(),
+    kind: z.enum(MEMORY_KINDS).optional(),
+};
+export const searchMemorySchema = {
+    query: z.string().trim().min(1).max(2000),
+    repo: repo.optional(),
+    limit: z.number().int().min(1).max(MEMORY_SEARCH_LIMIT_MAX).optional(),
+};
+export const rememberSchema = { text: memoryText, kind: z.enum(MEMORY_KINDS), repo: repo.optional() };
+export const updateMemorySchema = { id: memoryId, text: memoryText, kind: z.enum(MEMORY_KINDS).optional() };
+export const forgetMemorySchema = { id: memoryId };
+export const setMemoryModeSchema = { memory_mode: z.enum(MEMORY_MODES) };
+const liveApi = { listMemories, searchMemories, saveMemory, updateMemory, deleteMemory, getMemoryMode, setMemoryMode };
+export function memoryLine(memory) {
+    return `- [${memory.id}] (${memory.repo ? `${memory.kind}, ${memory.repo}` : memory.kind}) ${memory.text}`;
+}
+async function guarded(run) {
+    try {
+        return await run();
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const code = err instanceof CommandError ? err.code ?? "memory_failed" : "memory_failed";
+        return {
+            summary: message,
+            data: { error: { code, message, ...(err instanceof CommandError && err.retryAfterSeconds !== undefined ? { retry_after_seconds: err.retryAfterSeconds } : {}) } },
+            isError: true,
+        };
+    }
+}
+export function createMemoryToolHandlers(cfg, chatId, api = liveApi) {
+    return {
+        list: (input) => guarded(async () => {
+            const listed = await api.listMemories(input, cfg);
+            const count = listed.items.length === 1 ? "1 memory" : `${listed.items.length} memories`;
+            return { summary: [`Memory is ${listed.memory_mode}. ${count}.`, ...listed.items.map(memoryLine)].join("\n"), data: listed };
+        }),
+        search: (input) => guarded(async () => {
+            const found = await api.searchMemories({ ...input, chatId }, cfg);
+            const all = [...found.rules, ...found.items];
+            const summary = found.memory_mode === "off"
+                ? "Memory is off, so nothing was searched."
+                : all.length === 0 ? "Nothing in memory matches." : ["Memories that match, best first:", ...all.map(memoryLine)].join("\n");
+            return { summary, data: found };
+        }),
+        remember: (input) => guarded(async () => {
+            const saved = await api.saveMemory({ ...input, chatId }, cfg);
+            return { summary: saved.merged ? `That matched memory ${saved.id}, which now says this.` : `Saved to memory as ${saved.id}.`, data: saved };
+        }),
+        update: (input) => guarded(async () => {
+            const updated = await api.updateMemory(input.id, { text: input.text, ...(input.kind ? { kind: input.kind } : {}) }, cfg);
+            return { summary: `Memory ${updated.id} updated.`, data: updated };
+        }),
+        forget: (input) => guarded(async () => {
+            const deleted = await api.deleteMemory(input.id, cfg);
+            return { summary: `Memory ${deleted.id} forgotten.`, data: deleted };
+        }),
+        getMode: () => guarded(async () => {
+            const mode = await api.getMemoryMode(cfg);
+            return { summary: `Memory is ${mode.memory_mode}.`, data: mode };
+        }),
+        setMode: (input) => guarded(async () => {
+            const mode = await api.setMemoryMode(input.memory_mode, cfg);
+            return { summary: `Memory is now ${mode.memory_mode}.`, data: mode };
+        }),
+    };
+}

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

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

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

@@ -0,0 +1,79 @@
+import { apiFetch, CommandError, isCommandErrorCode, loadConfig, rateLimitedMessage, REVIEW_EXIT, } from "mergestorm/client";
+function entrySummary(entry) {
+    const prNumber = entry.bounceDetail?.prNumber;
+    const repo = `${entry.owner}/${entry.repo}${prNumber ? `#${prNumber}` : ""}`;
+    const reason = entry.bounceDetail?.kind ?? entry.bounceReason ?? entry.waitReason ?? undefined;
+    const sha = entry.bounceDetail?.headSha ?? entry.verifyHeadSha ?? undefined;
+    return [
+        entry.state,
+        repo,
+        `stack ${entry.stackId}`,
+        reason,
+        sha?.slice(0, 7),
+    ].filter(Boolean).join(" · ");
+}
+export async function queueStatus(stackId, cfg) {
+    try {
+        const resolved = cfg ?? (await loadConfig());
+        const id = stackId?.trim();
+        const { status, body, retryAfterSeconds } = await apiFetch(resolved, id
+            ? `/api/v1/stacks/queue?stackId=${encodeURIComponent(id)}`
+            : "/api/v1/stacks/queue");
+        if (status === 404) {
+            throw new CommandError("Merge queue route returned 404. Deploy the API.");
+        }
+        if (status === 429) {
+            throw new CommandError(rateLimitedMessage(retryAfterSeconds), REVIEW_EXIT.rate_limited, "rate_limited", { retryAfterSeconds });
+        }
+        if (status !== 200) {
+            throw new CommandError(`Failed to get queue status (HTTP ${status}): ${JSON.stringify(body)}`);
+        }
+        const entries = body.entries;
+        if (!Array.isArray(entries)) {
+            throw new CommandError(`Failed to get queue status (HTTP 200): ${JSON.stringify(body)}`);
+        }
+        if (id) {
+            const matchingEntries = entries.filter((candidate) => candidate?.stackId?.toLowerCase() === id.toLowerCase());
+            if (matchingEntries.length === 0) {
+                const message = `Queue entry not found for stack: ${id}`;
+                return {
+                    summary: message,
+                    data: {
+                        error: {
+                            code: "queue_entry_not_found",
+                            message,
+                            stack_id: id,
+                        },
+                    },
+                    isError: true,
+                };
+            }
+            return {
+                summary: matchingEntries.map(entrySummary).join("\n"),
+                data: { entries: matchingEntries },
+            };
+        }
+        return {
+            summary: entries.length === 0
+                ? "No merge queue entries (live or bounced)"
+                : entries.map(entrySummary).join("\n"),
+            data: { entries },
+        };
+    }
+    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/repo-settings.d.ts

@@ -0,0 +1,6 @@
+import { type Config, type RepoSettings, type RepoSettingsPatch } from "mergestorm/client";
+import type { ToolPayload } from "./types.js";
+export declare function repoSettingsSummary(entry: RepoSettings): string;
+export declare function repoSettingsPatchFromArgs(args: Record<string, unknown>): RepoSettingsPatch;
+export declare function repoSettingsGet(args: Record<string, unknown>, cfg?: Config): Promise<ToolPayload>;
+export declare function repoSettingsSet(args: Record<string, unknown>, cfg?: Config): Promise<ToolPayload>;