@d3ara1n/pi-hashline-edit 0.3.4 → 0.4.0

package/README.md

@@ -24,6 +24,22 @@ Routine local code editing in pi — the common case. If you spend turns fightin
 
 Set `hashlineEdit.enabled = false` (or uninstall) to fall back to the built-in `read`/`edit`/`grep` when you need **remote or custom-storage files** — the overrides read/write/search the local filesystem directly, so pi's custom `ReadOperations`/`GrepOperations` (SSH, etc.) aren't supported. The same switch lets you opt out per-project. All four tools — `read`, `grep`, `edit`, `replace` — are one set governed by this switch: when disabled, `read`/`grep`/`edit` delegate to the built-ins and `replace` refuses (it has no built-in counterpart).
 
+## Model compatibility — field notes
+
+Real-world reliability depends on the model more than on anything else. Field observations from real sessions (June 2026, single environment — directional, not benchmarks; vendors iterate fast, re-test on new releases):
+
+| Model profile | Tested example | Built-in string-replace | hashline-edit | Recommendation |
+|---|---|---|---|---|
+| Weak tool-call construction | DeepSeek V4 Flash | ~50% of edits fail; each fix takes several more `edit` rounds | ~80% of edits fail, but each failure converges in **one** retry | Keep hashline on — fewer total round-trips despite the higher failure rate |
+| Strong, but not trained on hashline | Kimi K3 | Excellent | Frequent anchor mistakes | Turn the plugin off — the built-in `edit` serves this profile better |
+| Strong, follows the schema as given | GLM 5.2 | Occasional not-found / whitespace friction | 100% — the friction disappears | The intended pairing |
+
+What these numbers actually say:
+
+- **A high failure rate on weak models is not a hashline problem.** DeepSeek V4 Flash fails at ~50% even on plain string-replace — the root cause is misremembered file content, and no edit protocol fixes that. What changes is the *shape* of a failure: string-replace failures are divergent (the model retries from the same wrong memory, so fixes take multiple rounds), while hashline failures are convergent (a mismatched anchor returns the live content plus a ready-to-resend `LINE#HASH`, so one retry closes the loop without trusting the model's memory).
+- **Strong ≠ automatic win.** Hashline assumes anchor discipline — copy hashes verbatim from read output, never invent one. A model that hasn't internalized that will fabricate anchors no matter how capable it is. If a strong model keeps hitting anchor errors, the fastest fix is disabling the plugin, not more retries.
+- **Some errors are invisible to any edit protocol.** On weak models `insert_after` is sometimes misread as string-replace-style: the model copies the anchor line into `body` (observed on DeepSeek V4 Flash), the toolcall verifies and succeeds, and the line ends up duplicated in the file. Nothing at the tool layer can catch this — the anchor is valid; the model's *intent* was wrong, and no amount of prompt wording cures it (the schema description already forbids the copy). Capable models never needed the wording in the first place: GLM used `insert_after` correctly back when the tool description didn't explain the op at all. The mismatch lives in the model, not the tool.
+
 ## Gotchas (vs. the built-in `read`/`edit`)
 
 Once hashline overrides the built-ins, a few things behave differently:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@d3ara1n/pi-hashline-edit",
-  "version": "0.3.4",
+  "version": "0.4.0",
   "type": "module",
   "description": "Hashline-style file editing for pi — line-anchored edits verified by content hash, replacing oldText/newText matching",
   "keywords": [

package/src/pi/edit-tool.ts

@@ -28,6 +28,7 @@ import { splitLines } from "../core/lines.ts";
 import type { ApplyFailure, Edit } from "../core/types.ts";
 import { canonicalPath } from "./read-tool.ts";
 import { getState } from "./state.ts";
+import { formatDiffCounts, publishDiffCounts, renderDiffPreview } from "./render.ts";
 
 /** Cap on the number of updated anchors returned inline (bounds token cost for large inserts). */
 const MAX_ANCHOR_LINES = 40;
@@ -209,12 +210,18 @@ export function makeEditOverride(cwd: string) {
 		parameters: editSchema,
 		renderShell: "default" as const,
 
-		renderCall(args: Static<typeof editSchema>, theme: any) {
-			let text = theme.fg("toolTitle", theme.bold("edit "));
-			text += theme.fg("accent", args.path);
+		renderCall(args: Static<typeof editSchema>, theme: any, context: any) {
+			const text = (context?.lastComponent as Text | undefined) ?? new Text("", 0, 0);
+			let t = theme.fg("toolTitle", theme.bold("edit "));
+			t += theme.fg("accent", args.path);
 			const n = args.edits?.length ?? 0;
-			if (n) text += theme.fg("dim", ` — ${n} op${n > 1 ? "s" : ""}: ${args.edits[0].op}`);
-			return new Text(text, 0, 0);
+			if (n) t += theme.fg("dim", ` — ${n} op${n > 1 ? "s" : ""}: ${args.edits[0].op}`);
+			// diff counts land after execution: renderResult publishes them into
+			// context.state and invalidates the row, re-running this renderer
+			const counts = context?.state?.diffCounts;
+			if (counts && (counts.added || counts.removed)) t += formatDiffCounts(counts, theme);
+			text.setText(t);
+			return text;
 		},
 
 		renderResult(result: any, { isPartial, expanded }: any, theme: any, context: any) {
@@ -225,24 +232,16 @@ export function makeEditOverride(cwd: string) {
 				return new Text(theme.fg("error", t), 0, 0);
 			}
 			const diff: string | undefined = result.details?.diff;
+			publishDiffCounts(diff, context);
 			if (!diff) {
 				// No net diff (e.g. a successful but non-mutating edit): show only the summary
 				// line — content.text also carries `Updated anchors` (hashline) for the model.
 				const t = content?.type === "text" ? content.text.split("\n")[0] : "Edited";
 				return new Text(theme.fg("success", t), 0, 0);
 			}
-			// details.diff is pi-format (+N/-N/<space>N content); color by leading char
-			const allLines = diff.split("\n");
-			const shown = expanded ? allLines : allLines.slice(0, 24);
-			const body = shown
-				.map((line: string) => {
-					if (line.startsWith("+")) return theme.fg("success", line);
-					if (line.startsWith("-")) return theme.fg("error", line);
-					return theme.fg("dim", line);
-				})
-				.join("\n");
-			const more = !expanded && allLines.length > 24 ? `\n${theme.fg("dim", `… (${allLines.length - 24} more)`)}` : "";
-			return new Text(body + more, 0, 0);
+			// details.diff is pi-format (+N/-N/<space>N content); renderDiff handles
+			// semantic colors plus intra-line change highlighting
+			return new Text(renderDiffPreview(diff, expanded, theme), 0, 0);
 		},
 
 		async execute(toolCallId: string, params: Static<typeof editSchema>, signal: AbortSignal | undefined, onUpdate: any) {

package/src/pi/execute.test.ts

@@ -8,6 +8,7 @@ import assert from "node:assert/strict";
 import { mkdtemp, rm, readFile, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { initTheme } from "@earendil-works/pi-coding-agent";
 import { makeEditOverride } from "./edit-tool.ts";
 import { makeReadOverride } from "./read-tool.ts";
 import { computeLineHash } from "../core/hash.ts";
@@ -215,6 +216,10 @@ test("edit execute: delete op", async () => {
 
 const stubTheme = { fg: (_k: string, s: string) => s, bold: (s: string) => s };
 
+// renderResult delegates to pi's renderDiff, which reads the global TUI theme
+// singleton — initialize it once for this test process (watcher off by default).
+initTheme();
+
 test("edit success: details.diff is a string (not the generateDiffString object)", async () => {
 	await withDir(async (dir) => {
 		const f = join(dir, "f.txt");
@@ -241,13 +246,43 @@ test("edit success: renderResult renders the diff without throwing", async () =>
 			path: "f.txt",
 			edits: [{ op: "replace", anchor: h(text, 2), body: ["B"] }],
 		});
-		// @ts-ignore — drive the renderer with a stub theme
-		const comp: any = edit.renderResult({ content: r.content, details: r.details }, { isPartial: false, expanded: true }, stubTheme, { isError: r.isError ?? false });
+	// @ts-ignore — drive the renderer with a stub theme
+		const comp: any = edit.renderResult({ content: r.content, details: r.details }, { isPartial: false, expanded: true }, stubTheme, { isError: r.isError ?? false, state: {}, invalidate: () => {} });
 		assert.ok(typeof comp?.text === "string");
 		assert.ok(comp.text.includes("B"), "rendered diff should contain the new content");
 	});
 });
 
+test("edit header: renderResult publishes diff counts, renderCall shows +N -N", async () => {
+	await withDir(async (dir) => {
+		const f = join(dir, "f.txt");
+		const text = "a\nb\nc\nd\ne\n";
+		await writeFile(f, text);
+		await call(makeReadOverride(dir), { path: "f.txt" });
+		const edit = makeEditOverride(dir);
+		const r: any = await call(edit, {
+			path: "f.txt",
+			edits: [
+				{ op: "replace", anchor: h(text, 2), end: h(text, 3), body: ["B"] },
+				{ op: "insert_after", anchor: h(text, 5), body: ["f", "g"] },
+			],
+		});
+		const context: any = { isError: false, state: {}, invalidate: () => {} };
+		edit.renderResult({ content: r.content, details: r.details }, { isPartial: false, expanded: true }, stubTheme, context);
+		assert.deepEqual(context.state.diffCounts, { added: 3, removed: 2 });
+		const header: any = edit.renderCall(
+			{ path: "f.txt", edits: [{ op: "replace" }] },
+			stubTheme,
+			{ state: context.state },
+		);
+		assert.ok(header.text.includes("+3"), "header should show added count");
+		assert.ok(header.text.includes("-2"), "header should show removed count");
+		// without counts in state (streaming, pre-execution), no +N -N in the header
+		const plain: any = edit.renderCall({ path: "f.txt", edits: [{ op: "replace" }] }, stubTheme, { state: {} });
+		assert.ok(!plain.text.includes("+3"), "pre-execution header must not show counts");
+	});
+});
+
 test("edit error: renderResult renders the error line without throwing", async () => {
 	await withDir(async (dir) => {
 		await writeFile(join(dir, "f.txt"), "a\n");

package/src/pi/render.ts

@@ -1,5 +1,5 @@
 /**
- * Shared anchor-parsing helper for the hashline-aware tool renderers.
+ * Shared helpers for the hashline-aware tool renderers.
  *
  * The model-facing `content` text uses the `LINE#HASH│content` anchor format so
  * an anchor can be copied straight into an edit op. The user-facing TUI
@@ -9,6 +9,8 @@
  * @module pi-hashline-edit/pi
  */
 
+import { renderDiff } from "@earendil-works/pi-coding-agent";
+
 const HASHLINE_RE = /^(\d+)#[A-Za-z0-9]+│(.*)$/;
 
 export interface HashlineRow {
@@ -28,3 +30,60 @@ export function parseHashline(line: string): HashlineRow | null {
 	const m = line.match(HASHLINE_RE);
 	return m ? { lineNo: m[1], content: m[2] } : null;
 }
+
+/** Max diff lines shown when a result is rendered collapsed. */
+const MAX_COLLAPSED_DIFF_LINES = 24;
+
+/**
+ * Render a pi-format diff (`+N`/`-N`/` N` content) for the TUI, reusing pi's
+ * built-in renderer: semantic diff colors plus intra-line (word-level) change
+ * highlighting on single-line modifications. When not expanded, collapse to the
+ * first 24 rendered lines with an overflow marker — truncating after rendering
+ * keeps `-`/`+` pairs intact so the intra-line highlight never dangles.
+ */
+export function renderDiffPreview(diff: string, expanded: boolean, theme: any): string {
+	const rendered = renderDiff(diff);
+	if (expanded) return rendered;
+	const allLines = rendered.split("\n");
+	const more =
+		allLines.length > MAX_COLLAPSED_DIFF_LINES
+			? `\n${theme.fg("dim", `… (${allLines.length - MAX_COLLAPSED_DIFF_LINES} more)`)}`
+			: "";
+	return allLines.slice(0, MAX_COLLAPSED_DIFF_LINES).join("\n") + more;
+}
+
+/** Added/removed line counts of a pi-format diff string (`+N`/`-N` leading char). */
+export interface DiffCounts {
+	added: number;
+	removed: number;
+}
+
+/** Count added/removed lines in a pi-format diff (`+N content` / `-N content` / ` N content`). */
+export function countDiffLines(diff: string): DiffCounts {
+	let added = 0;
+	let removed = 0;
+	for (const line of diff.split("\n")) {
+		if (line.startsWith("+")) added++;
+		else if (line.startsWith("-")) removed++;
+	}
+	return { added, removed };
+}
+
+/** Format `+N -N` with the theme's diff colors for the tool call header. */
+export function formatDiffCounts(counts: DiffCounts, theme: any): string {
+	return ` ${theme.fg("toolDiffAdded", `+${counts.added}`)} ${theme.fg("toolDiffRemoved", `-${counts.removed}`)}`;
+}
+
+/**
+ * Stash per-call diff counts into the row-local render state and invalidate
+ * once so the call header re-renders with `+N -N`. Idempotent: skips the
+ * invalidate when the counts are unchanged (prevents a render loop).
+ */
+export function publishDiffCounts(diff: string | undefined, context: any): void {
+	if (!diff || !context?.state) return;
+	const counts = countDiffLines(diff);
+	const prev: DiffCounts | undefined = context.state.diffCounts;
+	if (prev && prev.added === counts.added && prev.removed === counts.removed) return;
+	context.state.diffCounts = counts;
+	context.invalidate?.();
+}

package/src/pi/replace-tool.ts

@@ -35,6 +35,7 @@ import { readFile, writeFile } from "node:fs/promises";
 import { hashFileLines, splitLines } from "../core/index.ts";
 import { getState } from "./state.ts";
 import { canonicalPath } from "./read-tool.ts";
+import { formatDiffCounts, publishDiffCounts, renderDiffPreview } from "./render.ts";
 
 /** Cap on updated-anchor lines returned inline (bounds token cost for large spans). */
 const MAX_ANCHOR_LINES = 40;
@@ -162,13 +163,19 @@ export function makeReplaceTool(cwd: string) {
 		parameters: replaceSchema,
 		renderShell: "default" as const,
 
-		renderCall(args: ReplaceParams, theme: any) {
-			let text = theme.fg("toolTitle", theme.bold("replace "));
-			text += theme.fg("accent", args.path);
+		renderCall(args: ReplaceParams, theme: any, context: any) {
+			const text = (context?.lastComponent as Text | undefined) ?? new Text("", 0, 0);
+			let t = theme.fg("toolTitle", theme.bold("replace "));
+			t += theme.fg("accent", args.path);
 			const mode = args.regex ? "regex" : "lit";
 			const f = args.flags ? `/${args.flags}` : "";
-			text += theme.fg("dim", ` — ${mode}${f} "${show(args.find)}" → "${show(args.replace)}"`);
-			return new Text(text, 0, 0);
+			t += theme.fg("dim", ` — ${mode}${f} "${show(args.find)}" → "${show(args.replace)}"`);
+			// diff counts land after execution: renderResult publishes them into
+			// context.state and invalidates the row, re-running this renderer
+			const counts = context?.state?.diffCounts;
+			if (counts && (counts.added || counts.removed)) t += formatDiffCounts(counts, theme);
+			text.setText(t);
+			return text;
 		},
 
 		renderResult(result: any, { isPartial, expanded }: any, theme: any, context: any) {
@@ -179,24 +186,16 @@ export function makeReplaceTool(cwd: string) {
 				return new Text(theme.fg("error", t), 0, 0);
 			}
 			const diff: string | undefined = result.details?.diff;
+			publishDiffCounts(diff, context);
 			if (!diff) {
 				// No net diff: show only the summary line — content.text also carries
 				// `Updated anchors` (hashline) for the model.
 				const t = content?.type === "text" ? content.text.split("\n")[0] : "Replaced";
 				return new Text(theme.fg("success", t), 0, 0);
 			}
-			// details.diff is pi-format (+N/-N/<space>N content); color by leading char
-			const allLines = diff.split("\n");
-			const shown = expanded ? allLines : allLines.slice(0, 24);
-			const body = shown
-				.map((line: string) => {
-					if (line.startsWith("+")) return theme.fg("success", line);
-					if (line.startsWith("-")) return theme.fg("error", line);
-					return theme.fg("dim", line);
-				})
-				.join("\n");
-			const more = !expanded && allLines.length > 24 ? `\n${theme.fg("dim", `… (${allLines.length - 24} more)`)}` : "";
-			return new Text(body + more, 0, 0);
+			// details.diff is pi-format (+N/-N/<space>N content); renderDiff handles
+			// semantic colors plus intra-line change highlighting
+			return new Text(renderDiffPreview(diff, expanded, theme), 0, 0);
 		},
 
 		async execute(toolCallId: string, params: ReplaceParams, signal: AbortSignal | undefined, onUpdate: any) {

package/src/pi/replace.test.ts

@@ -11,6 +11,7 @@ import assert from "node:assert/strict";
 import { mkdtemp, rm, readFile, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { initTheme } from "@earendil-works/pi-coding-agent";
 import { makeReplaceTool } from "./replace-tool.ts";
 import { makeEditOverride } from "./edit-tool.ts";
 import { getState } from "./state.ts";
@@ -35,6 +36,10 @@ function anchorLine(block: string, line: number) {
 
 const stubTheme = { fg: (_k: string, s: string) => s, bold: (s: string) => s };
 
+// renderResult delegates to pi's renderDiff, which reads the global TUI theme
+// singleton — initialize it once for this test process (watcher off by default).
+initTheme();
+
 test("replace literal: replaces all occurrences", async () => {
 	await withDir(async (dir) => {
 		const f = join(dir, "f.txt");
@@ -234,7 +239,7 @@ test("replace renderResult: renders the diff without throwing", async () => {
 			{ content: r.content, details: r.details },
 			{ isPartial: false, expanded: true },
 			stubTheme,
-			{ isError: r.isError ?? false },
+			{ isError: r.isError ?? false, state: {}, invalidate: () => {} },
 		);
 		assert.ok(typeof comp?.text === "string");
 		assert.ok(comp.text.includes("B"), "rendered diff should contain the new content");