pi-hashline-edit-pro 2.7.0 → 2.7.2

package/src/read.ts

@@ -3,14 +3,15 @@ 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 { recordServedSafe } from "./served";
@@ -56,7 +57,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 +101,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)) {

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,
@@ -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[],
+  limits?: DiffLimits,
 ): { diff: string; firstChangedLine: 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,42 @@ export function genDiff(
   let oldLineNum = 1;
   let lastWasChange = false;
   let firstChangedLine: number | undefined;
+  let outBytes = 0;
+  let stopped = false;
+  let diffTruncated = false;
+
+  const emitPlain = (line: string): 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);
+  };
+
+  const emitRow = (prefix: " " | "+" | "-", line: string, hash: string | undefined): 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));
+      return;
+    }
+    if (outBytes + rowBytes + 1 > maxBytes) {
+      stopped = true;
+      diffTruncated = true;
+      return;
+    }
+    outBytes += rowBytes + 1;
+    output.push(full);
+  };
 
   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 +124,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++;
         } else {
           const hash = oldContentHashes?.[oldLineNum - 1];
-          output.push(fmtDiffLine("-", displayLines[k]!, hash));
+          emitRow("-", displayLines[k]!, hash);
           oldLineNum++;
         }
       }
+      if (stopped) break;
       lastWasChange = true;
       continue;
     }
@@ -152,24 +198,25 @@ export function genDiff(
       }
 
       if (skipStart > 0) {
-        output.push(" ...");
+        emitPlain(" ...");
         newLineNum += skipStart;
         oldLineNum += skipStart;
       }
       for (const line of linesToShow) {
+        if (stopped) break;
         if (isEllipsisMarker(line)) {
-          output.push(" ...");
+          emitPlain(" ...");
           newLineNum += skipMiddle;
           oldLineNum += skipMiddle;
           continue;
         }
         const hash = effectiveNewHashes[newLineNum - 1];
-        output.push(fmtDiffLine(" ", line, hash));
+        emitRow(" ", line, hash);
         newLineNum++;
         oldLineNum++;
       }
       if (skipTail > 0) {
-        output.push(" ...");
+        emitPlain(" ...");
       }
     } else {
       newLineNum += displayLines.length;
@@ -178,6 +225,11 @@ export function genDiff(
     lastWasChange = false;
   }
 
+  if (diffTruncated) {
+    output.push(" ...");
+    output.push(`[diff truncated at ${formatSize(maxBytes)}; use read to see the rest.]`);
+  }
+
   return { diff: output.join("\n"), firstChangedLine };
 }
 
@@ -185,9 +237,41 @@ export function genPatch(
   path: string,
   oldContent: string,
   newContent: string,
-): string {
-  return Diff.createTwoFilesPatch(path, path, oldContent, newContent, undefined, undefined, {
+  limits?: DiffLimits,
+): { patch: string; truncated: boolean } {
+  const full = Diff.createTwoFilesPatch(path, path, oldContent, newContent, undefined, undefined, {
     context: 4,
     headerOptions: Diff.FILE_HEADERS_ONLY,
   });
+  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 };
 }

package/src/replace-render.ts

@@ -1,5 +1,5 @@
 import { Markdown, Text } from "@earendil-works/pi-tui";
-import type { Theme } from "@earendil-works/pi-coding-agent";
+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";
@@ -145,20 +145,46 @@ export function isApplied(
 	);
 }
 
+const RESULT_PREVIEW_LINES = 16;
+
+function expandHint(): string {
+	try {
+		return keyHint("app.tools.expand", "to expand");
+	} catch {
+		return "ctrl+o to expand";
+	}
+}
+
+function extractSummary(text: string | undefined): string | undefined {
+	if (!text) return undefined;
+	if (text.includes("│")) return undefined;
+	const warningsIdx = text.indexOf("\n\nWarnings:");
+	const summary = warningsIdx >= 0 ? text.slice(0, warningsIdx) : text;
+	return summary.length > 0 ? summary : undefined;
+}
+
 export function buildAppliedText(
 	text: string | undefined,
 	details: ReplaceDetails | undefined,
 	theme: FgT,
+	expanded: boolean,
 ): string | undefined {
 	const sections: string[] = [];
-
+	const summary = extractSummary(text);
+	if (summary) sections.push(summary);
 	if (details?.diff) {
-		sections.push(fmtResult(details.diff, theme));
+		const diffLines = details.diff.split("\n");
+		const diffSection = expanded
+			? fmtResult(details.diff, theme)
+			: fmtPreview(details.diff, false, theme);
+		const hint =
+			!expanded && diffLines.length > RESULT_PREVIEW_LINES
+				? ` (${expandHint()})`
+				: "";
+		sections.push(`${diffSection}${hint}`);
 	}
-
 	const warnings = extractWarnings(text);
 	if (warnings) sections.push(warnings);
-
 	return sections.length > 0 ? sections.join("\n\n") : undefined;
 }
 
