@d3ara1n/pi-hashline-edit 0.3.4 → 0.4.1

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.1",
   "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, type DiffCounts } from "./render.ts";
 
 /** Cap on the number of updated anchors returned inline (bounds token cost for large inserts). */
 const MAX_ANCHOR_LINES = 40;
@@ -189,6 +190,16 @@ function formatUpdatedAnchors(newText: string, touched: readonly number[], hashL
 	return `\nUpdated anchors (use these for the next edit):\n${shown.join("\n")}${more}`;
 }
 
+/** Call-header line: `edit path — N ops: op`, plus `+N -N` once the result's diff counts are known. */
+function editHeader(args: Static<typeof editSchema>, theme: any, counts?: DiffCounts): string {
+	let t = theme.fg("toolTitle", theme.bold("edit "));
+	t += theme.fg("accent", args.path);
+	const n = args.edits?.length ?? 0;
+	if (n) t += theme.fg("dim", ` — ${n} op${n > 1 ? "s" : ""}: ${args.edits[0].op}`);
+	if (counts && (counts.added || counts.removed)) t += formatDiffCounts(counts, theme);
+	return t;
+}
+
 export function makeEditOverride(cwd: string) {
 	const builtin = createEditTool(cwd);
 
@@ -209,12 +220,14 @@ 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);
-			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);
+		renderCall(args: Static<typeof editSchema>, theme: any, context: any) {
+			const text = (context?.lastComponent as Text | undefined) ?? new Text("", 0, 0);
+			// Stash the header for renderResult: the diff counts land after
+			// execution and are refreshed in place (renderResult's lastComponent
+			// is the result component, not this header)
+			if (context?.state) context.state.callText = text;
+			text.setText(editHeader(args, theme, context?.state?.diffCounts));
+			return text;
 		},
 
 		renderResult(result: any, { isPartial, expanded }: any, theme: any, context: any) {
@@ -225,24 +238,20 @@ export function makeEditOverride(cwd: string) {
 				return new Text(theme.fg("error", t), 0, 0);
 			}
 			const diff: string | undefined = result.details?.diff;
+			// refresh the call header's +N -N in place — never invalidate from
+			// inside a renderer (re-enters updateDisplay, diff renders twice)
+			publishDiffCounts(diff, context, (counts) => {
+				context.state?.callText?.setText(editHeader(context.args, theme, counts));
+			});
 			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,48 @@ 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 refreshes the call header in place — no invalidate", 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 args = { path: "f.txt", edits: [{ op: "replace" as const }] };
+		let invalidated = false;
+		const context: any = { args, isError: false, state: {}, invalidate: () => { invalidated = true; } };
+		// first pass: renderCall builds the header; no counts exist yet
+		const header: any = edit.renderCall(args, stubTheme, context);
+		assert.ok(!header.text.includes("+3"), "pre-execution header must not show counts");
+		// result lands: renderResult refreshes the SAME component in place
+		edit.renderResult({ content: r.content, details: r.details }, { isPartial: false, expanded: true }, stubTheme, context);
+		assert.deepEqual(context.state.diffCounts, { added: 3, removed: 2 });
+		assert.ok(header.text.includes("+3"), "header should show added count");
+		assert.ok(header.text.includes("-2"), "header should show removed count");
+		// refreshing via context.invalidate() re-enters updateDisplay and renders
+		// the diff twice — the renderer must never call it
+		assert.ok(!invalidated, "renderResult must not call invalidate");
+		// later full passes (expand/collapse) re-run renderCall; counts survive in state
+		const header2: any = edit.renderCall(args, stubTheme, { args, state: context.state, lastComponent: header });
+		assert.equal(header2, header, "renderCall reuses the stashed component");
+		assert.ok(header2.text.includes("+3"), "re-render keeps the 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,74 @@ 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 refresh the
+ * call header component in place — pi's own edit-tool pattern (renderResult
+ * mutates the component stashed by renderCall; it never re-runs the renderer).
+ *
+ * `updateDisplay` runs renderCall before renderResult in every pass, so later
+ * passes (expand/collapse, result updates) rebuild the header from
+ * `state.diffCounts`; the in-place refresh covers the first result render,
+ * where renderCall ran before the counts existed. renderResult cannot find the
+ * header via `lastComponent` — there it is the *result* component — so
+ * renderCall stashes it (e.g. `state.callText`).
+ *
+ * MUST NOT call `context.invalidate()`: it re-enters `updateDisplay`
+ * synchronously (not re-entrant) and the outer pass then re-adds the result
+ * component after the nested one — the diff renders twice.
+ */
+export function publishDiffCounts(
+	diff: string | undefined,
+	context: any,
+	refreshHeader: (counts: DiffCounts) => void,
+): void {
+	if (!diff || !context?.state) return;
+	const counts = countDiffLines(diff);
+	const prev: DiffCounts | undefined = context.state.diffCounts;
+	context.state.diffCounts = counts;
+	if (!prev || prev.added !== counts.added || prev.removed !== counts.removed) refreshHeader(counts);
+}

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, type DiffCounts } from "./render.ts";
 
 /** Cap on updated-anchor lines returned inline (bounds token cost for large spans). */
 const MAX_ANCHOR_LINES = 40;
