@d3ara1n/pi-hashline-edit 0.4.0 → 0.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@d3ara1n/pi-hashline-edit",
-  "version": "0.4.0",
+  "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,7 +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";
+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;
@@ -190,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);
 
@@ -212,15 +222,11 @@ export function makeEditOverride(cwd: string) {
 
 		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) 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);
+			// 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;
 		},
 
@@ -232,7 +238,11 @@ export function makeEditOverride(cwd: string) {
 				return new Text(theme.fg("error", t), 0, 0);
 			}
 			const diff: string | undefined = result.details?.diff;
-			publishDiffCounts(diff, context);
+			// 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.

package/src/pi/execute.test.ts

@@ -253,7 +253,7 @@ test("edit success: renderResult renders the diff without throwing", async () =>
 	});
 });
 
-test("edit header: renderResult publishes diff counts, renderCall shows +N -N", async () => {
+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";
@@ -267,19 +267,24 @@ test("edit header: renderResult publishes diff counts, renderCall shows +N -N",
 				{ op: "insert_after", anchor: h(text, 5), body: ["f", "g"] },
 			],
 		});
-		const context: any = { isError: false, state: {}, invalidate: () => {} };
+		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 });
-		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");
+		// 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");
 	});
 });
 

package/src/pi/render.ts

@@ -75,15 +75,29 @@ export function formatDiffCounts(counts: DiffCounts, theme: any): string {
 }
 
 /**
- * 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).
+ * 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): void {
+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;
-	if (prev && prev.added === counts.added && prev.removed === counts.removed) return;
 	context.state.diffCounts = counts;
-	context.invalidate?.();
+	if (!prev || prev.added !== counts.added || prev.removed !== counts.removed) refreshHeader(counts);
 }

package/src/pi/replace-tool.ts

@@ -35,7 +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";
+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;
@@ -145,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,
@@ -165,16 +176,11 @@ export function makeReplaceTool(cwd: string) {
 
 		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}` : "";
-			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);
+			// 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;
 		},
 
@@ -186,7 +192,11 @@ export function makeReplaceTool(cwd: string) {
 				return new Text(theme.fg("error", t), 0, 0);
 			}
 			const diff: string | undefined = result.details?.diff;
-			publishDiffCounts(diff, context);
+			// 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.

package/src/pi/replace.test.ts

@@ -268,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");