@rethunk/mcp-multi-root-git 2.3.3 → 2.4.0

package/dist/server/batch-commit-tool.js

@@ -5,9 +5,24 @@ import { getCurrentBranch, inferRemoteFromUpstream } from "./git-refs.js";
 import { jsonRespond, spreadDefined, spreadWhen } from "./json.js";
 import { requireSingleRepo } from "./roots.js";
 import { WorkspacePickSchema } from "./schemas.js";
+const FileEntrySchema = z.union([
+    z.string().min(1),
+    z.object({
+        path: z.string().min(1).describe("File path relative to git root."),
+        lines: z
+            .object({
+            from: z.number().int().min(1).describe("Start line number (1-indexed)."),
+            to: z.number().int().min(1).describe("End line number (1-indexed, inclusive)."),
+        })
+            .describe("Line range to stage. Only hunks overlapping [from, to] are staged."),
+    }),
+]);
 const CommitEntrySchema = z.object({
     message: z.string().min(1).describe("Commit message."),
-    files: z.array(z.string().min(1)).min(1).describe("Paths to stage, relative to the git root."),
+    files: z
+        .array(FileEntrySchema)
+        .min(1)
+        .describe("Paths to stage, relative to the git root. Each can be a string path or { path, lines } for hunk-level staging."),
 });
 const PushModeSchema = z
     .enum(["never", "after"])
@@ -16,6 +31,132 @@ const PushModeSchema = z
     .describe("`never` (default): no push. `after`: push the current branch to its upstream once all commits succeed; " +
     "fails with `push_no_upstream` if the branch has no upstream (commits are NOT rolled back). " +
     "Enum reserved for future modes such as `force-with-lease`.");