@@ -317,7 +343,7 @@ export function renderEditResult(
 			: new Text("", 0, 0);
 	}
 	if (isApplied(result.details)) {
-		const appliedText = buildAppliedText(renderedText, result.details, theme);
+		const appliedText = buildAppliedText(renderedText, result.details, theme, context.expanded === true);
 		return appliedText ? reuseText(context, appliedText) : new Text("", 0, 0);
 	}
 	if (!renderedText) return new Text("", 0, 0);

package/src/replace-response.ts

@@ -1,3 +1,4 @@
+import type { NEdit } from "./hashline";
 import type { ReplaceDetails } from "./replace";
 import { genDiff, genPatch } from "./replace-diff";
 import { visLines, clipLine } from "./utils";
@@ -27,14 +28,9 @@ export type RMeta = {
   removedLines: number;
 };
 
-type NEditEntry = {
-	loc: string;
-	currentContent: string;
-};
-
 export interface NoopInput {
 	path: string;
-	noopEdit: NEditEntry | undefined;
+	noopEdit: NEdit | undefined;
 	snapshotId?: string;
 	editMeta: RMeta;
 	warnings: string[] | undefined;
@@ -157,11 +153,13 @@ export function buildChanged(input: SuccessInput, verb = "replaced"): TResult {
     removedLines,
   });
 
