pi-hashline-edit-pro 2.7.1 → 2.8.0

package/src/hashline/parse.ts

@@ -1,9 +1,12 @@
 import {
 	ANCHOR_LEN,
 	ALPH_RE,
+	HASH_CLASS,
 } from "./hash";
 import { NEW_CONTENT_NOT_ARRAY_MSG } from "../constants";
 
+const HASH_EXTRACT_RE = new RegExp(HASH_CLASS);
+
 export type Anchor = { hash: string };
 
 function diagRef(ref: string): string {
@@ -14,11 +17,22 @@ function diagRef(ref: string): string {
 	}
 
 	if (/^\d+/.test(trimmed)) {
-		return `[E_BAD_REF] Invalid anchor. Use the hash alone (e.g. "aB3"): no line numbers or trailing content.`;
+		return `[E_BAD_REF] Invalid anchor. Use the anchor alone (e.g. "aB3"): no line numbers or trailing content.`;
+	}
+	if (trimmed.includes("│") && trimmed.includes("\n")) {
+		const lines = trimmed.split(/\r?\n/);
+		const first = lines[0] ?? "";
+		const last = lines[lines.length - 1] ?? "";
+		const hashRe = HASH_EXTRACT_RE;
+		const firstMatch = first.match(hashRe);
+		const lastMatch = last.match(hashRe);
+		const firstHash = firstMatch?.[0] ?? "aB3";
+		const lastHash = lastMatch?.[0] ?? "aB3";
+		const preview = first.slice(0, 60);
+		return `[E_BAD_REF] Invalid anchor — remove_from and remove_to must each be a single bare 3-char hash (e.g. "aB3"), not a block with HASH│content. Received ${lines.length} lines starting "${preview}…" — use only the first hash "${firstHash}" as remove_from and "${lastHash}" as remove_to, and put the new content (without HASH│) in replacement_lines.`;
 	}
-
 	if (trimmed.includes("│")) {
-		return `[E_BAD_REF] Invalid anchor "${trimmed}": use only the 3-char hash, drop everything from "│" onward.`;
+		return `[E_BAD_REF] Invalid anchor "${trimmed}": use only the 3-char anchor, drop everything from "│" onward.`;
 	}
 
 	return `[E_BAD_REF] Invalid anchor "${trimmed}". Expected a 3-char alphanumeric anchor (e.g. "aB3").`;

package/src/hashline/resolve.ts

@@ -1,4 +1,4 @@
-import { abortIf, rejectUnknownFields, firstNonEmptyIndex, lastNonEmptyIndex, clipLine } from "../utils";
+import { abortIf, rejectUnknownFields, firstNonEmptyIndex, lastNonEmptyIndex, clipLine, getCached } from "../utils";
 import { HASH_SEP, HASH_RUN, stripRowPrefix, canon } from "./hash";
 import { parseHashRef, parseText, type Anchor } from "./parse";
 import { NEW_CONTENT_NOT_ARRAY_MSG, MAX_RANGE_STALE_LINES } from "../constants";
@@ -152,12 +152,12 @@ function assertItem(edit: Record<string, unknown>): void {
 
   if ("remove_from" in edit && typeof edit.remove_from !== "string") {
     throw new Error(
-      `[E_BAD_SHAPE] Field "remove_from" must be an anchor string (3-char hash).`,
+      `[E_BAD_SHAPE] Field "remove_from" must be an anchor string (3-char anchor).`,
     );
   }
   if ("remove_to" in edit && typeof edit.remove_to !== "string") {
     throw new Error(
-      `[E_BAD_SHAPE] Field "remove_to" must be an anchor string (3-char hash).`,
+      `[E_BAD_SHAPE] Field "remove_to" must be an anchor string (3-char anchor).`,
     );
   }
   if (!("replacement_lines" in edit)) {
@@ -168,7 +168,7 @@ function assertItem(edit: Record<string, unknown>): void {
   }
   if (typeof edit.remove_from !== "string" || typeof edit.remove_to !== "string") {
     throw new Error(
-      `[E_BAD_SHAPE] The edit requires "remove_from" and "remove_to" anchor strings (3-char hashes from read output).`,
+      `[E_BAD_SHAPE] The edit requires "remove_from" and "remove_to" anchor strings (3-char anchors from read output).`,
     );
   }
 }
@@ -187,7 +187,7 @@ export function stripAnchorRow(
 			? "diff-preview marker"
 			: match[1] === "-"
 				? 'leading "-" marker'
-				: '"HASH│" prefix';
+				: '"anchor│" prefix';
 	warnings?.push(`[E_BAD_REF] Stripped ${marker} from ${entryLabel} "${trimmed}".`);
 	return match[2]!;
 }
@@ -239,7 +239,7 @@ export function stripBarePrefixes(
 			? " Verify it was pasted from read output."
 			: "";
 	warnings.push(
-		`[E_BARE_HASH_PREFIX] Stripped "HASH│" prefix from ${locations}.${guidance}`
+		`[E_BARE_HASH_PREFIX] Stripped "anchor│" prefix from ${locations}.${guidance}`
 	);
 	return { ...edit, content_lines: contentLines };
 }
@@ -462,7 +462,8 @@ export function valEdit(
 	}
 	const endLine = endResolved.line;
 	const rangeLines = fileLines.slice(startResolved.line - 1, endLine);
-	const canonLines = fileLines.map((line) => canon(line));
+	const canonCache = new Map<string, string>();
+	const canonLines = fileLines.map((line) => getCached(canonCache, line, canon));
 	boundaryDups.push(
 		...trailingDups(edit.content_lines, fileLines, endLine),
 		...leadingDups(edit.content_lines, fileLines, startResolved.line),
@@ -546,7 +547,7 @@ export function assertRangeServed(
   for (let line = startLine; line < startLine + shownLength; line++) {
     const hash = fileHashes[line - 1]!;
     shownHashes.push(hash);
-    rows.push(fmtRow(hash, fileLines[line - 1]));
+    rows.push(fmtRow(hash, clipLine(fileLines[line - 1])));
   }
   const location = filePath ? ` in ${filePath}` : "";
   const first = mismatchLines[0]!;

package/src/insert.ts

@@ -2,16 +2,14 @@ import type { ExtensionAPI, ToolDefinition } from "@earendil-works/pi-coding-age
 import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { constants } from "fs";
-import { execPipeline, type ReqParams, type ReplaceDetails } from "./replace";
+import { execPipeline, type ReqParams, type ReplaceDetails, previewFromPipe, previewError } from "./replace";
 import { commitEdit } from "./commit";
 import { readNormFile, type NormFile } from "./file-reader";
-import { resolveTarget } from "./fs-write";
+import { resolveInCwd } from "./fs-write";
 import { MAX_HASH_LINES, parseHashRef, resolveAnchorLine, type Anchor } from "./hashline";
 import { stripAnchorRow } from "./hashline/resolve";
-import { toCwd } from "./paths";
 import { loadP, loadGuide } from "./prompts";
-import { normReq } from "./replace-normalize";
-import { genDiff } from "./replace-diff";
+import { normReq } from "./payload-contract";
 import { makeRenderCall, renderEditResult, type RPreview, type RRState } from "./replace-render";
 import { abortIf, isRec, makePrepareArguments, rejectUnknownFields, splitLines } from "./utils";
 import { clearBoundaryBypass } from "./boundary-bypass";
@@ -34,7 +32,7 @@ export function assertInsertReq(request: unknown): asserts request is InsertReq
     throw new Error('[E_BAD_SHAPE] Insert request requires a non-empty "path" string.');
   }
   if (typeof request.anchor !== "string" || request.anchor.length === 0) {
-    throw new Error('[E_BAD_SHAPE] Insert request requires an "anchor" string (3-char hash from read output).');
+    throw new Error('[E_BAD_SHAPE] Insert request requires an "anchor" string (3-char anchor from read output).');
   }
   if (request.direction !== "before" && request.direction !== "after") {
     throw new Error('[E_BAD_SHAPE] Insert request "direction" must be "before" or "after".');
@@ -52,7 +50,7 @@ const insertToolSchema = Type.Object(
     }),
     anchor: Type.String({
       description:
-        'Bare 3-char HASH only (e.g. "aB3"): copy just the hash from the leftmost column of a read row like `aB3│content`; never the line content. A pasted diff row like `+aB3│x` or a `HASH│` prefix is stripped automatically with a warning. The anchored line is preserved; the new lines go after or before it.',
+        'Bare 3-char anchor only (e.g. "aB3"): copy just the anchor from the leftmost column of a read row like `aB3│content`; never the line content. A pasted diff row like `+aB3│x` or an `anchor│` prefix is stripped automatically with a warning. The anchored line is preserved; the new lines go after or before it.',
     }),
     direction: Type.Union(
       [
@@ -121,12 +119,9 @@ export async function insertPreview(request: unknown, cwd: string): Promise<RPre
       preloadedNorm: preload,
       skipBoundaryDedup: true,
     });
-    if (pipe.originalNormalized === pipe.result) {
-      return { error: `No changes made to ${normalized.path}. The edit produced identical content.` };
-    }
-    return { diff: genDiff(pipe.originalNormalized, pipe.result, 4, pipe.resultHashes, pipe.originalHashes).diff };
+    return previewFromPipe(pipe);
   } catch (error: unknown) {
-    return { error: error instanceof Error ? error.message : String(error) };
+    return previewError(error);
   }
 }
 
@@ -164,16 +159,17 @@ export function buildInsertToolDef(): InsertToolDef {
     promptSnippet: loadP("../prompts/insert-snippet.md"),
     promptGuidelines: loadGuide("../prompts/insert-guidelines.md"),
     prepareArguments: makePrepareArguments(),
+    executionMode: "sequential",
     parameters: insertToolSchema,
     renderShell: "default",
     renderCall: makeRenderCall(insertPreview, { getInput: getInsertInput, toolName: "insert" }),
-    renderResult(result, { isPartial }, theme, context) {
+    renderResult(result, { isPartial, expanded }, theme, context) {
       return renderEditResult(
         result as {
           content?: Array<{ type: string; text?: string }>;
           details?: ReplaceDetails;
         },
-        isPartial,
+        { isPartial, expanded },
         theme,
         context,
       );
@@ -185,8 +181,7 @@ export function buildInsertToolDef(): InsertToolDef {
       const req = canonical;
       const path = req.path;
       const { ref, warnings: anchorWarnings } = parseInsertAnchor(req.anchor);
-      const absolutePath = toCwd(path, ctx.cwd);
-      const mutationTargetPath = await resolveTarget(absolutePath);
+      const { absolute: absolutePath, resolved: mutationTargetPath } = await resolveInCwd(path, ctx.cwd);
       return withFileMutationQueue(mutationTargetPath, async () => {
         abortIf(signal);
         const preload = await readNormFile(path, ctx.cwd, {

package/src/payload-contract.ts

@@ -0,0 +1,102 @@
+import { Type } from "typebox";
+import { isRec, normalizeFilePath, rejectUnknownFields } from "./utils";
+
+const replacementLinesSchema = Type.Array(
+  Type.String({
+    description:
+      "One replacement line. Each element is exactly one line; do not embed \\n inside an element: use separate elements.",
+  }),
+  {
+    description:
+      "Replacement lines as an array of strings, one element per line. Use [] to delete the range.",
+  },
+);
+
+const removeFromSchema = Type.String({
+  description:
+    "Bare 3-char anchor only (e.g. \"aB3\"): copy just the anchor from the leftmost column of a read row like `aB3│content`; never the line content. Marks the FIRST line to remove (inclusive)",
+});
+
+const removeToSchema = Type.String({
+  description:
+    "Bare 3-char anchor only (e.g. \"aB3\"): copy just the anchor from the leftmost column of a read row like `aB3│content`; never the line content. Marks the LAST line to remove (inclusive)",
+});
+
+export const editToolSchema = Type.Object(
+  {
+    path: Type.Optional(
+      Type.String({
+        description:
+          "Path to edit. Required: always provide it explicitly; it is only auto-resolved from the anchors as a fallback when omitted by mistake.",
+      }),
+    ),
+    remove_from: removeFromSchema,
+    remove_to: removeToSchema,
+    replacement_lines: replacementLinesSchema,
+  },
+  { additionalProperties: false },
+);
+
+export type ReqParams = {
+  path: string;
+  remove_from: string;
+  remove_to: string;
+  replacement_lines: string[];
+};
+
+const ROOT_KS = new Set(["path", "remove_from", "remove_to", "replacement_lines"]);
+
+export function assertReq(request: unknown): asserts request is ReqParams {
+  if (!isRec(request)) {
+    throw new Error("[E_BAD_SHAPE] Edit request must be an object.");
+  }
+  rejectUnknownFields(request, ROOT_KS, "Edit request");
+  if (typeof request.path !== "string" || request.path.length === 0) {
+    throw new Error('[E_BAD_SHAPE] Edit request requires a non-empty "path" string.');
+  }
+  if (
+    typeof request.remove_from !== "string" ||
+    typeof request.remove_to !== "string" ||
+    !Array.isArray(request.replacement_lines) ||
+    request.replacement_lines.some((line) => typeof line !== "string")
+  ) {
+    throw new Error(
+      '[E_BAD_SHAPE] Edit request requires "remove_from", "remove_to", and "replacement_lines" (array of strings, one per line; use [] to delete).',
+    );
+  }
+}
+
+export function normReq(input: unknown): unknown {
+  if (!isRec(input)) {
+    return input;
+  }
+  const record: Record<string, unknown> = { ...input };
+  normalizeFilePath(record);
+  return record;
+}
+
+export function getPreviewInput(args: unknown): ReqParams | null {
+  let normalized: unknown;
+  try {
+    normalized = normReq(args);
+  } catch {
+    return null;
+  }
+  if (!isRec(normalized) || typeof normalized.path !== "string") {
+    return null;
+  }
+  if (
+    typeof normalized.remove_from !== "string" ||
+    typeof normalized.remove_to !== "string" ||
+    !Array.isArray(normalized.replacement_lines) ||
+    normalized.replacement_lines.some((line) => typeof line !== "string")
+  ) {
+    return null;
+  }
+  return {
+    path: normalized.path,
+    remove_from: normalized.remove_from,
+    remove_to: normalized.remove_to,
+    replacement_lines: normalized.replacement_lines,
+  };
+}

package/src/read.ts

@@ -3,19 +3,21 @@ import {
 	createReadTool,
 	formatSize,
 	truncateHead,
+	DEFAULT_MAX_BYTES,
 	DEFAULT_MAX_LINES,
 	type TruncationResult,
 } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
-import { MAX_READ_LINE_BYTES } from "./constants";
 import { loadFileKindAndText } from "./file-kind";
+import { MAX_OVERSIZED_WARNING_LINES } from "./constants";
 import { readNormFile, safeSnapId } from "./file-reader";
-import { lineHashes, fmtRegion, HASH_SEP, MAX_HASH_LINES } from "./hashline";
+import { lineHashes, fmtRegion, fmtRow, HASH_SEP, MAX_HASH_LINES } from "./hashline";
 import { toCwd } from "./paths";
-import { abortIf, makePrepareArguments, visLines } from "./utils";
+import { abortIf, makePrepareArguments, numberedRead, visLines } from "./utils";
 import { recordServedSafe } from "./served";
 import { loadP, loadGuide } from "./prompts";
 import { valAccess } from "./validation";
+import { Text } from "@earendil-works/pi-tui";
 
 const R_DESC = loadP("../prompts/read.md");
 
@@ -56,7 +58,7 @@ export async function fmtReadPreview(
 	options: { offset?: number; limit?: number },
 	precomputedHashes?: string[],
 	path?: string,
-	maxLineBytes = MAX_READ_LINE_BYTES,
+	maxLineBytes = DEFAULT_MAX_BYTES,
 	maxTruncLines = DEFAULT_MAX_LINES,
 ): Promise<{ text: string; truncation?: TruncationResult; nextOffset?: number; servedHashes: string[] }> {
 	const allLines = visLines(text);
@@ -100,21 +102,27 @@ export async function fmtReadPreview(
 		const oversized = rowSizes.filter((row) => row.bytes > maxBytes);
 		const rows = rowSizes.map((row, index) =>
 			row.bytes > maxBytes
-				? `[Line ${row.lineNumber} is ${formatSize(row.bytes)}, exceeds ${formatSize(maxBytes)}; content not shown. Use bash: sed -n '${row.lineNumber}p' <path> | head -c ${maxBytes}]`
+				? fmtRow(selectedHashes[index]!, `[Line ${row.lineNumber} is ${formatSize(row.bytes)}, exceeds ${formatSize(maxBytes)}; content not shown. Use bash: sed -n '${row.lineNumber}p' <path> | head -c ${maxBytes}]`)
 				: fmtRegion([selectedHashes[index]!], [selected[index]!]),
 		);
 		const skippedTruncation = truncateHead(rows.join("\n"), { maxBytes, maxLines: maxTruncLines });
 		const shownRowCount = skippedTruncation.content === "" ? 0 : skippedTruncation.content.split("\n").length;
 		const lastShownLine = shownRowCount > 0 ? startLine + shownRowCount - 1 : startLine - 1;
-		const oversizedIndexes = new Set(rowSizes.map((row, index) => row.bytes > maxBytes ? index : -1).filter((index) => index >= 0));
 		const servedHashes: string[] = [];
 		for (let index = 0; index < Math.min(shownRowCount, rows.length); index++) {
-			if (!oversizedIndexes.has(index)) servedHashes.push(selectedHashes[index]!);
+			servedHashes.push(selectedHashes[index]!);
 		}
-		const lineLabel = oversized.length === 1 ? `Line ${oversized[0]!.lineNumber}` : `Lines ${oversized.map((row) => row.lineNumber).join(", ")}`;
-		const verb = oversized.length === 1 ? "exceeds" : "exceed";
-		const addresses = oversized.map((row) => `${row.lineNumber}p`).join(";");
-		const warning = `[${lineLabel} ${verb} ${formatSize(maxBytes)}; content not shown. Inspect with bash: sed -n '${addresses}' <path> | head -c ${maxBytes}]`;
+		const listed = oversized.slice(0, MAX_OVERSIZED_WARNING_LINES);
+		const hiddenCount = oversized.length - listed.length;
+		const lineLabel = oversized.length === 1
+			? `Line ${oversized[0]!.lineNumber}`
+			: `Lines ${listed.map((row) => row.lineNumber).join(', ')}${hiddenCount > 0 ? `, ... (+${hiddenCount} more)` : ''}`;
+		const verb = oversized.length === 1 ? 'exceeds' : 'exceed';
+		const addresses = listed.map((row) => `${row.lineNumber}p`).join(';');
+		const moreHint = hiddenCount > 0
+			? ` ${hiddenCount} more oversized line(s). Use read with offset to inspect them.`
+			: '';
+		const warning = `[${lineLabel} ${verb} ${formatSize(maxBytes)}; content not shown. Inspect with bash: sed -n '${addresses}' <path> | head -c ${maxBytes}${moreHint}]`;
 		let preview = skippedTruncation.content;
 		let nextOffset: number | undefined;
 		if (shownRowCount > 0 && (skippedTruncation.truncated || lastShownLine < totalLines)) {
@@ -183,6 +191,18 @@ export function regRead(pi: ExtensionAPI): void {
 				}),
 			),
 		}),
+		executionMode: "sequential",
+		renderResult(result, { isPartial, expanded }, theme, context) {
+			if (isPartial) return new Text((theme as unknown as { fg: (a:string,b:string)=>string }).fg("warning", "Reading..."), 0, 0);
+			const raw = (result.content?.[0] as { text?: string } | undefined)?.text;
+			if (typeof raw !== "string") return new Text("", 0, 0);
+			if ((context as unknown as { isError?: boolean }).isError) return new Text((theme as unknown as { fg: (a:string,b:string)=>string }).fg("error", raw), 0, 0);
+			const isExpanded = expanded === true || (context as unknown as { expanded?: boolean }).expanded === true;
+			if (!isExpanded) return new Text("", 0, 0);
+			const details = (result as unknown as { details?: { offset?: number } }).details;
+			const off = details?.offset ?? (context as unknown as { args?: { offset?: number } }).args?.offset ?? 1;
+			return new Text(numberedRead(raw, off), 0, 0);
+		},
 
 		async execute(_toolCallId, params, signal, _onUpdate, ctx) {
 			const rawPath = params.path;
@@ -228,6 +248,7 @@ export function regRead(pi: ExtensionAPI): void {
 				details: {
 					truncation: preview.truncation,
 					snapshotId,
+					offset: params.offset ?? 1,
 					...(preview.nextOffset !== undefined
 						? { nextOffset: preview.nextOffset }
 						: {}),

package/src/replace-diff.ts

@@ -1,4 +1,5 @@
 import * as Diff from "diff";
+import { formatSize, DEFAULT_MAX_BYTES } from "@earendil-works/pi-coding-agent";
 import {
   _lineHashesPure,
   ANCHOR_LEN,
@@ -8,13 +9,13 @@ import {
 export type LineEnding = "\r\n" | "\n" | "\r";
 
 export function detectEnding(content: string): LineEnding {
+  const crIdx = content.indexOf("\r");
   const lfIdx = content.indexOf("\n");
-  if (lfIdx === -1) {
-    return content.indexOf("\r") >= 0 ? "\r" : "\n";
-  }
-  const crlfIdx = content.indexOf("\r\n");
-  if (crlfIdx === -1) return "\n";
-  return crlfIdx < lfIdx ? "\r\n" : "\n";
+  if (crIdx === -1 && lfIdx === -1) return "\n";
+  if (crIdx === -1) return "\n";
+  if (lfIdx === -1) return "\r";
+  if (crIdx < lfIdx) return content[crIdx + 1] === "\n" ? "\r\n" : "\r";
+  return "\n";
 }
 
 export function toLF(text: string): string {
@@ -55,14 +56,23 @@ const ELLIPSIS_MARKER: unique symbol = Symbol("ellipsis");
 const isEllipsisMarker = (line: string | symbol): line is symbol =>
   line === ELLIPSIS_MARKER;
 
+export interface DiffLimits {
+  maxLineBytes?: number;
+  maxBytes?: number;
+  unlimited?: boolean;
+}
+
 export function genDiff(
   oldContent: string,
   newContent: string,
   contextLines = 2,
   newContentHashes?: string[],
   oldContentHashes?: string[],
-): { diff: string; firstChangedLine: number | undefined } {
+  limits?: DiffLimits,
+): { diff: string; firstChangedLine: number | undefined; lineNumbers: (number|undefined)[] } {
   const effectiveNewHashes = newContentHashes ?? _lineHashesPure(newContent);
+  const maxLineBytes = limits?.unlimited ? Number.POSITIVE_INFINITY : (limits?.maxLineBytes ?? DEFAULT_MAX_BYTES);
+  const maxBytes = limits?.unlimited ? Number.POSITIVE_INFINITY : (limits?.maxBytes ?? DEFAULT_MAX_BYTES);
 
   const parts = Diff.diffLines(oldContent, newContent);
   const output: string[] = [];
@@ -70,8 +80,45 @@ export function genDiff(
   let oldLineNum = 1;
   let lastWasChange = false;
   let firstChangedLine: number | undefined;
+  let outBytes = 0;
+  let stopped = false;
+  let diffTruncated = false;
+	const lineNumbers: (number|undefined)[] = [];
+
+	const emitPlain = (line: string, num?: number): void => {
+    if (stopped) return;
+    const lineBytes = Buffer.byteLength(line, "utf-8") + 1;
+    if (outBytes + lineBytes > maxBytes) {
+      stopped = true;
+      diffTruncated = true;
+      return;
+    }
+    outBytes += lineBytes;
+    output.push(line);
+    lineNumbers.push(num);
+  };
+
+	const emitRow = (prefix: " " | "+" | "-", line: string, hash: string | undefined, num?: number): void => {
+    if (stopped) return;
+    const full = fmtDiffLine(prefix, line, hash);
+    const rowBytes = Buffer.byteLength(full, "utf-8");
+    if (rowBytes > maxLineBytes) {
+      const marker = `[Row is ${formatSize(rowBytes)}, exceeds ${formatSize(maxLineBytes)}; content not shown. Use read to see the full line.]`;
+      emitPlain(fmtDiffLine(prefix, marker, hash), num);
+      return;
+    }
+    if (outBytes + rowBytes + 1 > maxBytes) {
+      stopped = true;
+      diffTruncated = true;
+      return;
+    }
+    outBytes += rowBytes + 1;
+    output.push(full);
+    lineNumbers.push(num);
+  };
 
   for (let i = 0; i < parts.length; i++) {
+    if (stopped) break;
     const part = parts[i]!;
     const raw = part.value.split("\n");
     if (raw[raw.length - 1] === "") raw.pop();
@@ -80,16 +127,18 @@ export function genDiff(
     if (part.added || part.removed) {
       if (firstChangedLine === undefined) firstChangedLine = newLineNum;
       for (let k = 0; k < displayLines.length; k++) {
+        if (stopped) break;
         if (part.added) {
           const hash = effectiveNewHashes[newLineNum - 1];
-          output.push(fmtDiffLine("+", displayLines[k]!, hash));
+          emitRow("+", displayLines[k]!, hash, newLineNum);
           newLineNum++;
         } else {
           const hash = oldContentHashes?.[oldLineNum - 1];
-          output.push(fmtDiffLine("-", displayLines[k]!, hash));
+          emitRow("-", displayLines[k]!, hash, oldLineNum);
           oldLineNum++;
         }
       }
+      if (stopped) break;
       lastWasChange = true;
       continue;
     }
@@ -152,24 +201,25 @@ export function genDiff(
       }
 
       if (skipStart > 0) {
-        output.push(" ...");
+        emitPlain(" ...", undefined);
         newLineNum += skipStart;
         oldLineNum += skipStart;
       }
       for (const line of linesToShow) {
+        if (stopped) break;
         if (isEllipsisMarker(line)) {
-          output.push(" ...");
+          emitPlain(" ...", undefined);
           newLineNum += skipMiddle;
           oldLineNum += skipMiddle;
           continue;
         }
         const hash = effectiveNewHashes[newLineNum - 1];
-        output.push(fmtDiffLine(" ", line, hash));
+        emitRow(" ", line, hash, newLineNum);
         newLineNum++;
         oldLineNum++;
       }
       if (skipTail > 0) {
-        output.push(" ...");
+        emitPlain(" ...", undefined);
       }
     } else {
       newLineNum += displayLines.length;
@@ -178,16 +228,55 @@ export function genDiff(
     lastWasChange = false;
   }
 
-  return { diff: output.join("\n"), firstChangedLine };
+  if (diffTruncated) {
+    output.push(" ...");
+    lineNumbers.push(undefined);
+    output.push(`[diff truncated at ${formatSize(maxBytes)}; use read to see the rest.]`);
+    lineNumbers.push(undefined);
+  }
+
+  return { diff: output.join("\n"), firstChangedLine, lineNumbers };
 }
 
 export function genPatch(
   path: string,
   oldContent: string,
   newContent: string,
-): string {
-  return Diff.createTwoFilesPatch(path, path, oldContent, newContent, undefined, undefined, {
-    context: 4,
-    headerOptions: Diff.FILE_HEADERS_ONLY,
-  });
+  limits?: DiffLimits,
+): { patch: string; truncated: boolean } {
+	const patchOpts: Record<string, unknown> = { context: 4 };
+	const ho = (Diff as unknown as Record<string, unknown>).FILE_HEADERS_ONLY;
+	if (ho !== undefined) patchOpts.headerOptions = ho;
+	const full = (Diff.createTwoFilesPatch(path, path, oldContent, newContent, undefined, undefined, patchOpts as never) as unknown as string) ?? "";
+  const maxLineBytes = limits?.unlimited ? Number.POSITIVE_INFINITY : (limits?.maxLineBytes ?? DEFAULT_MAX_BYTES);
+  const maxBytes = limits?.unlimited ? Number.POSITIVE_INFINITY : (limits?.maxBytes ?? DEFAULT_MAX_BYTES);
+  const out: string[] = [];
+  let outBytes = 0;
+  let truncated = false;
+  for (const line of full.split("\n")) {
+    const lineBytes = Buffer.byteLength(line, "utf-8");
+    if (lineBytes > maxLineBytes) {
+      truncated = true;
+      const prefix = /^[ +-]/.test(line) ? line[0]! : "";
+      const marker = `${prefix}[Patch line is ${formatSize(lineBytes)}, exceeds ${formatSize(maxLineBytes)}; content not shown. Use read to see the full line.]`;
+      const markerBytes = Buffer.byteLength(marker, "utf-8") + 1;
+      if (outBytes + markerBytes > maxBytes) {
+        break;
+      }
+      outBytes += markerBytes;
+      out.push(marker);
+      continue;
+    }
+    if (outBytes + lineBytes + 1 > maxBytes) {
+      truncated = true;
+      break;
+    }
+    outBytes += lineBytes + 1;
+    out.push(line);
+  }
+  if (truncated) {
+    out.push("...");
+    out.push(`[patch truncated at ${formatSize(maxBytes)}; the patch cannot be applied as-is. Use read to see the full file.]`);
+  }
+  return { patch: out.join("\n"), truncated };
 }