@rethunk/mcp-multi-root-git 2.9.1 → 4.0.0

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

@@ -0,0 +1,230 @@
+import { existsSync, readFileSync } from "node:fs";
+import { isAbsolute, join } from "node:path";
+import { z } from "zod";
+import { assertRelativePathUnderTop, resolvePathForRepo } from "../repo-paths.js";
+import { ERROR_CODES } from "./error-codes.js";
+import { spawnGitAsync } from "./git.js";
+import { conflictPaths } from "./git-refs.js";
+import { jsonRespond, spreadDefined, spreadWhen } from "./json.js";
+import { requireSingleRepo } from "./roots.js";
+import { WorkspacePickSchema } from "./schemas.js";
+// ---------------------------------------------------------------------------
+// Operation-state detection
+// ---------------------------------------------------------------------------
+/** Resolve the repo's git directory (handles worktrees, where it is not literally `<top>/.git`). */
+async function resolveGitDir(gitTop) {
+    const r = await spawnGitAsync(gitTop, ["rev-parse", "--git-dir"]);
+    if (!r.ok)
+        return null;
+    const raw = r.stdout.trim();
+    if (!raw)
+        return null;
+    return isAbsolute(raw) ? raw : join(gitTop, raw);
+}
+/** Detect the in-progress operation, if any, via marker files/dirs under the git dir. */
+export async function detectConflictState(gitTop) {
+    const gitDir = await resolveGitDir(gitTop);
+    if (!gitDir)
+        return undefined;
+    if (existsSync(join(gitDir, "MERGE_HEAD")))
+        return "merge";
+    if (existsSync(join(gitDir, "CHERRY_PICK_HEAD")))
+        return "cherry-pick";
+    if (existsSync(join(gitDir, "REVERT_HEAD")))
+        return "revert";
+    if (existsSync(join(gitDir, "rebase-merge")) || existsSync(join(gitDir, "rebase-apply"))) {
+        return "rebase";
+    }
+    return undefined;
+}
+// ---------------------------------------------------------------------------
+// Conflict marker parsing
+// ---------------------------------------------------------------------------
+const OURS_MARKER = "<<<<<<<";
+const BASE_MARKER = "|||||||";
+const SPLIT_MARKER = "=======";
+const THEIRS_MARKER = ">>>>>>>";
+function labelAfterMarker(line, marker) {
+    const rest = line.slice(marker.length).trim();
+    return rest.length > 0 ? rest : undefined;
+}
+/**
+ * Parse `<<<<<<<`/`|||||||`/`=======`/`>>>>>>>` conflict markers out of file text.
+ * Only the first `maxLinesPerFile` lines are scanned; when the file is longer,
+ * `truncated: true` is reported and any hunk still open at the cutoff is dropped
+ * rather than emitted half-formed. An incomplete hunk at EOF (corrupt/missing
+ * closing marker within the scan window) also sets `truncated: true`.
+ */
+export function parseConflictHunks(text, maxLinesPerFile) {
+    const allLines = text.split("\n");
+    const truncatedByCap = allLines.length > maxLinesPerFile;
+    const lines = truncatedByCap ? allLines.slice(0, maxLinesPerFile) : allLines;
+    const hunks = [];
+    let state = "outside";
+    let cur = null;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i] ?? "";
+        const lineNo = i + 1;
+        if (line.startsWith(OURS_MARKER)) {
+            cur = {
+                startLine: lineNo,
+                oursLines: [],
+                baseLines: [],
+                theirsLines: [],
+                oursLabel: labelAfterMarker(line, OURS_MARKER),
+            };
+            state = "ours";
+            continue;
+        }
+        if (state === "ours" && line.startsWith(BASE_MARKER)) {
+            state = "base";
+            continue;
+        }
+        if ((state === "ours" || state === "base") && line.startsWith(SPLIT_MARKER)) {
+            state = "theirs";
+            continue;
+        }
+        if (state === "theirs" && line.startsWith(THEIRS_MARKER) && cur) {
+            cur.theirsLabel = labelAfterMarker(line, THEIRS_MARKER);
+            hunks.push({
+                startLine: cur.startLine,
+                ours: cur.oursLines.join("\n"),
+                theirs: cur.theirsLines.join("\n"),
+                ...spreadWhen(cur.baseLines.length > 0, { base: cur.baseLines.join("\n") }),
+                ...spreadDefined("oursLabel", cur.oursLabel),
+                ...spreadDefined("theirsLabel", cur.theirsLabel),
+            });
+            cur = null;
+            state = "outside";
+            continue;
+        }
+        if (!cur)
+            continue;
+        if (state === "ours")
+            cur.oursLines.push(line);
+        else if (state === "base")
+            cur.baseLines.push(line);
+        else if (state === "theirs")
+            cur.theirsLines.push(line);
+    }
+    // Incomplete open hunk at EOF (or at the line-cap) → flag truncated so callers
+    // know markers were present but not fully parsed.
+    const truncated = truncatedByCap || cur !== null;
+    return { hunks, truncated };
+}
+/** Conservative binary sniff: a NUL byte in the first 8000 bytes. */
+function isLikelyBinary(buf) {
+    const len = Math.min(buf.length, 8000);
+    for (let i = 0; i < len; i++) {
+        if (buf[i] === 0)
+            return true;
+    }
+    return false;
+}
+// ---------------------------------------------------------------------------
+// Per-file resolution
+// ---------------------------------------------------------------------------
+export function readConflictFile(gitTop, relPath, maxLinesPerFile) {
+    const resolved = resolvePathForRepo(relPath, gitTop);
+    if (!assertRelativePathUnderTop(relPath, resolved, gitTop)) {
+        return { path: relPath, error: ERROR_CODES.PATH_ESCAPES_REPO };
+    }
+    let buf;
+    try {
+        buf = readFileSync(resolved);
+    }
+    catch {
+        return { path: relPath };
+    }
+    if (isLikelyBinary(buf)) {
+        return { path: relPath };
+    }
+    const { hunks, truncated } = parseConflictHunks(buf.toString("utf8"), maxLinesPerFile);
+    return {
+        path: relPath,
+        ...spreadWhen(hunks.length > 0, { hunks }),
+        ...spreadWhen(truncated, { truncated: true }),
+    };
+}
+// ---------------------------------------------------------------------------
+// Markdown rendering
+// ---------------------------------------------------------------------------
+function renderConflictsMarkdown(result) {
+    const lines = ["# Git conflicts"];
+    if (result.state)
+        lines.push(`_state: ${result.state}_`);
+    lines.push("");
+    if (result.files.length === 0) {
+        lines.push("_(no conflicts)_");
+        return lines.join("\n");
+    }
+    for (const f of result.files) {
+        lines.push(`## ${f.path}`);
+        if (f.error)
+            lines.push(`_error: ${f.error}_`);
+        if (f.truncated)
+            lines.push("_(truncated)_");
+        if (!f.hunks || f.hunks.length === 0) {
+            lines.push("_(no parsed hunks — unreadable, binary, or no markers found)_", "");
+            continue;
+        }
+        for (const h of f.hunks) {
+            lines.push(`### hunk @ line ${h.startLine}`);
+            lines.push(`**ours${h.oursLabel ? ` (${h.oursLabel})` : ""}:**`, "```", h.ours, "```");
+            if (h.base !== undefined) {
+                lines.push("**base:**", "```", h.base, "```");
+            }
+            lines.push(`**theirs${h.theirsLabel ? ` (${h.theirsLabel})` : ""}:**`, "```", h.theirs, "```");
+        }
+        lines.push("");
+    }
+    return lines.join("\n").trimEnd();
+}
+// ---------------------------------------------------------------------------
+// Tool registration
+// ---------------------------------------------------------------------------
+export function registerGitConflictsTool(server) {
+    server.addTool({
+        name: "git_conflicts",
+        description: "Inspect unresolved merge conflicts after git_merge/git_cherry_pick reports them. " +
+            "Reports the in-progress operation (merge/cherry-pick/revert/rebase, when detectable) and, " +
+            "per conflicted file, the parsed ours/theirs (and base, for diff3-style markers) hunks.",
+        annotations: {
+            readOnlyHint: true,
+        },
+        parameters: WorkspacePickSchema.extend({
+            withHunks: z
+                .boolean()
+                .optional()
+                .default(true)
+                .describe("Parse conflict-marker hunks per file. Set false for just the path list."),
+            maxLinesPerFile: z
+                .number()
+                .int()
+                .min(1)
+                .max(2000)
+                .optional()
+                .default(200)
+                .describe("Cap on lines scanned per file before marking `truncated: true`."),
+        }),
+        execute: async (args) => {
+            const pre = requireSingleRepo(server, args);
+            if (!pre.ok)
+                return jsonRespond(pre.error);
+            const gitTop = pre.gitTop;
+            const state = await detectConflictState(gitTop);
+            const paths = await conflictPaths(gitTop);
+            const withHunks = args.withHunks !== false;
+            const maxLinesPerFile = typeof args.maxLinesPerFile === "number" ? args.maxLinesPerFile : 200;
+            const files = paths.map((p) => withHunks ? readConflictFile(gitTop, p, maxLinesPerFile) : { path: p });
+            const result = {
+                ...spreadDefined("state", state),
+                files,
+            };
+            if (args.format === "json") {
+                return jsonRespond(result);
+            }
+            return renderConflictsMarkdown(result);
+        },
+    });
+}

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