+const DryRunSchema = z
+    .boolean()
+    .optional()
+    .default(false)
+    .describe("When true, stage files, collect preview (files staged, commit messages), return preview response without writing commits. " +
+    "Unstages any files that were staged for the preview. Response indicates DRY RUN mode.");
+/**
+ * Parses a unified diff to extract hunks that overlap with a given line range.
+ * Returns a partial patch containing only the overlapping hunks, including header lines.
+ * Uses new file line numbers (after @@) to determine overlap.
+ */
+function extractOverlappingHunks(diffContent, fromLine, toLine) {
+    const lines = diffContent.split("\n");
+    // Find file header lines (index, ---, +++)
+    const fileHeaderLines = [];
+    let firstHunkIdx = -1;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (line === undefined)
+            continue;
+        if (line.startsWith("@@")) {
+            firstHunkIdx = i;
+            break;
+        }
+        fileHeaderLines.push(line);
+    }
+    if (firstHunkIdx === -1) {
+        // No hunks found
+        return null;
+    }
+    const result = [...fileHeaderLines];
+    let i = firstHunkIdx;
+    while (i < lines.length) {
+        const line = lines[i];
+        if (line === undefined) {
+            i++;
+            continue;
+        }
+        // Match hunk header: @@ -oldStart,oldCount +newStart,newCount @@
+        const hunkMatch = /^@@\s+-\d+(?:,\d+)?\s+\+(\d+)(?:,(\d+))?\s+@@/.exec(line);
+        if (hunkMatch) {
+            const newStart = Number.parseInt(hunkMatch[1] || "0", 10);
+            const newCount = Number.parseInt(hunkMatch[2] || "1", 10);
+            const hunkEnd = newStart + newCount - 1;
+            // Check if hunk overlaps with requested line range
+            const hasOverlap = !(hunkEnd < fromLine || newStart > toLine);
+            if (hasOverlap) {
+                // Add hunk header
+                result.push(line);
+                i++;
+                // Add hunk content until next hunk or EOF
+                while (i < lines.length) {
+                    const contentLine = lines[i];
+                    if (contentLine === undefined) {
+                        i++;
+                        continue;
+                    }
+                    // Stop at next hunk header
+                    if (contentLine.startsWith("@@")) {
+                        break;
+                    }
+                    result.push(contentLine);
+                    i++;
+                }
+            }
+            else {
+                // Skip hunk
+                i++;
+                while (i < lines.length) {
+                    const contentLine = lines[i];
+                    if (contentLine === undefined) {
+                        i++;
+                        continue;
+                    }
+                    if (contentLine.startsWith("@@")) {
+                        break;
+                    }
+                    i++;
+                }
+            }
+        }
+        else {
+            i++;
+        }
+    }
+    return result.length > fileHeaderLines.length ? result.join("\n") : null;
+}
+/**
+ * Stages a file with optional line range. If lines are provided, only hunks
+ * overlapping the range are staged via a partial patch. Otherwise, stages the whole file.
+ */
+async function stageFile(gitTop, filePath, lines) {
+    if (!lines) {
+        // Simple case: stage the whole file
+        const addResult = await spawnGitAsync(gitTop, ["add", "--", filePath]);
+        return {
+            ok: addResult.ok,
+            error: addResult.ok ? undefined : (addResult.stderr || addResult.stdout).trim(),
+        };
+    }
+    // Line range case: extract overlapping hunks and apply patch
+    const diffResult = await spawnGitAsync(gitTop, ["diff", filePath]);
+    if (!diffResult.ok) {
+        return { ok: false, error: (diffResult.stderr || diffResult.stdout).trim() };
+    }
+    const partialPatch = extractOverlappingHunks(diffResult.stdout, lines.from, lines.to);
+    if (!partialPatch) {
+        return { ok: false, error: "No hunks found in line range" };
+    }
+    // Write partial patch to temp file in the git repo and apply it to the index
+    const tempPatchFile = `${gitTop}/.git/.mcp-patch-${Date.now()}-${Math.random().toString(36).slice(2)}.patch`;
+    const { writeFileSync, unlinkSync } = await import("node:fs");
+    writeFileSync(tempPatchFile, partialPatch, "utf8");
+    const applyResult = await spawnGitAsync(gitTop, ["apply", "--cached", tempPatchFile]);
+    // Clean up temp file
+    try {
+        unlinkSync(tempPatchFile);
+    }
+    catch {
+        // Ignore cleanup errors
+    }
+    return {
+        ok: applyResult.ok,
+        error: applyResult.ok ? undefined : (applyResult.stderr || applyResult.stdout).trim(),
+    };
+}
 /**
  * After all commits succeed, push the current branch to its upstream.
  * Commits are already applied at this point — do NOT attempt rollback on push failure.
@@ -39,7 +180,13 @@ export async function runPushAfter(gitTop) {
             detail: (pushResult.stderr || pushResult.stdout).trim(),
         };
     }
-    return { ok: true, branch, upstream: t.upstream };
+    const gitOutput = (pushResult.stdout || pushResult.stderr).trim();
+    return {
+        ok: true,
+        branch,
+        upstream: t.upstream,
+        ...spreadDefined("output", gitOutput || undefined),
+    };
 }
 export function registerBatchCommitTool(server) {
     server.addTool({
@@ -47,7 +194,8 @@ export function registerBatchCommitTool(server) {
         description: "Create multiple sequential git commits in a single call. " +
             "Each entry stages the listed files then commits with the given message. " +
             'Stops on first failure. Optional `push: "after"` pushes the current branch ' +
-            "to its upstream once all commits succeed.",
+            "to its upstream once all commits succeed. " +
+            "Optional `dryRun: true` previews what would be staged/committed without writing commits.",
         annotations: {
             readOnlyHint: false,
             destructiveHint: false,
@@ -60,6 +208,7 @@ export function registerBatchCommitTool(server) {
                 .max(50)
                 .describe("Commits to create, applied in order."),
             push: PushModeSchema,
+            dryRun: DryRunSchema,
         }),
         execute: async (args) => {
             const pre = requireSingleRepo(server, args);
@@ -67,16 +216,30 @@ export function registerBatchCommitTool(server) {
                 return jsonRespond(pre.error);
             const gitTop = pre.gitTop;
             const results = [];
+            const stagedFilesForCleanup = new Set();
             for (let i = 0; i < args.commits.length; i++) {
                 const entry = args.commits[i];
                 if (!entry)
                     break;
+                // Normalize file entries to { path, lines? } format
+                const fileEntries = [];
+                const filePaths = [];
+                for (const fileEntry of entry.files) {
+                    if (typeof fileEntry === "string") {
+                        fileEntries.push({ path: fileEntry });
+                        filePaths.push(fileEntry);
+                    }
+                    else {
+                        fileEntries.push(fileEntry);
+                        filePaths.push(fileEntry.path);
+                    }
+                }
                 // --- Validate all paths are under the git toplevel ---
                 const escapedPaths = [];
-                for (const rel of entry.files) {
-                    const abs = resolvePathForRepo(rel, gitTop);
+                for (const path of filePaths) {
+                    const abs = resolvePathForRepo(path, gitTop);
                     if (!isStrictlyUnderGitTop(abs, gitTop)) {
-                        escapedPaths.push(rel);
+                        escapedPaths.push(path);
                     }
                 }
                 if (escapedPaths.length > 0) {
@@ -84,53 +247,94 @@ export function registerBatchCommitTool(server) {
                         index: i,
                         ok: false,
                         message: entry.message,
-                        files: entry.files,
+                        files: filePaths,
                         error: "path_escapes_repository",
                         detail: escapedPaths.join(", "),
                     });
                     break;
                 }
-                // --- Stage files ---
-                const addResult = await spawnGitAsync(gitTop, ["add", "--", ...entry.files]);
-                if (!addResult.ok) {
+                // --- Stage files (with optional line ranges) ---
+                let stagingFailed = false;
+                let stagingError = "";
+                for (const fileEntry of fileEntries) {
+                    const stageResult = await stageFile(gitTop, fileEntry.path, fileEntry.lines);
+                    if (!stageResult.ok) {
+                        stagingFailed = true;
+                        stagingError = stageResult.error || "Unknown error";
+                        break;
+                    }
+                }
+                if (stagingFailed) {
                     results.push({
                         index: i,
                         ok: false,
                         message: entry.message,
-                        files: entry.files,
+                        files: filePaths,
                         error: "stage_failed",
-                        detail: (addResult.stderr || addResult.stdout).trim(),
+                        detail: stagingError,
+                        ...spreadDefined("output", stagingError || undefined),
                     });
                     break;
                 }
+                // Track staged files for cleanup in dry-run
+                if (args.dryRun) {
+                    for (const path of filePaths) {
+                        stagedFilesForCleanup.add(path);
+                    }
+                }
+                // --- Dry-run mode: collect preview and unstage ---
+                if (args.dryRun) {
+                    // Get diff stat for this staged entry
+                    const diffStatResult = await spawnGitAsync(gitTop, ["diff", "--staged", "--stat"]);
+                    const diffStat = diffStatResult.ok ? (diffStatResult.stdout || "").trim() : undefined;
+                    results.push({
+                        index: i,
+                        ok: true,
+                        message: entry.message,
+                        files: filePaths,
+                        staged: filePaths,
+                        ...spreadDefined("diffStat", diffStat || undefined),
+                    });
+                    continue; // Skip actual commit in dry-run mode
+                }
                 // --- Commit ---
                 const commitResult = await spawnGitAsync(gitTop, ["commit", "-m", entry.message]);
                 if (!commitResult.ok) {
+                    const gitOutput = (commitResult.stderr || commitResult.stdout).trim();
                     results.push({
                         index: i,
                         ok: false,
                         message: entry.message,
-                        files: entry.files,
+                        files: filePaths,
                         error: "commit_failed",
-                        detail: (commitResult.stderr || commitResult.stdout).trim(),
+                        detail: gitOutput,
+                        ...spreadDefined("output", gitOutput || undefined),
                     });
                     break;
                 }
                 // --- Extract SHA from commit output ---
                 const shaMatch = /\[[\w/.-]+\s+([0-9a-f]+)\]/.exec(commitResult.stdout);
+                const gitOutput = (commitResult.stdout || commitResult.stderr).trim();
                 results.push({
                     index: i,
                     ok: true,
                     sha: shaMatch?.[1],
                     message: entry.message,
-                    files: entry.files,
+                    files: filePaths,
+                    ...spreadDefined("output", gitOutput || undefined),
                 });
             }
+            // --- In dry-run mode, unstage all files ---
+            if (args.dryRun && stagedFilesForCleanup.size > 0) {
+                const filesToReset = Array.from(stagedFilesForCleanup);
+                await spawnGitAsync(gitTop, ["reset", "HEAD", "--", ...filesToReset]);
+            }
             const allOk = results.length === args.commits.length && results.every((r) => r.ok);
-            // --- Optional push after all commits succeed ---
-            const push = allOk && args.push === "after" ? await runPushAfter(gitTop) : undefined;
+            // --- Optional push after all commits succeed (not in dry-run mode) ---
+            const push = !args.dryRun && allOk && args.push === "after" ? await runPushAfter(gitTop) : undefined;
             if (args.format === "json") {
                 return jsonRespond({
+                    ...spreadWhen(args.dryRun, { dryRun: true }),
                     ok: allOk,
                     committed: results.filter((r) => r.ok).length,
                     total: args.commits.length,
@@ -140,8 +344,11 @@ export function registerBatchCommitTool(server) {
                         ...spreadDefined("sha", r.sha),
                         message: r.message,
                         files: r.files,
+                        ...spreadDefined("staged", r.staged),
+                        ...spreadDefined("diffStat", r.diffStat),
                         ...spreadDefined("error", r.error),
                         ...spreadDefined("detail", r.detail),
+                        ...spreadDefined("output", r.output),
                     })),
                     ...spreadWhen(push !== undefined, {
                         push: {
@@ -150,15 +357,17 @@ export function registerBatchCommitTool(server) {
                             ...spreadDefined("upstream", push?.upstream),
                             ...spreadDefined("error", push?.error),
                             ...spreadDefined("detail", push?.detail),
+                            ...spreadDefined("output", push?.output),
                         },
                     }),
                 });
             }
             // --- Markdown ---
             const lines = [];
+            const dryRunPrefix = args.dryRun ? "DRY RUN — " : "";
             const header = allOk
-                ? `# Batch commit: ${results.length}/${args.commits.length} committed`
-                : `# Batch commit: ${results.filter((r) => r.ok).length}/${args.commits.length} committed (stopped on error)`;
+                ? `# Batch commit: ${dryRunPrefix}${results.length}/${args.commits.length} committed`
+                : `# Batch commit: ${dryRunPrefix}${results.filter((r) => r.ok).length}/${args.commits.length} committed (stopped on error)`;
             lines.push(header, "");
             for (const r of results) {
                 const icon = r.ok ? "✓" : "✗";
@@ -167,11 +376,24 @@ export function registerBatchCommitTool(server) {
                 if (!r.ok && r.detail) {
                     lines.push(`  Error: ${r.error} — ${r.detail}`);
                 }
+                if (args.dryRun && r.staged) {
+                    lines.push(`  Staged: ${r.staged.join(", ")}`);
+                }
+                if (args.dryRun && r.diffStat) {
+                    lines.push(`  Diff stat:`);
+                    lines.push(`  ${r.diffStat.replace(/\n/g, "\n  ")}`);
+                }
+                if (r.output) {
+                    lines.push(`  Output: ${r.output.replace(/\n/g, "\n  ")}`);
+                }
             }
             if (!allOk && results.length < args.commits.length) {
                 const skipped = args.commits.length - results.length;
                 lines.push("", `${skipped} remaining commit(s) skipped.`);
             }
+            if (args.dryRun) {
+                lines.push("", "**DRY RUN — no commits written. All staged files have been unstaged.**");
+            }
             if (push) {
                 lines.push("");
                 if (push.ok) {
@@ -180,6 +402,9 @@ export function registerBatchCommitTool(server) {
                 else {
                     lines.push(`Push: ✗ ${push.error}${push.detail ? ` — ${push.detail}` : ""}`);
                 }
+                if (push.output) {
+                    lines.push(`  Output: ${push.output.replace(/\n/g, "\n  ")}`);
+                }
             }
             return lines.join("\n");
         },

package/dist/server/coverage.js

@@ -0,0 +1,22 @@
+export function parseAllFilesLineCoverage(output) {
+    const rows = output
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.includes("|"));
+    const header = rows.find((line) => /^File\s*\|/i.test(line));
+    if (!header)
+        return null;
+    const columns = header.split("|").map((column) => column.trim().toLowerCase());
+    const lineIndex = columns.indexOf("% lines");
+    if (lineIndex === -1)
+        return null;
+    const allFiles = rows.find((line) => /^All files\s*\|/i.test(line));
+    if (!allFiles)
+        return null;
+    const cells = allFiles.split("|").map((cell) => cell.trim());
+    const raw = cells[lineIndex];
+    if (!raw)
+        return null;
+    const value = Number.parseFloat(raw);
+    return Number.isFinite(value) ? value : null;
+}

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

@@ -0,0 +1,132 @@
+import { z } from "zod";
+import { isSafeGitUpstreamToken, spawnGitAsync } from "./git.js";
+import { jsonRespond } from "./json.js";
+import { requireSingleRepo } from "./roots.js";
+import { WorkspacePickSchema } from "./schemas.js";
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/** Build the diff args array from parameters. */
+function buildDiffArgs(opts) {
+    const args = ["diff"];
+    // Handle staged flag first
+    if (opts.staged === true) {
+        args.push("--staged");
+    }
+    else if (opts.base || opts.head) {
+        // Range-based diff: base..head or base...head
+        // If only base is given, use base~0..HEAD (implicit HEAD)
+        const baseStr = opts.base?.trim() ?? "HEAD";
+        const headStr = opts.head?.trim() ?? "HEAD";
+        if (!isSafeGitUpstreamToken(baseStr) || !isSafeGitUpstreamToken(headStr)) {
+            return { ok: false, error: "unsafe_range_token" };
+        }
+        // Use two-dot range: base..head
+        args.push(`${baseStr}..${headStr}`);
+    }
+    // Scope to path if provided
+    if (opts.path?.trim()) {
+        args.push("--", opts.path.trim());
+    }
+    return { ok: true, args };
+}
+/** Human-readable label for the range. */
+function rangeLabel(opts) {
+    let label = "";
+    if (opts.staged === true) {
+        label = "staged changes";
+    }
+    else if (opts.base || opts.head) {
+        const baseStr = opts.base?.trim() ?? "HEAD";
+        const headStr = opts.head?.trim() ?? "HEAD";
+        label = `${baseStr}..${headStr}`;
+    }
+    else {
+        label = "unstaged changes";
+    }
+    if (opts.path?.trim()) {
+        label += ` (${opts.path.trim()})`;
+    }
+    return label;
+}
+// ---------------------------------------------------------------------------
+// Tool registration
+// ---------------------------------------------------------------------------
+export function registerGitDiffTool(server) {
+    server.addTool({
+        name: "git_diff",
+        description: "Get diff text for scoped file or range. Returns the raw diff output. " +
+            "Use `staged: true` for staged changes, `base`/`head` for revision ranges, " +
+            "and `path` to scope to a specific file.",
+        annotations: {
+            readOnlyHint: true,
+        },
+        parameters: WorkspacePickSchema.extend({
+            base: z
+                .string()
+                .optional()
+                .describe('Base ref (e.g. "main", "HEAD~3"). Required for range diffs. ' +
+                "If omitted and `staged: false`, shows unstaged changes."),
+            head: z
+                .string()
+                .optional()
+                .describe('Head ref (e.g. "feature-branch"). If omitted, defaults to HEAD. ' +
+                "Only used if `base` is provided."),
+            path: z
+                .string()
+                .optional()
+                .describe('Scope diff to a single file path (e.g. "src/main.ts").'),
+            staged: z
+                .boolean()
+                .optional()
+                .default(false)
+                .describe("If true, show staged changes (git diff --staged). " + "Ignored if `base` is provided."),
+        }),
+        execute: async (args) => {
+            const pre = requireSingleRepo(server, args);
+            if (!pre.ok)
+                return jsonRespond(pre.error);
+            const gitTop = pre.gitTop;
+            // Build git diff args
+            const diffArgsResult = buildDiffArgs({
+                base: args.base,
+                head: args.head,
+                path: args.path,
+                staged: args.staged,
+            });
+            if (!diffArgsResult.ok) {
+                return jsonRespond({ error: diffArgsResult.error });
+            }
+            // Run git diff
+            const result = await spawnGitAsync(gitTop, diffArgsResult.args);
+            if (!result.ok) {
+                return jsonRespond({
+                    error: "git_diff_failed",
+                    detail: (result.stderr || result.stdout).trim(),
+                });
+            }
+            const label = rangeLabel({
+                base: args.base,
+                head: args.head,
+                path: args.path,
+                staged: args.staged,
+            });
+            if (args.format === "json") {
+                return jsonRespond({
+                    range: label,
+                    diff: result.stdout,
+                });
+            }
+            // Markdown output
+            const lines = [];
+            lines.push(`# Diff: ${label}`, "");
+            if (result.stdout.trim()) {
+                lines.push("```diff", result.stdout.trimEnd(), "```");
+            }
+            else {
+                lines.push("_(no changes)_");
+            }
+            return lines.join("\n");
+        },
+    });
+}

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

