pi-hashline-edit-pro 2.7.2 → 2.8.0

package/src/hash-store.ts

@@ -6,6 +6,8 @@ import { initHasher, contentChecksum } from "./hashline/hasher";
 import { HASH_RE } from "./hashline/alphabet";
 import { HASH_STORE_VERSION, HASH_STORE_BUSY_TIMEOUT } from "./constants";
 
+export const STORE_NOT_OPEN_MESSAGE = "Hash store is not open; transactional update aborted";
+
 type SqlParams = (string | number)[];
 
 interface RawStatement {
@@ -104,21 +106,22 @@ export function isValidHashList(value: unknown): value is string[] {
   return true;
 }
 
-export function parseHashList(raw: string, onInvalid: () => void): string[] | undefined {
+export function parseHashList(raw: string, onInvalid: () => void, context?: string): string[] | undefined {
   let parsed: unknown;
   try {
     parsed = JSON.parse(raw);
-  } catch {
+  } catch (error) {
+    console.error(`[parseHashList]${context ? ` ${context}:` : ""} failed to parse stored hashes JSON:`, error);
     onInvalid();
     return undefined;
   }
   if (!isValidHashList(parsed)) {
+    console.error(`[parseHashList]${context ? ` ${context}:` : ""} stored hashes did not pass validation:`, Array.isArray(parsed) ? `length=${parsed.length} sample=${JSON.stringify(parsed.slice(0, 3))}` : (() => { try { return JSON.stringify(parsed)?.slice(0, 500) ?? String(parsed).slice(0, 500); } catch { return String(parsed).slice(0, 500); } })());
     onInvalid();
     return undefined;
   }
   return parsed;
 }
-
 export function parseStoredHashes(
   row: Record<string, unknown> | undefined,
   onInvalid: () => void,
@@ -157,13 +160,14 @@ function isBusyError(error: unknown): boolean {
   return error instanceof Error && /busy|locked/i.test(error.message);
 }
 
+const sleepSab = new Int32Array(new SharedArrayBuffer(4));
+
 function sleepSync(ms: number): void {
-  const sab = new Int32Array(new SharedArrayBuffer(4));
-  Atomics.wait(sab, 0, 0, ms);
+  Atomics.wait(sleepSab, 0, 0, ms);
 }
 
 const BUSY_RETRIES = 3;
-const BUSY_RETRY_DELAY_MS = 100;
+const BUSY_RETRY_DELAY_MS = 50;
 
 function withBusyRetry<T>(fn: () => T): T {
   let lastError: unknown;
@@ -173,14 +177,28 @@ function withBusyRetry<T>(fn: () => T): T {
     } catch (error) {
       lastError = error;
       if (!isBusyError(error) || attempt === BUSY_RETRIES) throw error;
-      sleepSync(BUSY_RETRY_DELAY_MS);
+      sleepSync(BUSY_RETRY_DELAY_MS * (1 << attempt));
     }
   }
   throw lastError;
 }
 
-function openDbWithBusyRetry(storePath: string): { db: RawDb; stmts: Prepared } {
-  return withBusyRetry(() => openDb(storePath));
+async function withBusyRetryAsync<T>(fn: () => T): Promise<T> {
+  let lastError: unknown;
+  for (let attempt = 0; attempt <= BUSY_RETRIES; attempt++) {
+    try {
+      return fn();
+    } catch (error) {
+      lastError = error;
+      if (!isBusyError(error) || attempt === BUSY_RETRIES) throw error;
+      await new Promise<void>((r) => setTimeout(r, BUSY_RETRY_DELAY_MS * (1 << attempt)));
+    }
+  }
+  throw lastError;
+}
+
+async function openDbWithBusyRetryAsync(storePath: string): Promise<{ db: RawDb; stmts: Prepared }> {
+  return withBusyRetryAsync(() => openDb(storePath));
 }
 
 function retriedWrite(
@@ -341,19 +359,19 @@ async function openStore(storePath: string): Promise<HashStore> {
   let existed = existsSync(storePath);
   let opened: { db: RawDb; stmts: Prepared };
   try {
-    opened = openDbWithBusyRetry(storePath);
+    opened = await openDbWithBusyRetryAsync(storePath);
   } catch (error) {
     if (!isCorruptionError(error)) throw error;
     console.error("Hash store failed to open, rebuilding:", error);
     await quarantineStore(storePath);
     existed = false;
-    opened = openDbWithBusyRetry(storePath);
+    opened = await openDbWithBusyRetryAsync(storePath);
   }
   if (!isHealthy(opened.db)) {
     shutdownDb(opened.db);
     await quarantineStore(storePath);
     existed = false;
-    opened = openDbWithBusyRetry(storePath);
+    opened = await openDbWithBusyRetryAsync(storePath);
   }
   const { db, stmts } = opened;
 
@@ -403,9 +421,9 @@ export function shutdownHashStore(): void {
   snapshotCache.clear();
 }
 
-function withStore(fn: () => void): void {
+export function withStore(fn: () => void): void {
   if (!cachedDb) {
-    throw new Error("Hash store is not open; transactional update aborted");
+    throw new Error(STORE_NOT_OPEN_MESSAGE);
   }
   withBusyRetry(() => {
     cachedDb!.db.exec("BEGIN IMMEDIATE");
@@ -528,6 +546,14 @@ export function upsertSnapshot(
   store.stmts.upsert(path, checksum, lineCount, JSON.stringify(hashes), Date.now());
   cacheSnapshot(path, checksum, lineCount, hashes);
 }
+export function persistSnapshot(
+  store: HashStore,
+  path: string,
+  content: string,
+  hashes: string[],
+): void {
+  upsertSnapshot(store, path, contentChecksum(content), splitLines(content).length, hashes);
+}
 
 export function upsertUndo(store: HashStore, path: string, entry: UndoRecord): void {
   store.stmts.undoUpsert(
@@ -593,22 +619,32 @@ export async function pruneMissing(store: HashStore): Promise<void> {
   withStore(() => {
     for (const path of missing) {
       store.stmts.deleteOne(path);
-      snapshotCache.delete(path);
       store.stmts.servedDelete(path);
     }
   });
+  for (const path of missing) snapshotCache.delete(path);
 }
 
 function matchPathsByHashes(
   rows: { path: string; hashes: string }[],
   hashes: string[],
 ): string[] {
+  const needed = new Set(hashes);
+  if (needed.size === 0) return [];
   const matches: string[] = [];
   for (const row of rows) {
     try {
       const parsed = JSON.parse(row.hashes) as unknown;
       if (!isValidHashList(parsed)) continue;
-      if (hashes.every((h) => parsed.includes(h))) matches.push(row.path);
+      const parsedSet = new Set(parsed);
+      let ok = true;
+      for (const h of needed) {
+        if (!parsedSet.has(h)) {
+          ok = false;
+          break;
+        }
+      }
+      if (ok) matches.push(row.path);
     } catch {
       continue;
     }

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

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

@@ -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

@@ -9,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 {
@@ -69,7 +69,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 +83,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 +95,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 +114,7 @@ export function genDiff(
     }
     outBytes += rowBytes + 1;
     output.push(full);
+    lineNumbers.push(num);
   };
 
   for (let i = 0; i < parts.length; i++) {
@@ -127,11 +130,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 +201,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 +230,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 +244,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[] = [];