@@ -1,7 +1,8 @@
 import { matchesGlob } from "node:path";
 import { z } from "zod";
 import { ERROR_CODES } from "./error-codes.js";
-import { isSafeGitUpstreamToken, spawnGitAsync } from "./git.js";
+import { spawnGitAsync } from "./git.js";
+import { isSafeGitRangeToken } from "./git-refs.js";
 import { jsonRespond, spreadDefined, spreadWhen } from "./json.js";
 import { requireSingleRepo } from "./roots.js";
 import { WorkspacePickSchema } from "./schemas.js";
@@ -27,18 +28,26 @@ const DEFAULT_EXCLUDE_PATTERNS = [
 /**
  * Parse `git diff --numstat` output into exact per-file counts.
  * Format per line: "<additions>\t<deletions>\t<path>"
+ * Renames emit "<additions>\t<deletions>\told => new" — keyed by the new path
+ * so lookups from extractFileInfo (which uses the destination path) succeed.
  * Binary files emit "-\t-\t<path>" and are recorded as 0/0.
  */
-function parseNumstatOutput(numstat) {
+export function parseNumstatOutput(numstat) {
     const result = new Map();
     for (const line of numstat.split("\n")) {
         const parts = line.split("\t");
         if (parts.length < 3)
             continue;
         const [addStr, delStr, ...pathParts] = parts;
-        const filePath = pathParts.join("\t");
+        let filePath = pathParts.join("\t");
         if (!filePath)
             continue;
+        // Rename numstat: "old/path => new/path" — index under the new path.
+        const renameSep = " => ";
+        const renameIdx = filePath.indexOf(renameSep);
+        if (renameIdx >= 0) {
+            filePath = filePath.slice(renameIdx + renameSep.length);
+        }
         const additions = addStr === "-" ? 0 : Number.parseInt(addStr ?? "0", 10);
         const deletions = delStr === "-" ? 0 : Number.parseInt(delStr ?? "0", 10);
         if (!Number.isNaN(additions) && !Number.isNaN(deletions)) {
@@ -51,7 +60,7 @@ function parseNumstatOutput(numstat) {
  * Parse `git diff` output into per-file chunks.
  * Splits on "diff --git a/..." lines.
  */
-function parseDiffOutput(diff) {
+export function parseDiffOutput(diff) {
     const chunks = [];
     // Each file section starts with "diff --git"
     const parts = diff.split(/(?=^diff --git )/m);
@@ -70,7 +79,7 @@ function parseDiffOutput(diff) {
  * Header: "diff --git a/old b/new"
  * Body may contain "rename from", "rename to", "new file mode", "deleted file mode".
  */
-function extractFileInfo(header, body) {
+export function extractFileInfo(header, body) {
     // Parse "diff --git a/X b/Y". For non-renames X === Y; use midpoint split so
     // paths containing " b/" (e.g. "src/b/file.ts") are not mis-parsed by a greedy regex.
     const prefix = "diff --git a/";
@@ -114,10 +123,11 @@ function extractFileInfo(header, body) {
     return { path, oldPath, status };
 }
 /**
- * Truncate diff body to at most `maxLines` lines (counting only hunk content lines).
+ * Truncate diff body to at most `maxLines` lines of the raw body text
+ * (includes index/---/+++/@@ headers — coarser than hunk-content-only counting).
  * Returns { text, truncated }.
  */
-function truncateDiffBody(body, maxLines) {
+export function truncateDiffBody(body, maxLines) {
     const lines = body.split("\n");
     if (lines.length <= maxLines) {
         return { text: body, truncated: false };
@@ -125,7 +135,7 @@ function truncateDiffBody(body, maxLines) {
     return { text: lines.slice(0, maxLines).join("\n"), truncated: true };
 }
 /** Check whether a file path matches any of the given glob patterns. */
-function matchesAnyPattern(filePath, patterns) {
+export function matchesAnyPattern(filePath, patterns) {
     const normalized = filePath.replace(/\\/g, "/");
     for (const pattern of patterns) {
         if (matchesGlob(normalized, pattern))
@@ -138,7 +148,7 @@ function matchesAnyPattern(filePath, patterns) {
     return false;
 }
 /** Build the diff args array from the `range` parameter. */
-function buildDiffArgs(range) {
+export function buildDiffArgs(range) {
     if (range === undefined || range === "") {
         return { ok: true, args: [] };
     }
@@ -149,21 +159,13 @@ function buildDiffArgs(range) {
     if (normalized === "head") {
         return { ok: true, args: ["HEAD"] };
     }
-    // Range like "A..B", "A...B", or a single ref
-    // Split on ".." or "..." separators to validate each token
-    const separatorMatch = /^(.+?)(\.{2,3})(.+)$/.exec(range.trim());
-    if (separatorMatch) {
-        const [, left, sep, right] = separatorMatch;
-        if (!isSafeGitUpstreamToken(left ?? "") || !isSafeGitUpstreamToken(right ?? "")) {
-            return { ok: false, error: `unsafe_range_token: ${range}` };
-        }
-        return { ok: true, args: [`${left}${sep}${right}`] };
-    }
-    // Single ref
-    if (!isSafeGitUpstreamToken(range.trim())) {
-        return { ok: false, error: `unsafe_range_token: ${range}` };
+    // "A..B", "A...B", or a single ref (ancestor notation like "HEAD~3" accepted
+    // on any endpoint) — delegates to the shared range validator.
+    const trimmed = range.trim();
+    if (!isSafeGitRangeToken(trimmed)) {
+        return { ok: false, error: ERROR_CODES.UNSAFE_RANGE_TOKEN };
     }
-    return { ok: true, args: [range.trim()] };
+    return { ok: true, args: [trimmed] };
 }
 /** Human-readable label for the range. */
 function rangeLabel(range, diffArgs) {
@@ -184,7 +186,7 @@ export function registerGitDiffSummaryTool(server) {
         annotations: {
             readOnlyHint: true,
         },
-        parameters: WorkspacePickSchema.omit({ allWorkspaceRoots: true }).extend({
+        parameters: WorkspacePickSchema.extend({
             range: z
                 .string()
                 .optional()
@@ -245,8 +247,9 @@ export function registerGitDiffSummaryTool(server) {
             }
             // --- Parse diff chunks ---
             const chunks = parseDiffOutput(diffResult.stdout);
-            const totalFiles = chunks.length;
             // --- Apply excludePatterns and fileFilter ---
+            // totalFiles / totals count the post-filter set (before maxFiles truncation)
+            // so they stay consistent with each other; truncatedFiles covers display caps.
             const excludePatterns = args.excludePatterns !== undefined ? args.excludePatterns : DEFAULT_EXCLUDE_PATTERNS;
             const excludedFiles = [];
             const includedChunks = [];
@@ -257,24 +260,32 @@ export function registerGitDiffSummaryTool(server) {
                     continue;
                 }
                 if (args.fileFilter && !matchesAnyPattern(filePath, [args.fileFilter])) {
+                    excludedFiles.push(filePath);
                     continue;
                 }
                 includedChunks.push(chunk);
             }
+            const totalFiles = includedChunks.length;
             // --- Truncate to maxFiles ---
             const maxFiles = args.maxFiles ?? 30;
             const maxLinesPerFile = args.maxLinesPerFile ?? 50;
             const truncatedFileCount = includedChunks.length > maxFiles ? includedChunks.length - maxFiles : 0;
             const processedChunks = includedChunks.slice(0, maxFiles);
             // --- Build FileDiff entries ---
+            // Sum stats over the full filtered set (includedChunks), not only the
+            // maxFiles-truncated display slice, so totals match totalFiles.
             let totalAdditions = 0;
             let totalDeletions = 0;
+            for (const chunk of includedChunks) {
+                const { path: filePath } = extractFileInfo(chunk.header, chunk.body);
+                const stat = statMap.get(filePath) ?? { additions: 0, deletions: 0 };
+                totalAdditions += stat.additions;
+                totalDeletions += stat.deletions;
+            }
             const files = [];
             for (const chunk of processedChunks) {
                 const { path: filePath, oldPath, status } = extractFileInfo(chunk.header, chunk.body);
                 const stat = statMap.get(filePath) ?? { additions: 0, deletions: 0 };
-                totalAdditions += stat.additions;
-                totalDeletions += stat.deletions;
                 const { text: diffText, truncated } = truncateDiffBody(chunk.body, maxLinesPerFile);
                 files.push({
                     path: filePath,
@@ -282,7 +293,7 @@ export function registerGitDiffSummaryTool(server) {
                     additions: stat.additions,
                     deletions: stat.deletions,
                     ...spreadDefined("oldPath", oldPath),
-                    truncated,
+                    ...spreadWhen(truncated, { truncated: true }),
                     diff: diffText,
                 });
             }

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

@@ -1,31 +1,36 @@
 import { z } from "zod";
 import { assertRelativePathUnderTop, resolvePathForRepo } from "../repo-paths.js";
 import { ERROR_CODES } from "./error-codes.js";
-import { isSafeGitUpstreamToken, spawnGitAsync } from "./git.js";
-import { jsonRespond } from "./json.js";
+import { spawnGitAsync } from "./git.js";
+import { isSafeGitCommitIsh } from "./git-refs.js";
+import { jsonRespond, spreadWhen } from "./json.js";
 import { requireSingleRepo } from "./roots.js";
 import { WorkspacePickSchema } from "./schemas.js";
 // ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+/** Default byte cap on raw diff stdout to keep agent context bounded. */
+export const GIT_DIFF_DEFAULT_MAX_BYTES = 512_000;
+// ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
 /** Build the diff args array from parameters. */
-function buildDiffArgs(opts) {
+export 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)) {
+    // Docs: `staged` is ignored when `base` is provided; `head` is used only
+    // when `base` is set. Prefer base..head over --staged whenever base is set.
+    if (opts.base) {
+        const baseStr = opts.base.trim();
+        const headStr = opts.head?.trim() || "HEAD";
+        if (!isSafeGitCommitIsh(baseStr) || !isSafeGitCommitIsh(headStr)) {
             return { ok: false, error: ERROR_CODES.UNSAFE_RANGE_TOKEN };
         }
-        // Use two-dot range: base..head
         args.push(`${baseStr}..${headStr}`);
     }
+    else if (opts.staged === true) {
+        args.push("--staged");
+    }
+    // head without base is ignored (matches docs: head used only when base is set)
     // Apply unified context width if specified
     if (typeof opts.unified === "number") {
         args.push(`-U${opts.unified}`);
@@ -37,16 +42,16 @@ function buildDiffArgs(opts) {
     return { ok: true, args };
 }
 /** Human-readable label for the range. */
-function rangeLabel(opts) {
+export 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";
+    if (opts.base) {
+        const baseStr = opts.base.trim();
+        const headStr = opts.head?.trim() || "HEAD";
         label = `${baseStr}..${headStr}`;
     }
+    else if (opts.staged === true) {
+        label = "staged changes";
+    }
     else {
         label = "unstaged changes";
     }
@@ -55,6 +60,14 @@ function rangeLabel(opts) {
     }
     return label;
 }
+/** Cap diff text at maxBytes; UTF-8 safe via Buffer slice. */
+export function truncateDiffOutput(diff, maxBytes) {
+    const buf = Buffer.from(diff, "utf8");
+    if (buf.length <= maxBytes) {
+        return { text: diff, truncated: false };
+    }
+    return { text: buf.subarray(0, maxBytes).toString("utf8"), truncated: true };
+}
 // ---------------------------------------------------------------------------
 // Tool registration
 // ---------------------------------------------------------------------------
@@ -62,22 +75,20 @@ export function registerGitDiffTool(server) {
     server.addTool({
         name: "git_diff",
         description: "Raw diff text for scoped file(s) or range. `staged: true` for staged changes, " +
-            "`base`/`head` for revision ranges, `path`/`paths` to scope, `unified` for context lines.",
+            "`base`/`head` for revision ranges, `path`/`paths` to scope, `unified` for context lines. " +
+            "Output is capped by `maxBytes` (default 512000) to bound agent context.",
         annotations: {
             readOnlyHint: true,
         },
-        parameters: WorkspacePickSchema.omit({
-            absoluteGitRoots: true,
-            allWorkspaceRoots: true,
-        }).extend({
+        parameters: WorkspacePickSchema.extend({
             base: z
                 .string()
                 .optional()
-                .describe('Base ref (e.g. "main", "HEAD~3"). Omit for unstaged changes.'),
+                .describe('Base ref (e.g. "main"). Ancestor notation is accepted (e.g. "HEAD~3", "main^2"). Omit for unstaged changes.'),
             head: z
                 .string()
                 .optional()
-                .describe('Head ref (e.g. "feature-branch"). Defaults to HEAD. Used only when `base` is set.'),
+                .describe('Head ref (e.g. "feature-branch"). Ancestor notation is accepted (e.g. "HEAD~3", "main^2"). Defaults to HEAD. Used only when `base` is set.'),
             path: z
                 .string()
                 .optional()
@@ -98,6 +109,14 @@ export function registerGitDiffTool(server) {
                 .max(100)
                 .optional()
                 .describe("Context lines around each change (`-U<n>`). Default: 3. Use 0 for no context."),
+            maxBytes: z
+                .number()
+                .int()
+                .min(1024)
+                .max(10_000_000)
+                .optional()
+                .default(GIT_DIFF_DEFAULT_MAX_BYTES)
+                .describe(`Max UTF-8 bytes of diff text to return (default ${GIT_DIFF_DEFAULT_MAX_BYTES}). Oversized output is truncated with truncated:true.`),
         }),
         execute: async (args) => {
             const pre = requireSingleRepo(server, args);
@@ -144,6 +163,8 @@ export function registerGitDiffTool(server) {
                     detail: (result.stderr || result.stdout).trim(),
                 });
             }
+            const maxBytes = typeof args.maxBytes === "number" ? args.maxBytes : GIT_DIFF_DEFAULT_MAX_BYTES;
+            const { text: diffText, truncated } = truncateDiffOutput(result.stdout, maxBytes);
             const label = rangeLabel({
                 base: args.base,
                 head: args.head,
@@ -153,18 +174,22 @@ export function registerGitDiffTool(server) {
             if (args.format === "json") {
                 return jsonRespond({
                     range: label,
-                    diff: result.stdout,
+                    diff: diffText,
+                    ...spreadWhen(truncated, { truncated: true }),
                 });
             }
             // Markdown output
             const lines = [];
             lines.push(`# Diff: ${label}`, "");
-            if (result.stdout.trim()) {
-                lines.push("```diff", result.stdout.trimEnd(), "```");
+            if (diffText.trim()) {
+                lines.push("```diff", diffText.trimEnd(), "```");
             }
             else {
                 lines.push("_(no changes)_");
             }
+            if (truncated) {
+                lines.push("", `_(diff truncated at ${maxBytes} bytes)_`);
+            }
             return lines.join("\n");
         },
     });