@@ -144,6 +145,17 @@ function show(s: string, n = 30): string {
 	return folded.length > n ? folded.slice(0, n) + "…" : folded;
 }
 
+/** Call-header line: `replace path — mode "find" → "replace"`, plus `+N -N` once the result's diff counts are known. */
+function replaceHeader(args: ReplaceParams, theme: any, counts?: DiffCounts): string {
+	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}` : "";
+	t += theme.fg("dim", ` — ${mode}${f} "${show(args.find)}" → "${show(args.replace)}"`);
+	if (counts && (counts.added || counts.removed)) t += formatDiffCounts(counts, theme);
+	return t;
+}
+
 export function makeReplaceTool(cwd: string) {
 	return {
 		name: "replace" as const,
@@ -162,13 +174,14 @@ 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);
-			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);
+		renderCall(args: ReplaceParams, theme: any, context: any) {
+			const text = (context?.lastComponent as Text | undefined) ?? new Text("", 0, 0);
+			// Stash the header for renderResult: the diff counts land after
+			// execution and are refreshed in place (renderResult's lastComponent
+			// is the result component, not this header)
+			if (context?.state) context.state.callText = text;
+			text.setText(replaceHeader(args, theme, context?.state?.diffCounts));
+			return text;
 		},
 
 		renderResult(result: any, { isPartial, expanded }: any, theme: any, context: any) {
@@ -179,24 +192,20 @@ export function makeReplaceTool(cwd: string) {
 				return new Text(theme.fg("error", t), 0, 0);
 			}
 			const diff: string | undefined = result.details?.diff;
+			// refresh the call header's +N -N in place — never invalidate from
+			// inside a renderer (re-enters updateDisplay, diff renders twice)
+			publishDiffCounts(diff, context, (counts) => {
+				context.state?.callText?.setText(replaceHeader(context.args, theme, counts));
+			});
 			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");
@@ -263,6 +268,25 @@ test("replace renderResult: renders the error line without throwing", async () =
 	});
 });
 
+test("replace header: renderResult refreshes the call header in place — no invalidate", async () => {
+	await withDir(async (dir) => {
+		const f = join(dir, "f.txt");
+		await writeFile(f, "a\nb\nc\n");
+		const tool = makeReplaceTool(dir);
+		const args = { path: "f.txt", find: "b", replace: "B1\nB2" };
+		const r: any = await call(tool, args);
+		let invalidated = false;
+		const context: any = { args, isError: false, state: {}, invalidate: () => { invalidated = true; } };
+		const header: any = tool.renderCall(args, stubTheme, context);
+		assert.ok(!header.text.includes("+2"), "pre-execution header must not show counts");
+		tool.renderResult({ content: r.content, details: r.details }, { isPartial: false, expanded: true }, stubTheme, context);
+		assert.deepEqual(context.state.diffCounts, { added: 2, removed: 1 });
+		assert.ok(header.text.includes("+2"), "header should show added count");
+		assert.ok(header.text.includes("-1"), "header should show removed count");
+		assert.ok(!invalidated, "renderResult must not call invalidate");
+	});
+});
+
 test("replace: refuses and leaves the file untouched when hashlineEdit is disabled", async () => {
 	await withDir(async (dir) => {
 		const f = join(dir, "f.txt");