pi-hashline-edit-pro 2.7.2 → 2.8.1

package/src/hashline/hash.ts

@@ -1,12 +1,12 @@
-import { splitLines, truncateToBytes } from "../utils";
+import { splitLines, truncateToBytes, getCached } from "../utils";
 import { MAX_HASH_SOURCE_BYTES } from "../constants";
 import {
   loadHashStore,
   type HashStore,
   getSnapshot,
-  upsertSnapshot,
+  persistSnapshot,
 } from "../hash-store";
-import { xxh32, contentChecksum, initHasher } from "./hasher";
+import { xxh32, initHasher } from "./hasher";
 import { HASH_LEN, ALPH, ALPH_RE, HASH_CLASS, HASH_RUN } from "./alphabet";
 export { initHasher, HASH_LEN, ALPH_RE, HASH_CLASS, HASH_RUN };
 
@@ -120,9 +120,10 @@ export function _lineHashesPure(content: string): string[] {
   const hashes = new Array<string>(lines.length);
   const used = new Uint32Array(BITSET_WORDS);
   const hint = { value: 0 };
+  const hashSourceCache = new Map<string, string>();
 
   for (let i = 0; i < lines.length; i++) {
-    const c = hashSource(lines[i]!);
+    const c = getCached(hashSourceCache, lines[i]!, hashSource);
     const baseIdx = (xxh32(c) >>> 14) % HASH_SPACE;
     hashes[i] = assignHash(used, baseIdx, hint);
   }
@@ -151,7 +152,7 @@ export async function lineHashes(
     );
     if (persist !== false) {
       try {
-        upsertSnapshot(hashStore, path, contentChecksum(content), splitLines(content).length, newHashes);
+        persistSnapshot(hashStore, path, content, newHashes);
       } catch (error) {
         console.error("Failed to persist hash snapshot:", error);
       }
@@ -172,7 +173,7 @@ export async function lineHashes(
   const newHashes = _lineHashesPure(content);
   if (persist !== false) {
     try {
-      upsertSnapshot(hashStore, path, contentChecksum(content), splitLines(content).length, newHashes);
+      persistSnapshot(hashStore, path, content, newHashes);
     } catch (error) {
       console.error("Failed to persist hash snapshot:", error);
     }
@@ -224,6 +225,7 @@ function mapStableHashes(
   const newHashes = new Array<string>(newLines.length);
   const used = new Uint32Array(BITSET_WORDS);
   const hint = { value: 0 };
+  const hashSourceCache = new Map<string, string>();
   const removed = removedHashes ?? new Set<string>();
 
   const oldHashIndex = new Map<string, number>();
@@ -260,7 +262,7 @@ function mapStableHashes(
 
   const newByContent = new Map<string, number[]>();
   for (let i = 0; i < newLines.length; i++) {
-    const key = hashSource(newLines[i]!);
+    const key = getCached(hashSourceCache, newLines[i]!, hashSource);
     const list = newByContent.get(key);
     if (list) list.push(i);
     else newByContent.set(key, [i]);
@@ -275,7 +277,7 @@ function mapStableHashes(
   };
 
   for (const entry of survivors) {
-    const candidates = newByContent.get(hashSource(oldLines[entry.index]!));
+    const candidates = newByContent.get(getCached(hashSourceCache, oldLines[entry.index]!, hashSource));
     if (!candidates || candidates.length === 0) continue;
     const target = entry.index > spanEnd ? entry.index + shiftAfterSpan : entry.index;
     const pos = nearestNew(candidates, target);
@@ -306,7 +308,7 @@ function mapStableHashes(
 
   for (let i = 0; i < newLines.length; i++) {
     if (newHashes[i]) continue;
-    const c = hashSource(newLines[i]!);
+    const c = getCached(hashSourceCache, newLines[i]!, hashSource);
     const baseIdx = (xxh32(c) >>> 14) % HASH_SPACE;
     newHashes[i] = assignHash(used, baseIdx, hint);
   }

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 {
@@ -16,7 +19,18 @@ function diagRef(ref: string): string {
 	if (/^\d+/.test(trimmed)) {
 		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 anchor, drop everything from "│" onward.`;
 	}

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";
@@ -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),

package/src/insert.ts

@@ -1,20 +1,17 @@
 import type { ExtensionAPI, ToolDefinition } from "@earendil-works/pi-coding-agent";
-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 { 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 { makeRenderCall, renderEditResult, type RPreview, type RRState } from "./replace-render";
-import { abortIf, isRec, makePrepareArguments, rejectUnknownFields, splitLines } from "./utils";
+import { normReq } from "./payload-contract";
+import { isRec, rejectUnknownFields, splitLines } from "./utils";
 import { clearBoundaryBypass } from "./boundary-bypass";
+import type { RPreview, RRState } from "./replace-render";
+import { queuedEdit, editToolBase, editRenderCallWrapper, editRenderResultWrapper } from "./edit-common";
 
 const INSERT_KS = new Set(["path", "anchor", "direction", "lines"]);
 
@@ -121,12 +118,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);
   }
 }
 
@@ -163,32 +157,17 @@ export function buildInsertToolDef(): InsertToolDef {
     description: loadP("../prompts/insert.md"),
     promptSnippet: loadP("../prompts/insert-snippet.md"),
     promptGuidelines: loadGuide("../prompts/insert-guidelines.md"),
-    prepareArguments: makePrepareArguments(),
+    ...editToolBase,
     parameters: insertToolSchema,
-    renderShell: "default",
-    renderCall: makeRenderCall(insertPreview, { getInput: getInsertInput, toolName: "insert" }),
-    renderResult(result, { isPartial }, theme, context) {
-      return renderEditResult(
-        result as {
-          content?: Array<{ type: string; text?: string }>;
-          details?: ReplaceDetails;
-        },
-        isPartial,
-        theme,
-        context,
-      );
-    },
-
+    renderCall: editRenderCallWrapper(insertPreview, getInsertInput, "insert"),
+    renderResult: editRenderResultWrapper,
     async execute(_toolCallId, params, signal, _onUpdate, ctx) {
       const canonical = normReq(params);
       assertInsertReq(canonical);
       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);
-      return withFileMutationQueue(mutationTargetPath, async () => {
-        abortIf(signal);
+      return queuedEdit(path, ctx.cwd, signal, async (absolutePath, mutationTargetPath) => {
         const preload = await readNormFile(path, ctx.cwd, {
           signal,
           accessMode: constants.R_OK | constants.W_OK,

package/src/normalize.ts

@@ -0,0 +1,27 @@
+export type LineEnding = "\r\n" | "\n" | "\r";
+
+export function detectEnding(content: string): LineEnding {
+  const crIdx = content.indexOf("\r");
+  const lfIdx = content.indexOf("\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 {
+  return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+
+export function restoreEndings(text: string, ending: LineEnding): string {
+  if (ending === "\r\n") return text.replace(/\n/g, "\r\n");
+  if (ending === "\r") return text.replace(/\n/g, "\r");
+  return text;
+}
+
+export function stripBOM(content: string): { bom: string; text: string } {
+  return content.startsWith("\uFEFF")
+    ? { bom: "\uFEFF", text: content.slice(1) }
+    : { bom: "", text: content };
+}

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

@@ -13,10 +13,11 @@ import { MAX_OVERSIZED_WARNING_LINES } from "./constants";
 import { readNormFile, safeSnapId } from "./file-reader";
 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");
 
@@ -190,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;
@@ -235,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

@@ -5,37 +5,15 @@ import {
   ANCHOR_LEN,
   HASH_SEP,
 } from "./hashline";
+import {
+  detectEnding,
+  toLF,
+  restoreEndings,
+  stripBOM,
+  type LineEnding,
+} from "./normalize";
 
-export type LineEnding = "\r\n" | "\n" | "\r";
-
-export function detectEnding(content: string): LineEnding {
-  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";
-}
-
-export function toLF(text: string): string {
-  return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
-}
-
-export function restoreEndings(
-  text: string,
-  ending: LineEnding,
-): string {
-  if (ending === "\r\n") return text.replace(/\n/g, "\r\n");
-  if (ending === "\r") return text.replace(/\n/g, "\r");
-  return text;
-}
-
-export function stripBOM(content: string): { bom: string; text: string } {
-  return content.startsWith("\uFEFF")
-    ? { bom: "\uFEFF", text: content.slice(1) }
-    : { bom: "", text: content };
-}
+export { detectEnding, toLF, restoreEndings, stripBOM, type LineEnding };
 
 function fmtDiffLine(
   prefix: " " | "+" | "-",
@@ -69,7 +47,7 @@ export function genDiff(
   newContentHashes?: string[],
   oldContentHashes?: string[],
   limits?: DiffLimits,
-): { diff: string; firstChangedLine: number | undefined } {
+): { 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);
@@ -83,8 +61,9 @@ export function genDiff(
   let outBytes = 0;
   let stopped = false;
   let diffTruncated = false;
+	const lineNumbers: (number|undefined)[] = [];
 
-  const emitPlain = (line: string): void => {
+	const emitPlain = (line: string, num?: number): void => {
     if (stopped) return;
     const lineBytes = Buffer.byteLength(line, "utf-8") + 1;
     if (outBytes + lineBytes > maxBytes) {
@@ -94,15 +73,16 @@ export function genDiff(
     }
     outBytes += lineBytes;
     output.push(line);
+    lineNumbers.push(num);
   };
 
-  const emitRow = (prefix: " " | "+" | "-", line: string, hash: string | undefined): void => {
+	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));
+      emitPlain(fmtDiffLine(prefix, marker, hash), num);
       return;
     }
     if (outBytes + rowBytes + 1 > maxBytes) {
@@ -112,6 +92,7 @@ export function genDiff(
     }
     outBytes += rowBytes + 1;
     output.push(full);
+    lineNumbers.push(num);
   };
 
   for (let i = 0; i < parts.length; i++) {
@@ -127,11 +108,11 @@ export function genDiff(
         if (stopped) break;
         if (part.added) {
           const hash = effectiveNewHashes[newLineNum - 1];
-          emitRow("+", displayLines[k]!, hash);
+          emitRow("+", displayLines[k]!, hash, newLineNum);
           newLineNum++;
         } else {
           const hash = oldContentHashes?.[oldLineNum - 1];
-          emitRow("-", displayLines[k]!, hash);
+          emitRow("-", displayLines[k]!, hash, oldLineNum);
           oldLineNum++;
         }
       }
@@ -198,25 +179,25 @@ export function genDiff(
       }
 
       if (skipStart > 0) {
-        emitPlain(" ...");
+        emitPlain(" ...", undefined);
         newLineNum += skipStart;
         oldLineNum += skipStart;
       }
       for (const line of linesToShow) {
         if (stopped) break;
         if (isEllipsisMarker(line)) {
-          emitPlain(" ...");
+          emitPlain(" ...", undefined);
           newLineNum += skipMiddle;
           oldLineNum += skipMiddle;
           continue;
         }
         const hash = effectiveNewHashes[newLineNum - 1];
-        emitRow(" ", line, hash);
+        emitRow(" ", line, hash, newLineNum);
         newLineNum++;
         oldLineNum++;
       }
       if (skipTail > 0) {
-        emitPlain(" ...");
+        emitPlain(" ...", undefined);
       }
     } else {
       newLineNum += displayLines.length;
@@ -227,10 +208,12 @@ export function genDiff(
 
   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 };
+  return { diff: output.join("\n"), firstChangedLine, lineNumbers };
 }
 
 export function genPatch(
@@ -239,10 +222,10 @@ export function genPatch(
   newContent: string,
   limits?: DiffLimits,
 ): { patch: string; truncated: boolean } {
-  const full = Diff.createTwoFilesPatch(path, path, oldContent, newContent, undefined, undefined, {
-    context: 4,
-    headerOptions: Diff.FILE_HEADERS_ONLY,
-  });
+	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[] = [];

package/src/replace-render.ts

@@ -1,8 +1,9 @@
 import { Markdown, Text } from "@earendil-works/pi-tui";
 import { keyHint, type Theme } from "@earendil-works/pi-coding-agent";
-import { normReq } from "./replace-normalize";
-import type { ReqParams, ReplaceDetails } from "./replace";
-import { isRec } from "./utils";
+import type { ReplaceDetails } from "./replace";
+import { withLineNumbers } from "./utils";
+import { getPreviewInput } from "./payload-contract";
+export { getPreviewInput };
 
 export type FgT = Pick<Theme, "fg">;
 export type CallT = Pick<Theme, "fg" | "bold">;
@@ -20,42 +21,12 @@ export type RRState = {
 	previewTimer?: ReturnType<typeof setTimeout>;
 };
 
-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;
-	}
-
-	const request: ReqParams = {
-		path: normalized.path,
-		remove_from: normalized.remove_from,
-		remove_to: normalized.remove_to,
-		replacement_lines: normalized.replacement_lines,
-	};
-	return request;
-}
-
 type DiffRowKind = "added" | "removed" | "context";
 
 function diffRowKind(line: string): DiffRowKind {
-	if (line.startsWith("+") && !line.startsWith("+++")) return "added";
-	if (line.startsWith("-") && !line.startsWith("---")) return "removed";
+	const stripped = line.replace(/^\s*\d+\s+│\s*/, "");
+	if (stripped.startsWith("+") && !stripped.startsWith("+++")) return "added";
+	if (stripped.startsWith("-") && !stripped.startsWith("---")) return "removed";
 	return "context";
 }
 
@@ -67,6 +38,9 @@ export function colorLines(lines: string[], theme: FgT): string[] {
 		return theme.fg("dim", line);
 	});
 }
+export function toNumberedDiff(diff: string, lineNumbers: (number|undefined)[]): string {
+	return withLineNumbers(diff, lineNumbers);
+}
 
 export function fmtPreview(
 	diff: string,
@@ -173,10 +147,11 @@ export function buildAppliedText(
 	const summary = extractSummary(text);
 	if (summary) sections.push(summary);
 	if (details?.diff) {
+		const rawDiff = details.diffLineNumbers ? toNumberedDiff(details.diff, details.diffLineNumbers) : details.diff;
 		const diffLines = details.diff.split("\n");
 		const diffSection = expanded
-			? fmtResult(details.diff, theme)
-			: fmtPreview(details.diff, false, theme);
+			? fmtResult(rawDiff, theme)
+			: fmtPreview(rawDiff, false, theme);
 		const hint =
 			!expanded && diffLines.length > RESULT_PREVIEW_LINES
 				? ` (${expandHint()})`
@@ -322,10 +297,12 @@ export function makeRenderCall(
 
 export function renderEditResult(
 	result: { content?: Array<{ type: string; text?: string }>; details?: ReplaceDetails },
-	isPartial: boolean,
+	options: { isPartial: boolean; expanded?: boolean } | boolean,
 	theme: FgT,
 	context: any,
 ): Text | Markdown {
+	const isPartial = typeof options === "boolean" ? options : options.isPartial;
+	const optionsExpanded = typeof options === "boolean" ? undefined : options.expanded;
 	if (isPartial) return reuseText(context, theme.fg("warning", "Editing..."));
 	const renderedText = getResultText(result);
 	const renderState = context.state as RRState | undefined;
@@ -343,7 +320,8 @@ export function renderEditResult(
 			: new Text("", 0, 0);
 	}
 	if (isApplied(result.details)) {
-		const appliedText = buildAppliedText(renderedText, result.details, theme, context.expanded === true);
+		const isExpanded = optionsExpanded === true || context.expanded === true;
+		const appliedText = buildAppliedText(renderedText, result.details, theme, isExpanded);
 		return appliedText ? reuseText(context, appliedText) : new Text("", 0, 0);
 	}
 	if (!renderedText) return new Text("", 0, 0);

package/src/replace-response.ts

@@ -164,6 +164,7 @@ export function buildChanged(input: SuccessInput, verb = "replaced"): TResult {
         editMeta.firstChangedLine ?? diffResult.firstChangedLine,
       snapshotId,
       metrics,
+      diffLineNumbers: diffResult.lineNumbers,
     },
   };
 }