pi-edit-file 0.3.0 → 0.3.1

package/README.md

@@ -156,7 +156,7 @@ function f() {
 
 ## Rendering
 
-The UI draws the change as a unified diff with word-level highlighting (`details.diff`). The transcript card shows that diff plus a compact `+adds / -removals · N hunks` line — the per-hunk report, the anchor caveats and the shorter-form tip are written for the model and are **not** drawn next to the diff (Nik, 2026-10-01: "только сам дифф"). The model-facing content stays a summary, because models that see raw diffs in tool output start imitating the diff format in their own patches (this happened, and is why the escaping and diff-style diagnostics above exist).
+The UI draws the change as a unified diff with word-level highlighting (`details.diff`). A diff too large for the card keeps **both ends** — the head, a dim `… (N diff lines omitted) …` marker, and the tail — and the `+adds / -removals` counts always describe the whole diff, never the excerpt (2026-10-08: a rewritten file rendered as a wall of `-` lines with `+0` in the header). The transcript card shows that diff plus a compact `+adds / -removals · N hunks` line — the per-hunk report, the anchor caveats and the shorter-form tip are written for the model and are **not** drawn next to the diff (Nik, 2026-10-01: "только сам дифф"). The model-facing content stays a summary, because models that see raw diffs in tool output start imitating the diff format in their own patches (this happened, and is why the escaping and diff-style diagnostics above exist).
 A failed call draws its **error text** instead: a patch rejection carries the whole diagnosis there, and rendering the empty result showed "+0 / -0 · 0 hunks", hiding the reason (2026-10-07).
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-edit-file",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Block-based atomic file editing for Pi agents: one flat patch string, precise match diagnostics, word-level diff rendering",
   "keywords": [
     "pi-package",

package/src/core.ts

@@ -1223,9 +1223,50 @@ export function sequentialDiffs(original: string[], resolved: ResolvedHunk[]): s
 	return diffs;
 }
 
-export function truncateDiff(diff: string, max = MAX_DIFF_CHARS): { text: string; truncated: boolean } {
-	if (diff.length <= max) return { text: diff, truncated: false };
-	return { text: diff.slice(0, max) + "\n… (diff truncated)", truncated: true };
+/** Trim a diff for the transcript, keeping BOTH ends. A whole-file rewrite is one
+ * block of removals followed by one block of additions, so cutting the head only
+ * showed a wall of "-" lines with nothing to see (2026-10-08: every big `write`
+ * rendered that way). The reported counts describe the FULL diff, never the
+ * excerpt — the card header used to read "+0 / -212" for a rewritten file. */
+export function truncateDiff(
+	diff: string,
+	max = MAX_DIFF_CHARS,
+): { text: string; truncated: boolean; omitted: number; additions: number; removals: number } {
+	const lines = diff.split("\n");
+	let additions = 0;
+	let removals = 0;
+	for (const line of lines) {
+		if (line.startsWith("+++") || line.startsWith("---")) continue;
+		if (line.startsWith("+")) additions++;
+		else if (line.startsWith("-")) removals++;
+	}
+	if (diff.length <= max) return { text: diff, truncated: false, omitted: 0, additions, removals };
+
+	const headBudget = Math.floor(max * 0.6);
+	const tailBudget = max - headBudget;
+	let headEnd = 0;
+	let used = 0;
+	while (headEnd < lines.length) {
+		const cost = lines[headEnd].length + 1;
+		if (used + cost > headBudget) break;
+		used += cost;
+		headEnd++;
+	}
+	let tailStart = lines.length;
+	used = 0;
+	while (tailStart > headEnd) {
+		const cost = lines[tailStart - 1].length + 1;
+		if (used + cost > tailBudget) break;
+		used += cost;
+		tailStart--;
+	}
+	const omitted = lines.length - headEnd - (lines.length - tailStart);
+	const text = [
+		...lines.slice(0, headEnd),
+		`… (${omitted} diff lines omitted) …`,
+		...lines.slice(tailStart),
+	].join("\n");
+	return { text, truncated: true, omitted, additions, removals };
 }
 
 export interface EditOutcome {
@@ -1481,7 +1522,11 @@ export function unifiedDiff(oldText: string, newText: string, filePath: string,
 // Unified-diff parsing + word-level diff (for syntax-highlighted diff rendering)
 // ---------------------------------------------------------------------------
 
-export type DiffLineKind = " " | "-" | "+";
+/** "gap" is the omission marker a truncated diff carries ("… (12 diff lines
+ * omitted) …"). It is a line kind of its own so the renderer draws it dim
+ * instead of dropping it: silently jumping from the head of the diff to its tail
+ * looks like a complete (and wrong) diff. */
+export type DiffLineKind = " " | "-" | "+" | "gap";
 
 export interface ParsedDiffLine {
 	kind: DiffLineKind;
@@ -1514,6 +1559,10 @@ export function parseUnifiedDiff(diffText: string): ParsedHunk[] {
 		}
 		if (current === undefined) continue;
 		if (line.startsWith("\\")) continue;
+		if (line.startsWith("… (")) {
+			current.lines.push({ kind: "gap", text: line });
+			continue;
+		}
 		const kind = line[0];
 		if (kind !== " " && kind !== "-" && kind !== "+") continue;
 		current.lines.push({ kind: kind as DiffLineKind, text: line.slice(1) });

package/src/extension.ts

@@ -240,14 +240,14 @@ export default function editFileExtension(pi: { registerTool: (t: unknown) => vo
 				const diffText = sequentialDiffs(file.lines, resolved)
 					.filter(Boolean)
 					.join("\n");
-				const { text: diff, truncated } = truncateDiff(diffText);
+				const { text: diff, truncated, additions, removals } = truncateDiff(diffText);
 
 				// No raw diff in model-facing content: models started mimicking the
 				// unified-diff format when writing patches (see pi-hermes-memory
 				// session 2026-09-25). The UI renders details.diff; the model gets
 				// the per-hunk summary only.
 				const text = `${summary}\nfile: ${params.path} — now ${updated.length} lines (was ${originalCount})`;
-				return { text, reports, reportLines, totalLines: updated.length, truncated, diff };
+				return { text, reports, reportLines, totalLines: updated.length, truncated, diff, additions, removals };
 			});
 
 			return {
@@ -259,6 +259,8 @@ export default function editFileExtension(pi: { registerTool: (t: unknown) => vo
 					totalLines: result.totalLines,
 					diff: result.diff,
 					diffTruncated: result.truncated,
+					diffAdditions: result.additions,
+					diffRemovals: result.removals,
 				},
 			};
 		},
@@ -290,16 +292,24 @@ export default function editFileExtension(pi: { registerTool: (t: unknown) => vo
 			}
 
 			const details = result?.details as
-				| { path?: string; hunks?: unknown[]; reportLines?: string[]; totalLines?: number; diff?: string; diffTruncated?: boolean }
+				| {
+						path?: string;
+						hunks?: unknown[];
+						reportLines?: string[];
+						totalLines?: number;
+						diff?: string;
+						diffTruncated?: boolean;
+						diffAdditions?: number;
+						diffRemovals?: number;
+				  }
 				| undefined;
 			const diff = details?.diff ?? "";
 			const diffLines = diff ? diff.split("\n") : [];
-			let additions = 0;
-			let removals = 0;
-			for (const line of diffLines) {
-				if (line.startsWith("+")) additions++;
-				if (line.startsWith("-")) removals++;
-			}
+			// The counts describe the FULL diff and arrive with the result; counting the
+			// rendered excerpt instead reported "+0" for a rewritten file (2026-10-08).
+			const counted = countDiffLines(diffLines);
+			const additions = details?.diffAdditions ?? counted.additions;
+			const removals = details?.diffRemovals ?? counted.removals;
 
 			const hunkCount = details?.hunks?.length ?? 0;
 			let text = theme.fg("success", `+${additions}`);
@@ -339,6 +349,19 @@ export default function editFileExtension(pi: { registerTool: (t: unknown) => vo
 	registerWriteDiff(pi);
 }
 
+/** Line counts of a rendered diff excerpt; the stored full-diff stats win when
+ * present (see truncateDiff). Kept here so both renderers agree. */
+function countDiffLines(lines: string[]): { additions: number; removals: number } {
+	let additions = 0;
+	let removals = 0;
+	for (const line of lines) {
+		if (line.startsWith("+++") || line.startsWith("---")) continue;
+		if (line.startsWith("+")) additions++;
+		else if (line.startsWith("-")) removals++;
+	}
+	return { additions, removals };
+}
+
 const WRITE_TOOL_NAME = "write";
 
 /** Old text of a file worth diffing: regular, text, within the size cap. */
@@ -389,11 +412,11 @@ function registerWriteDiff(pi: { registerTool: (t: unknown) => void }) {
 
 			const diffText = unifiedDiff(before, params.content, params.path);
 			if (!diffText) return result;
-			const { text: diff, truncated } = truncateDiff(diffText);
+			const { text: diff, truncated, additions, removals } = truncateDiff(diffText);
 
 			return {
 				...(result as Record<string, unknown>),
-				details: { path: absPath, diff, diffTruncated: truncated },
+				details: { path: absPath, diff, diffTruncated: truncated, diffAdditions: additions, diffRemovals: removals },
 			};
 		},
 
@@ -416,7 +439,9 @@ function registerWriteDiff(pi: { registerTool: (t: unknown) => void }) {
 		},
 
 		renderResult(result: any, options: { expanded: boolean; isPartial: boolean }, theme: any, context: any) {
-			const details = result?.details as { diff?: string; diffTruncated?: boolean } | undefined;
+			const details = result?.details as
+				| { diff?: string; diffTruncated?: boolean; diffAdditions?: number; diffRemovals?: number }
+				| undefined;
 			const diff = details?.diff ?? "";
 			if (!diff) {
 				// New file or no-op: keep pi's own result rendering (it clears the
@@ -431,13 +456,9 @@ function registerWriteDiff(pi: { registerTool: (t: unknown) => void }) {
 			}
 
 			const lines = diff.split("\n");
-			let additions = 0;
-			let removals = 0;
-			for (const line of lines) {
-				if (line.startsWith("+++") || line.startsWith("---")) continue;
-				if (line.startsWith("+")) additions++;
-				if (line.startsWith("-")) removals++;
-			}
+			const counted = countDiffLines(lines);
+			const additions = details?.diffAdditions ?? counted.additions;
+			const removals = details?.diffRemovals ?? counted.removals;
 
 			let text = theme.fg("success", `+${additions}`);
 			text += theme.fg("dim", " / ");
@@ -527,6 +548,14 @@ function renderDiffBody(diffText: string, absPath: string | undefined, theme: an
 		let i = 0;
 
 		while (i < lines.length) {
+			if (lines[i].kind === "gap") {
+				// The marker a truncated diff carries; without this branch the tail of
+				// the diff would sit right under its head, looking like one diff (2026-10-08).
+				out.push(theme.fg("dim", lines[i].text));
+				i++;
+				continue;
+			}
+
 			if (lines[i].kind === " ") {
 				out.push(` ${newLine(lines[i].text, b)}`);
 				b++;