@@ -0,0 +1,131 @@
+import { z } from "zod";
+import { spawnGitAsync } from "./git.js";
+import { jsonRespond } from "./json.js";
+import { requireSingleRepo } from "./roots.js";
+import { WorkspacePickSchema } from "./schemas.js";
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Parse `git fetch` output to extract updated and new refs.
+ * Lines containing "[new" indicate new refs (new branch, new tag, new ref).
+ * Lines with " -> " but not containing "[new" indicate updated refs.
+ */
+function parseGitFetchOutput(output) {
+    const lines = output.split("\n");
+    const updatedRefs = [];
+    const newRefs = [];
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        // Lines containing "[new" indicate new refs (e.g. "[new branch]", "[new tag]", "[new ref]")
+        if (trimmed.includes("[new")) {
+            newRefs.push(trimmed);
+        }
+        // Lines with " -> " that don't contain "[new" indicate ref updates
+        else if (trimmed.includes(" -> ")) {
+            updatedRefs.push(trimmed);
+        }
+    }
+    return { updatedRefs, newRefs };
+}
+// ---------------------------------------------------------------------------
+// Tool registration
+// ---------------------------------------------------------------------------
+export function registerGitFetchTool(server) {
+    server.addTool({
+        name: "git_fetch",
+        description: "Fetch updates from a remote repository without modifying the working tree. " +
+            "Returns structured output distinguishing updated refs from new refs.",
+        annotations: {
+            readOnlyHint: false, // Fetch modifies refs but not working tree; not strictly read-only but safe
+        },
+        parameters: WorkspacePickSchema.omit({ absoluteGitRoots: true, allWorkspaceRoots: true })
+            .pick({
+            workspaceRoot: true,
+            rootIndex: true,
+            format: true,
+        })
+            .extend({
+            remote: z
+                .string()
+                .optional()
+                .default("origin")
+                .describe("Remote to fetch from (default: origin)."),
+            branch: z
+                .string()
+                .optional()
+                .describe("If specified: fetch only this branch (e.g. 'main')."),
+            prune: z
+                .boolean()
+                .optional()
+                .default(false)
+                .describe("Pass --prune to remove deleted remote branches (default: false)."),
+            tags: z
+                .boolean()
+                .optional()
+                .default(false)
+                .describe("Pass --tags to also fetch all tags (default: false)."),
+        }),
+        execute: async (args) => {
+            const pre = requireSingleRepo(server, args);
+            if (!pre.ok) {
+                return jsonRespond(pre.error);
+            }
+            const gitTop = pre.gitTop;
+            const remote = (args.remote ?? "origin").trim();
+            const branch = args.branch?.trim();
+            const prune = args.prune === true;
+            const tags = args.tags === true;
+            // Build git fetch command
+            const fetchArgs = ["fetch"];
+            if (prune) {
+                fetchArgs.push("--prune");
+            }
+            if (tags) {
+                fetchArgs.push("--tags");
+            }
+            fetchArgs.push(remote);
+            if (branch) {
+                fetchArgs.push(branch);
+            }
+            const result = await spawnGitAsync(gitTop, fetchArgs);
+            const { updatedRefs, newRefs } = parseGitFetchOutput(result.stdout + result.stderr);
+            const fetchResult = {
+                ok: result.ok,
+                remote,
+                updatedRefs,
+                newRefs,
+                output: (result.stdout + result.stderr).trim(),
+            };
+            if (args.format === "json") {
+                return jsonRespond(fetchResult);
+            }
+            // Markdown output
+            const lines = [`# Git fetch from '${remote}'`];
+            if (!result.ok) {
+                lines.push("", "**Status**: Failed", "");
+                lines.push("```", result.stdout || result.stderr || "(no output)", "```");
+                return lines.join("\n");
+            }
+            lines.push("", "**Status**: Success", "");
+            if (updatedRefs.length > 0) {
+                lines.push("## Updated refs", "");
+                for (const ref of updatedRefs) {
+                    lines.push(`- ${ref}`);
+                }
+            }
+            if (newRefs.length > 0) {
+                lines.push("", "## New refs", "");
+                for (const ref of newRefs) {
+                    lines.push(`- ${ref}`);
+                }
+            }
+            if (updatedRefs.length === 0 && newRefs.length === 0 && result.stdout.trim()) {
+                lines.push("", "## Output", "", "```", result.stdout.trim(), "```");
+            }
+            return lines.join("\n");
+        },
+    });
+}