+  const patchResult = genPatch(path, originalNormalized, result);
   return {
     content: [{ type: "text", text }],
     details: {
       diff: diffResult.diff,
-      patch: genPatch(path, originalNormalized, result),
+      patch: patchResult.patch,
+      ...(patchResult.truncated ? { patchTruncated: true as const } : {}),
       firstChangedLine:
         editMeta.firstChangedLine ?? diffResult.firstChangedLine,
       snapshotId,

package/src/replace-undo.ts

@@ -126,26 +126,15 @@ export function regUndo(pi: ExtensionAPI): void {
           if (errCode(error) !== "ENOENT") throw error;
         }
 
-        if (currentRaw === undefined) {
-          await clearUndo(mutationTargetPath);
-          return {
-            content: [
-              {
-                type: "text",
-                text: `[E_UNDO_STALE] Cannot undo last change on ${path}: the file no longer exists.`
-              },
-            ],
-            isError: true,
-            details: {},
-          };
-        }
-        if (currentRaw !== undo.bom + restoreEndings(undo.resultContent, undo.originalEnding)) {
-          await clearUndo(mutationTargetPath);
+        if (
+          currentRaw !== undefined &&
+          currentRaw !== undo.bom + restoreEndings(undo.resultContent, undo.originalEnding)
+        ) {
           return {
             content: [
               {
                 type: "text",
-                text: `[E_UNDO_STALE] Cannot undo last change on ${path}: the file changed after the edit. Call read() to inspect the current state.`
+                text: `[E_UNDO_STALE] Cannot undo last change on ${path}: the file changed after the edit. The undo record is kept; once the file matches the edited state again, undo_last_change will succeed. Call read() to inspect the current state.`
               },
             ],
             isError: true,
@@ -153,20 +142,19 @@ export function regUndo(pi: ExtensionAPI): void {
           };
         }
 
-        const { text: currentStripped } = stripBOM(currentRaw);
-        const currentNormalized = toLF(currentStripped);
+        await writeAtomic(
+          mutationTargetPath,
+          undo.bom + restoreEndings(undo.content, undo.originalEnding),
+        );
+
+        const currentNormalized = currentRaw === undefined ? "" : toLF(stripBOM(currentRaw).text);
         const currentHashes = await lineHashes(currentNormalized, mutationTargetPath);
-        const diffResult = genDiff(undo.content, currentNormalized, 0, undefined, undo.hashes);
+        const diffResult = genDiff(undo.content, undo.resultContent, 0, undefined, undo.hashes, { unlimited: true });
         const linesAddedByReplace = cntDiff(diffResult.diff, "+");
         const linesRemovedByReplace = cntDiff(diffResult.diff, "-");
         const restoredRange = changedRange(currentNormalized, undo.content);
         const undoDiff = genDiff(currentNormalized, undo.content, 1, undo.hashes, currentHashes).diff;
 
-        await writeAtomic(
-          mutationTargetPath,
-          undo.bom + restoreEndings(undo.content, undo.originalEnding),
-        );
-
         try {
           const store = await loadHashStore();
           upsertSnapshot(store, mutationTargetPath, contentChecksum(undo.content), splitLines(undo.content).length, undo.hashes);
@@ -180,6 +168,9 @@ export function regUndo(pi: ExtensionAPI): void {
         const parts: string[] = [
           `Undone last change on ${path}.`,
         ];
+        if (currentRaw === undefined) {
+          parts.push("The file was deleted; restored it from undo history.");
+        }
         if (linesAddedByReplace > 0 || linesRemovedByReplace > 0) {
           parts.push(
             `Removed ${linesAddedByReplace} line(s), restored ${linesRemovedByReplace} line(s).`,
@@ -189,6 +180,7 @@ export function regUndo(pi: ExtensionAPI): void {
           "Call read for fresh anchors.",
         );
 
+        const patchResult = genPatch(path, currentNormalized, undo.content);
         return {
           content: [
             {
@@ -198,7 +190,8 @@ export function regUndo(pi: ExtensionAPI): void {
           ],
           details: {
             diff: undoDiff,
-            patch: genPatch(path, currentNormalized, undo.content),
+            patch: patchResult.patch,
+            ...(patchResult.truncated ? { patchTruncated: true as const } : {}),
             metrics: buildMetrics({
               classification: "applied",
               editsAttempted: 1,

package/src/replace.ts

@@ -31,9 +31,8 @@ import {
   type RPreview,
   type RRState,
 } from "./replace-render";
-export { reuseText, reuseMarkdown } from "./replace-render";
 import { loadP, loadGuide } from "./prompts";
-import { loadHashStore, findSnapshotPaths, type HashStore } from "./hash-store";
+import { loadHashStore, findSnapshotPaths, findServedPaths, type HashStore } from "./hash-store";
 import { getServed, recordServedSafe } from "./served";
 import { noopPayloadKey, markBoundaryNoop, consumeBoundaryBypass, clearBoundaryBypass } from "./boundary-bypass";
 import { commitEdit } from "./commit";
@@ -50,11 +49,11 @@ const replacementLinesSchema = Type.Array(
 );
 
 const removeFromSchema = 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. Marks the FIRST line to remove (inclusive)",
+  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 HASH only (e.g. \"aB3\"): copy just the hash from the leftmost column of a read row like `aB3│content`; never the line content. Marks the LAST line to remove (inclusive)",
+  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(
@@ -76,6 +75,7 @@ export type ReqParams = {
 export type ReplaceDetails = {
   diff: string;
   patch?: string;
+  patchTruncated?: boolean;
   firstChangedLine?: number;
   snapshotId?: string;
   classification?: "noop";
@@ -149,7 +149,7 @@ async function resolveMissingPath(
   } catch {
     return undefined;
   }
-  const matches = findSnapshotPaths(store, hashes);
+  const matches = [...new Set([...findSnapshotPaths(store, hashes), ...findServedPaths(store, hashes)])];
   if (matches.length === 1) {
     return {
       path: matches[0]!,

package/src/served.ts

@@ -1,4 +1,4 @@
-import { loadHashStore, parseHashList, type HashStore } from "./hash-store";
+import { loadHashStore, parseStoredHashes, type HashStore } from "./hash-store";
 import { HASH_CLASS } from "./hashline/alphabet";
 
 const SERVED_DIFF_ROW_RE = new RegExp(`^[+ ](${HASH_CLASS})│`);
@@ -14,8 +14,7 @@ export function servedHashesFromDiff(diff: string): string[] {
 
 export function getServed(store: HashStore, path: string): Set<string> | undefined {
   const row = store.stmts.servedGet(path);
-  if (!row) return undefined;
-  const parsed = parseHashList(row.hashes as string, () => store.stmts.servedDelete(path));
+  const parsed = parseStoredHashes(row, () => store.stmts.servedDelete(path));
   if (!parsed) return undefined;
   return new Set(parsed);
 }

package/src/utils.ts

@@ -93,6 +93,19 @@ export function firstNonEmpty(lines: string[]): string | undefined {
 	return idx >= 0 ? lines[idx] : undefined;
 }
 
+export function truncateToBytes(s: string, maxBytes: number): string {
+	if (Buffer.byteLength(s, "utf-8") <= maxBytes) return s;
+	let out = "";
+	let bytes = 0;
+	for (const ch of s) {
+		const chBytes = Buffer.byteLength(ch, "utf-8");
+		if (bytes + chBytes > maxBytes) break;
+		out += ch;
+		bytes += chBytes;
+	}
+	return out;
+}
+
 export function clipLine(line: string, maxLen = 200): string {
 	const flat = line.replace(/\n/g, "\\n");
 	return flat.length > maxLen ? `${flat.slice(0, maxLen)}...` : flat;