@rethunk/mcp-multi-root-git 2.1.0 → 2.3.0

package/dist/server/git-log-tool.js

@@ -14,12 +14,13 @@ const DEFAULT_SINCE = "7.days";
 // The format string itself is safe ASCII; git emits the byte.
 const FIELD_SEP_OUT = "\x01"; // what git outputs (SOH)
 const RECORD_SEP_OUT = "\x02"; // what git outputs (STX) — used as record-START marker
-// git log --pretty tformat: sha7, shaFull, subject, author, email, ISO date, relative date.
+// git log --pretty tformat: shaFull, subject, author, email, ISO date.
+// sha7 and ageRelative dropped in v3 (shaFull.slice(0,7) used for display; date is ISO).
 // %x02 is placed at the START of each record (tformat adds \n as terminator after each).
 // Splitting stdout on \x02 then gives empty-first-chunk + one chunk per commit,
 // each structured as:  <fields>\x01\n\n <shortstat text>\n
 // Fields are separated by %x01; the trailing \x01 before \n leaves one empty last field (ignored).
-const PRETTY_FORMAT = "%x02%h%x01%H%x01%s%x01%aN%x01%aE%x01%aI%x01%ar%x01";
+const PRETTY_FORMAT = "%x02%H%x01%s%x01%aN%x01%aE%x01%aI%x01";
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -101,18 +102,16 @@ async function runGitLog(opts) {
         const fieldsPart = newlineIdx >= 0 ? chunk.slice(0, newlineIdx) : chunk;
         const statPart = newlineIdx >= 0 ? chunk.slice(newlineIdx + 1) : "";
         const fields = fieldsPart.split(FIELD_SEP_OUT);
-        const [sha7, shaFull, subject, authorName, email, date, ageRelative] = fields;
-        if (!sha7 || !shaFull)
+        const [shaFull, subject, authorName, email, date] = fields;
+        if (!shaFull)
             continue;
         const stat = parseShortstat(statPart);
         const commit = {
-            sha7: sha7.trim(),
-            shaFull: shaFull.trim(),
+            sha: shaFull.trim(),
             subject: subject?.trim() ?? "",
             author: authorName?.trim() ?? "",
-            email: email?.trim() ?? "",
+            ...spreadDefined("email", email?.trim() || undefined),
             date: date?.trim() ?? "",
-            ageRelative: ageRelative?.trim() ?? "",
             ...spreadDefined("filesChanged", stat?.filesChanged),
             ...spreadDefined("insertions", stat?.insertions),
             ...spreadDefined("deletions", stat?.deletions),
@@ -123,7 +122,7 @@ async function runGitLog(opts) {
     const commits = truncated ? allCommits.slice(0, maxCommits) : allCommits;
     const omittedCount = truncated ? allCommits.length - maxCommits : 0;
     return {
-        workspace_root: top,
+        workspaceRoot: top,
         repo: basename(top),
         branch: resolvedBranch,
         commits,
@@ -137,14 +136,14 @@ async function runGitLog(opts) {
 function renderLogMarkdown(group, filterSummary) {
     const lines = [];
     lines.push(`### ${group.repo} (${group.branch})${filterSummary ? `  —  ${filterSummary}` : ""}`);
-    lines.push(`_root: ${group.workspace_root}_`);
+    lines.push(`_root: ${group.workspaceRoot}_`);
     lines.push("");
     if (group.commits.length === 0) {
         lines.push("_(no commits match)_");
     }
     else {
         for (const c of group.commits) {
-            lines.push(`- \`${c.sha7}\`  ${c.ageRelative}  ${c.subject}  —  ${c.author}`);
+            lines.push(`- \`${c.sha.slice(0, 7)}\`  ${c.date.slice(0, 10)}  ${c.subject}  —  ${c.author}`);
         }
     }
     if (group.truncated) {
@@ -160,8 +159,7 @@ export function registerGitLogTool(server) {
     server.addTool({
         name: "git_log",
         description: "Path-filtered, time-windowed read-only `git log` across one or more workspace roots. " +
-            "Returns structured commit history with author, date, subject, and optional diff stats. " +
-            "See docs/mcp-tools.md.",
+            "Returns structured commit history with author, date, subject, and optional diff stats.",
         annotations: {
             readOnlyHint: true,
         },
@@ -216,7 +214,7 @@ export function registerGitLogTool(server) {
             const results = await asyncPool(jobs, GIT_SUBPROCESS_PARALLELISM, async ({ rootInput }) => {
                 const top = gitTopLevel(rootInput);
                 if (!top) {
-                    return { _error: true, workspace_root: rootInput, error: "not_a_git_repo" };
+                    return { _error: true, workspaceRoot: rootInput, error: "not_a_git_repository" };
                 }
                 const r = await runGitLog({
                     top,
@@ -228,7 +226,7 @@ export function registerGitLogTool(server) {
                     branch: args.branch,
                 });
                 if ("error" in r) {
-                    return { _error: true, workspace_root: rootInput, error: r.error };
+                    return { _error: true, workspaceRoot: rootInput, error: r.error };
                 }
                 return { _error: false, ...r };
             });
@@ -245,8 +243,8 @@ export function registerGitLogTool(server) {
                 const groups = results.map((r) => {
                     if (r._error) {
                         return {
-                            workspace_root: r.workspace_root,
-                            repo: basename(r.workspace_root),
+                            workspaceRoot: r.workspaceRoot,
+                            repo: basename(r.workspaceRoot ?? ""),
                             branch: "",
                             commits: [],
                             ...spreadWhen(true, { error: r.error }),
@@ -264,7 +262,7 @@ export function registerGitLogTool(server) {
             const mdChunks = ["# Git log"];
             for (const r of results) {
                 if (r._error) {
-                    mdChunks.push(`### ${r.workspace_root}\n_error: ${r.error}_`);
+                    mdChunks.push(`### ${r.workspaceRoot}\n_error: ${r.error}_`);
                     continue;
                 }
                 const { _error: _e, ...group } = r;

package/dist/server/git-merge-tool.js

@@ -0,0 +1,378 @@
+import { z } from "zod";
+import { spawnGitAsync } from "./git.js";
+import { conflictPaths, getCurrentBranch, isFullyMergedInto, isProtectedBranch, isSafeGitRefToken, isWorkingTreeClean, resolveRef, worktreeForBranch, } from "./git-refs.js";
+import { jsonRespond, spreadDefined, spreadWhen } from "./json.js";
+import { requireSingleRepo } from "./roots.js";
+import { WorkspacePickSchema } from "./schemas.js";
+// ---------------------------------------------------------------------------
+// Schemas
+// ---------------------------------------------------------------------------
+const StrategySchema = z
+    .enum(["auto", "ff-only", "rebase", "merge"])
+    .optional()
+    .default("auto")
+    .describe("`auto` (default): cascade fast-forward → rebase → merge-commit per source. " +
+    "`ff-only`: only fast-forward, fail if diverged. " +
+    "`rebase`: rebase source onto destination, then fast-forward (no merge-commit fallback). " +
+    "`merge`: always create a merge commit (no fast-forward).");
+// ---------------------------------------------------------------------------
+// Abort helpers
+// ---------------------------------------------------------------------------
+async function abortMerge(gitTop) {
+    await spawnGitAsync(gitTop, ["merge", "--abort"]);
+}
+async function abortRebase(gitTop) {
+    await spawnGitAsync(gitTop, ["rebase", "--abort"]);
+}
+// ---------------------------------------------------------------------------
+// Per-source merge logic
+// ---------------------------------------------------------------------------
+/**
+ * Attempt to land `source` on `into`. Caller must ensure `into` is checked out.
+ * On conflict the repo state is cleaned (merge/rebase aborted, HEAD restored to `into`).
+ */
+async function mergeOneSource(gitTop, into, source, strategy, mergeMessage) {
+    // --- Classify state via merge-base ---
+    const intoSha = await resolveRef(gitTop, into);
+    const sourceSha = await resolveRef(gitTop, source);
+    if (!sourceSha) {
+        return { source, ok: false, error: "source_not_found" };
+    }
+    if (!intoSha) {
+        return { source, ok: false, error: "destination_not_found" };
+    }
+    const mb = await spawnGitAsync(gitTop, ["merge-base", into, source]);
+    if (!mb.ok) {
+        return {
+            source,
+            ok: false,
+            error: "merge_base_failed",
+            detail: (mb.stderr || mb.stdout).trim(),
+        };
+    }
+    const mergeBase = mb.stdout.trim();
+    // source fully contained in into → noop
+    if (mergeBase === sourceSha) {
+        return { source, ok: true, outcome: "up_to_date", mergedSha: intoSha };
+    }
+    // into fully contained in source → fast-forward is the right move
+    const canFastForward = mergeBase === intoSha;
+    // --- ff-only strategy ---
+    if (strategy === "ff-only") {
+        if (!canFastForward) {
+            return {
+                source,
+                ok: false,
+                error: "cannot_fast_forward",
+                detail: "destination and source have diverged; retry with strategy: rebase, merge, or auto",
+            };
+        }
+        return fastForward(gitTop, source);
+    }
+    // --- Fast-forward path for auto/rebase when applicable ---
+    if (canFastForward && (strategy === "auto" || strategy === "rebase")) {
+        return fastForward(gitTop, source);
+    }
+    // --- merge strategy: always merge commit ---
+    if (strategy === "merge") {
+        return mergeCommit(gitTop, source, mergeMessage, into);
+    }
+    // --- rebase or auto (diverged case) ---
+    const rebased = await rebaseSourceOntoInto(gitTop, into, source);
+    if (rebased.ok) {
+        // Rebase succeeded; FF destination up to the now-rebased source tip.
+        const ff = await fastForward(gitTop, source);
+        if (!ff.ok)
+            return ff;
+        return { ...ff, outcome: "rebase_then_ff" };
+    }
+    if (strategy === "rebase") {
+        return rebased; // caller opted out of merge-commit fallback
+    }
+    // auto: fall through to merge commit
+    return mergeCommit(gitTop, source, mergeMessage, into);
+}
+async function fastForward(gitTop, source) {
+    const r = await spawnGitAsync(gitTop, ["merge", "--ff-only", source]);
+    if (!r.ok) {
+        await abortMerge(gitTop);
+        return {
+            source,
+            ok: false,
+            outcome: "conflicts",
+            conflictStage: "merge",
+            conflictPaths: [],
+            error: "merge_failed",
+            detail: (r.stderr || r.stdout).trim(),
+        };
+    }
+    const head = await spawnGitAsync(gitTop, ["rev-parse", "HEAD"]);
+    return {
+        source,
+        ok: true,
+        outcome: "fast_forward",
+        mergedSha: head.ok ? head.stdout.trim() : undefined,
+    };
+}
+async function mergeCommit(gitTop, source, message, into) {
+    const msg = message?.trim() || `Merge branch '${source}' into ${into}`;
+    const r = await spawnGitAsync(gitTop, ["merge", "--no-ff", "--no-edit", "-m", msg, source]);
+    if (!r.ok) {
+        const paths = await conflictPaths(gitTop);
+        await abortMerge(gitTop);
+        return {
+            source,
+            ok: false,
+            outcome: "conflicts",
+            conflictStage: "merge",
+            conflictPaths: paths,
+            error: "merge_conflicts",
+            detail: (r.stderr || r.stdout).trim(),
+        };
+    }
+    const head = await spawnGitAsync(gitTop, ["rev-parse", "HEAD"]);
+    return {
+        source,
+        ok: true,
+        outcome: "merge_commit",
+        mergedSha: head.ok ? head.stdout.trim() : undefined,
+    };
+}
+/**
+ * Rebase `source` onto `into`, then return to `into`.
+ * On failure: abort rebase, check out `into` again, return structured conflict.
+ */
+async function rebaseSourceOntoInto(gitTop, into, source) {
+    // `git rebase <upstream> <branch>` first switches to <branch>.
+    const r = await spawnGitAsync(gitTop, ["rebase", into, source]);
+    if (!r.ok) {
+        const paths = await conflictPaths(gitTop);
+        await abortRebase(gitTop);
+        // Ensure we're back on `into` regardless of rebase state.
+        await spawnGitAsync(gitTop, ["checkout", into]);
+        return {
+            source,
+            ok: false,
+            outcome: "conflicts",
+            conflictStage: "rebase",
+            conflictPaths: paths,
+            error: "rebase_conflicts",
+            detail: (r.stderr || r.stdout).trim(),
+        };
+    }
+    // Rebase succeeded; switch back to destination so the caller can FF.
+    const co = await spawnGitAsync(gitTop, ["checkout", into]);
+    if (!co.ok) {
+        return {
+            source,
+            ok: false,
+            error: "checkout_failed",
+            detail: (co.stderr || co.stdout).trim(),
+        };
+    }
+    return { source, ok: true }; // caller FFs
+}
+// ---------------------------------------------------------------------------
+// Cleanup helpers
+// ---------------------------------------------------------------------------
+async function maybeRemoveWorktree(gitTop, source, enabled) {
+    if (!enabled)
+        return undefined;
+    const path = await worktreeForBranch(gitTop, source);
+    if (!path)
+        return undefined;
+    // Re-check protected names against the worktree path's trailing segment too.
+    const tail = path.split("/").pop() ?? "";
+    if (isProtectedBranch(tail))
+        return undefined;
+    const r = await spawnGitAsync(gitTop, ["worktree", "remove", path]);
+    return r.ok ? path : undefined;
+}
+async function maybeDeleteBranch(gitTop, source, enabled, into) {
+    if (!enabled)
+        return false;
+    if (isProtectedBranch(source))
+        return false;
+    // Safety double-check: source must be fully merged into destination.
+    const merged = await isFullyMergedInto(gitTop, source, into);
+    if (!merged)
+        return false;
+    const r = await spawnGitAsync(gitTop, ["branch", "-d", source]);
+    return r.ok;
+}
+// ---------------------------------------------------------------------------
+// Tool registration
+// ---------------------------------------------------------------------------
+export function registerGitMergeTool(server) {
+    server.addTool({
+        name: "git_merge",
+        description: "Merge one or more source branches into a destination. Default strategy `auto` " +
+            "cascades fast-forward → rebase → merge-commit per source, preferring linear history. " +
+            "Refuses if the working tree is dirty. Stops on the first conflict and reports " +
+            "the affected paths. Optional flags auto-delete merged branches and worktrees, " +
+            "skipping protected names (main, master, dev, develop, stable, trunk, prod, " +
+            "production, release/*, hotfix/*).",
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+        },
+        parameters: WorkspacePickSchema.extend({
+            sources: z
+                .array(z.string().min(1))
+                .min(1)
+                .max(20)
+                .describe("Branches to merge into the destination, in order."),
+            into: z
+                .string()
+                .optional()
+                .describe("Destination branch. Defaults to the currently checked-out branch."),
+            strategy: StrategySchema,
+            message: z
+                .string()
+                .optional()
+                .describe("Merge commit message (used only when a merge commit is created)."),
+            deleteMergedBranches: z
+                .boolean()
+                .optional()
+                .default(false)
+                .describe("After all sources merge cleanly, delete each source branch locally (`git branch -d`). " +
+                "Protected names always skipped. Never affects remote branches."),
+            deleteMergedWorktrees: z
+                .boolean()
+                .optional()
+                .default(false)
+                .describe("After all sources merge cleanly, remove any local worktree currently checked out " +
+                "on a source branch (`git worktree remove`). Protected tails always skipped."),
+        }),
+        execute: async (args) => {
+            const pre = requireSingleRepo(server, args);
+            if (!pre.ok)
+                return jsonRespond(pre.error);
+            const gitTop = pre.gitTop;
+            // --- Validate ref tokens early ---
+            for (const s of args.sources) {
+                if (!isSafeGitRefToken(s)) {
+                    return jsonRespond({ error: "unsafe_ref_token", ref: s });
+                }
+            }
+            if (args.into !== undefined && !isSafeGitRefToken(args.into)) {
+                return jsonRespond({ error: "unsafe_ref_token", ref: args.into });
+            }
+            // --- Resolve destination ---
+            const startBranch = await getCurrentBranch(gitTop);
+            const into = args.into?.trim() || startBranch;
+            if (!into) {
+                return jsonRespond({ error: "into_detached_head" });
+            }
+            // --- Refuse dirty tree ---
+            if (!(await isWorkingTreeClean(gitTop))) {
+                return jsonRespond({ error: "working_tree_dirty" });
+            }
+            // --- Ensure destination is checked out ---
+            if (into !== startBranch) {
+                const co = await spawnGitAsync(gitTop, ["checkout", into]);
+                if (!co.ok) {
+                    return jsonRespond({
+                        error: "checkout_failed",
+                        detail: (co.stderr || co.stdout).trim(),
+                    });
+                }
+            }
+            // Verify destination exists after checkout.
+            const intoShaProbe = await resolveRef(gitTop, into);
+            if (!intoShaProbe) {
+                return jsonRespond({ error: "destination_not_found", ref: into });
+            }
+            // --- Merge each source sequentially ---
+            const strategy = args.strategy ?? "auto";
+            const results = [];
+            let firstConflict = false;
+            for (const source of args.sources) {
+                const r = await mergeOneSource(gitTop, into, source, strategy, args.message);
+                results.push(r);
+                if (!r.ok) {
+                    firstConflict = true;
+                    break;
+                }
+            }
+            const allOk = !firstConflict && results.every((r) => r.ok);
+            // --- Cleanup (only on full success) ---
+            if (allOk) {
+                for (let i = 0; i < results.length; i++) {
+                    const r = results[i];
+                    if (!r || r.outcome === "up_to_date")
+                        continue;
+                    const worktreeRemoved = await maybeRemoveWorktree(gitTop, r.source, args.deleteMergedWorktrees ?? false);
+                    const branchDeleted = await maybeDeleteBranch(gitTop, r.source, args.deleteMergedBranches ?? false, into);
+                    results[i] = {
+                        ...r,
+                        ...spreadDefined("worktreeRemoved", worktreeRemoved),
+                        ...spreadWhen(branchDeleted, { branchDeleted: true }),
+                    };
+                }
+            }
+            const headProbe = await spawnGitAsync(gitTop, ["rev-parse", "HEAD"]);
+            const headSha = headProbe.ok ? headProbe.stdout.trim() : undefined;
+            if (args.format === "json") {
+                return jsonRespond({
+                    ok: allOk,
+                    into,
+                    strategy,
+                    ...spreadDefined("headSha", headSha),
+                    applied: results.filter((r) => r.ok).length,
+                    total: args.sources.length,
+                    results: results.map((r) => ({
+                        source: r.source,
+                        ok: r.ok,
+                        ...spreadDefined("outcome", r.outcome),
+                        ...spreadDefined("mergedSha", r.mergedSha),
+                        ...spreadDefined("conflictStage", r.conflictStage),
+                        ...spreadWhen((r.conflictPaths?.length ?? 0) > 0, {
+                            conflictPaths: r.conflictPaths,
+                        }),
+                        ...spreadWhen(r.branchDeleted === true, { branchDeleted: true }),
+                        ...spreadDefined("worktreeRemoved", r.worktreeRemoved),
+                        ...spreadDefined("skipReason", r.skipReason),
+                        ...spreadDefined("error", r.error),
+                        ...spreadDefined("detail", r.detail),
+                    })),
+                });
+            }
+            // --- Markdown ---
+            const lines = [];
+            const applied = results.filter((r) => r.ok).length;
+            const header = allOk
+                ? `# Merge into \`${into}\`: ${applied}/${args.sources.length} sources applied`
+                : `# Merge into \`${into}\`: ${applied}/${args.sources.length} sources applied (stopped on conflict)`;
+            lines.push(header, "");
+            for (const r of results) {
+                const icon = r.ok ? "✓" : "✗";
+                const tail = [];
+                if (r.outcome)
+                    tail.push(r.outcome);
+                if (r.mergedSha)
+                    tail.push(`\`${r.mergedSha.slice(0, 7)}\``);
+                if (r.branchDeleted)
+                    tail.push("branch deleted");
+                if (r.worktreeRemoved)
+                    tail.push(`worktree removed: ${r.worktreeRemoved}`);
+                lines.push(`${icon} ${r.source}${tail.length ? `  —  ${tail.join(", ")}` : ""}`);
+                if (!r.ok) {
+                    if (r.conflictPaths?.length) {
+                        for (const p of r.conflictPaths)
+                            lines.push(`  conflict: ${p}`);
+                    }
+                    if (r.error)
+                        lines.push(`  Error: ${r.error}${r.detail ? ` — ${r.detail}` : ""}`);
+                }
+            }
+            if (!allOk) {
+                const skipped = args.sources.length - results.length;
+                if (skipped > 0)
+                    lines.push("", `${skipped} remaining source(s) skipped.`);
+            }
+            return lines.join("\n");
+        },
+    });
+}

package/dist/server/git-parity-tool.js

@@ -8,7 +8,10 @@ import { WorkspacePickSchema } from "./schemas.js";
 export function registerGitParityTool(server) {
     server.addTool({
         name: "git_parity",
-        description: "Read-only HEAD parity for path pairs. See docs/mcp-tools.md.",
+        description: "Read-only HEAD parity for path pairs.",
+        annotations: {
+            readOnlyHint: true,
+        },
         parameters: WorkspacePickSchema.extend({
             pairs: z
                 .array(z.object({

package/dist/server/git-push-tool.js

@@ -0,0 +1,109 @@
+import { z } from "zod";
+import { isSafeGitUpstreamToken, spawnGitAsync } from "./git.js";
+import { getCurrentBranch, inferRemoteFromUpstream, isSafeGitRefToken } from "./git-refs.js";
+import { jsonRespond, spreadDefined } from "./json.js";
+import { requireSingleRepo } from "./roots.js";
+import { WorkspacePickSchema } from "./schemas.js";
+export function registerGitPushTool(server) {
+    server.addTool({
+        name: "git_push",
+        description: "Push the current branch to its configured upstream. " +
+            "Use `setUpstream: true` to set tracking (`-u`) when no upstream is configured yet. " +
+            "Refuses on detached HEAD. Does not force-push.",
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+        },
+        parameters: WorkspacePickSchema.extend({
+            remote: z
+                .string()
+                .optional()
+                .describe("Remote to push to. Defaults to the remote inferred from the current upstream tracking " +
+                "ref, or `origin` when `setUpstream` is true."),
+            branch: z
+                .string()
+                .optional()
+                .describe("Branch to push. Defaults to the currently checked-out branch. " +
+                "Rejected when HEAD is detached."),
+            setUpstream: z
+                .boolean()
+                .optional()
+                .default(false)
+                .describe("Set the upstream tracking reference (`git push -u`). " +
+                "Use when the branch has not been pushed yet. Remote defaults to `origin`."),
+        }),
+        execute: async (args) => {
+            const pre = requireSingleRepo(server, args);
+            if (!pre.ok)
+                return jsonRespond(pre.error);
+            const { gitTop } = pre;
+            // --- Resolve branch ---
+            const currentBranch = await getCurrentBranch(gitTop);
+            const branch = args.branch?.trim() || currentBranch;
+            if (!branch) {
+                return jsonRespond({ error: "push_detached_head" });
+            }
+            if (!isSafeGitRefToken(branch)) {
+                return jsonRespond({ error: "unsafe_ref_token", ref: branch });
+            }
+            // --- Resolve remote ---
+            let remote;
+            if (args.remote?.trim()) {
+                if (!isSafeGitUpstreamToken(args.remote.trim())) {
+                    return jsonRespond({ error: "unsafe_remote_token", remote: args.remote.trim() });
+                }
+                remote = args.remote.trim();
+            }
+            else if (args.setUpstream) {
+                // No explicit remote and we're setting upstream — default to origin.
+                remote = "origin";
+            }
+            else {
+                // Infer remote from existing upstream tracking ref.
+                const t = await inferRemoteFromUpstream(gitTop);
+                if (!t.ok) {
+                    return jsonRespond({
+                        error: "push_no_upstream",
+                        branch,
+                        detail: t.detail,
+                    });
+                }
+                remote = t.remote;
+            }
+            // --- Push ---
+            const pushArgs = ["push"];
+            if (args.setUpstream)
+                pushArgs.push("-u");
+            pushArgs.push(remote, branch);
+            const pushResult = await spawnGitAsync(gitTop, pushArgs);
+            if (!pushResult.ok) {
+                return jsonRespond({
+                    ok: false,
+                    branch,
+                    remote,
+                    error: "push_failed",
+                    detail: (pushResult.stderr || pushResult.stdout).trim(),
+                });
+            }
+            // Probe the upstream tracking ref now (may have been set by -u).
+            const upstreamProbe = await spawnGitAsync(gitTop, [
+                "rev-parse",
+                "--abbrev-ref",
+                "--symbolic-full-name",
+                "@{u}",
+            ]);
+            const upstream = upstreamProbe.ok ? upstreamProbe.stdout.trim() : `${remote}/${branch}`;
+            if (args.format === "json") {
+                return jsonRespond({
+                    ok: true,
+                    branch,
+                    remote,
+                    upstream,
+                    ...spreadDefined("setUpstream", args.setUpstream || undefined),
+                });
+            }
+            return `# Push\n✓ ${branch} → ${upstream}`;
+        },
+    });
+}