pi-hashline-edit-pro 1.0.8 → 1.1.0

package/README.md

@@ -11,7 +11,7 @@ Fork of [pi-hashline-edit](https://github.com/RimuruW/pi-hashline-edit) by Rimur
 - **Stable anchors.** Editing one part of a file leaves the hashes of untouched lines unchanged, so anchors from earlier reads stay valid.
 - **Autocorrection with warnings.** Unambiguous copy-paste mistakes — hash prefixes, diff-preview rows, reversed ranges — are fixed automatically and reported.
 - **Safe writes.** Atomic temp-file-then-rename writes preserve permissions, BOMs, line endings, symlinks, and hard links.
-- **Auto-read.** Fresh anchors are appended to the result of every `write`, `replace`, and `undo_last_replace`.
+- **Auto-read.** Fresh anchors are appended to the result of every `write` that changes the file; after `replace` and `undo_last_replace`, the post-edit diff is shown instead.
 
 ## Installation
 
@@ -47,7 +47,7 @@ kQm│}
 }
 ```
 
-3. Keep editing. Anchors for untouched lines remain valid across edits, so hashes from earlier reads keep working; changed lines get fresh anchors, which auto-read appends to each result.
+3. Keep editing. Anchors for untouched lines remain valid across edits, so hashes from earlier reads keep working; changed lines get fresh anchors, which auto-read appends after each `write`.
 
 ## The `read` tool
 
@@ -102,7 +102,7 @@ Behavior:
   - A reversed range (start hash after end hash) is swapped and applied.
   - A duplicated boundary line — the classic `}`, `});`, or `} else {` pasted twice — is silently removed; the duplicate never reaches the file.
   - `file_path` is accepted as an alias for `path`; a JSON-string `content_lines` is parsed into an array.
-- **Response.** A successful edit reports `Successfully replaced in {path}. Added X line(s), removed Y line(s).` plus any warnings. An edit that produces identical content reports `No changes made` and never rotates anchors. The post-edit diff is exposed to the host UI via `details.diff` only — it is intentionally not part of the model-visible text.
+- **Response.** With auto-read enabled (the default), a successful edit returns the post-edit diff — the same `+HASH│` / `-   │` / ` HASH│` rows the user sees — instead of the summary. With auto-read disabled, the edit reports `Successfully replaced in {path}. Added X line(s), removed Y line(s).` plus any warnings, and no diff is shown to the model. Warnings are appended in both modes. An edit that produces identical content reports `No changes made` and never rotates anchors. The post-edit diff is exposed to the host UI via `details.diff` — the TUI always shows it — and reaches the model-visible text only while auto-read is on.
 - **Undo.** Every successful replace is undoable once via `undo_last_replace` — see [Undo](#undo).
 
 ## Anchor stability
@@ -118,13 +118,15 @@ A no-op replace never changes the file, so anchors remain valid. On first run af
 
 ## Auto-read
 
-Enabled by default. After a successful `write`, `replace`, or `undo_last_replace`, the extension reads the file and appends an `--- Auto-read (hashline anchors) ---` block to the result, so the model gets immediate `HASH│content` anchors without a separate `read` call.
+Enabled by default. After a successful `write` that changes the file, the extension reads the file and appends an `--- Auto-read (hashline anchors) ---` block to the result, so the model gets immediate `HASH│content` anchors without a separate `read` call.
 
-- After `replace` / `undo_last_replace`, the block covers the changed span plus 2 lines of context above and below — the rest of the file keeps its anchors from the persistent store.
+- A no-op `replace` produces no diff — the file is unchanged, so existing anchors remain valid.
+- After `replace` / `undo_last_replace`, the success summary is replaced by the post-edit diff (the same `+HASH│` / `-   │` / ` HASH│` rows used for replace) plus any warnings, so the model sees the change like a git diff instead of line counts; no anchor block is appended — call `read` for fresh anchors.
+- With auto-read disabled, `replace` / `undo_last_replace` results keep the plain summary in the model-visible text — no diff and no anchor block reach the model (the post-edit diff is still shown to the user).
 - After `write`, the block dumps from the top of the file. For files over 2000 lines, the dump is truncated with a pagination hint — use `read` with `offset` to continue.
 - Auto-read keeps a 50KB display budget: lines over 50KB are skipped with a marker instead of their content (use `read` for lines up to 200KB).
 - Toggle at runtime with `/toggle-auto-read`; the setting persists across sessions.
-- If the auto-read itself fails (e.g. the file was deleted between the operation and the read), a short `--- Auto-read failed: ... ---` notice is appended instead of the anchor block, so the model knows the anchors are missing.
+- If the auto-read itself fails (e.g. the file was deleted between the write and the read), a short `--- Auto-read failed: ... ---` notice is appended instead of the anchor block, so the model knows the anchors are missing.
 
 ## Undo
 
@@ -134,14 +136,14 @@ Enabled by default. After a successful `write`, `replace`, or `undo_last_replace
 - History is persisted in the hash store (`~/.config/pi-hashline-edit-pro/hash-store.sqlite`) and survives session restarts; a failed `write` does not clear it.
 - **Undo is a precondition, not a convenience.** The undo record is persisted *before* the edit is written; if it cannot be persisted, the `replace` is refused with `[E_UNDO_UNAVAILABLE]` and the file is not touched, so every applied edit is undoable. If the file write itself then fails, the previous undo record is restored, so a refused edit never destroys earlier undo history.
 - A successful `write` clears the history for that file.
-- Call `read` after an undo to get fresh anchors for follow-up edits.
+- With auto-read enabled, the model sees the post-edit diff after an undo, just like a replace; with auto-read disabled it sees the plain summary. No anchors are appended after an undo — call `read` to get fresh anchors for follow-up edits.
 - **Safety guard.** If the file was modified or deleted since the last replace, `undo_last_replace` refuses with `[E_UNDO_STALE]` rather than overwriting those changes.
 
 ## Commands and configuration
 
 | Command | Description |
 | --- | --- |
-| `/toggle-auto-read` | Toggle automatic hashline anchors after write and replace operations. Persists across sessions. |
+| `/toggle-auto-read` | Toggle automatic hashline anchors after write and post-edit diffs after replace and undo_last_replace operations. Persists across sessions. |
 
 Settings live in `~/.config/pi-hashline-edit-pro/config.json`, created automatically when a setting is toggled:
 

package/index.ts

@@ -5,7 +5,7 @@ import { regReplace } from "./src/replace";
 import { regReplaceUndo, clearUndo } from "./src/replace-undo";
 import { regRead, fmtReadPreview } from "./src/read";
 import type { RMetrics } from "./src/replace-response";
-import { AUTO_READ_MAX } from "./src/constants";
+import { extractWarnings } from "./src/replace-render";
 import { MAX_HASH_LINES } from "./src/hashline";
 import {
   readConfig,
@@ -17,7 +17,7 @@ import { toCwd } from "./src/paths";
 import { resolveTarget } from "./src/fs-write";
 
 export default function (pi: ExtensionAPI): void {
-  regRead(pi, { autoRead: true });
+  regRead(pi);
 
   regReplace(pi);
   regReplaceUndo(pi);
@@ -37,25 +37,23 @@ export default function (pi: ExtensionAPI): void {
     }
     const config = await readConfig();
     autoRead = config.autoRead;
-    regRead(pi, { autoRead });
-
     if (debugValue === "1" || debugValue === "true") {
       ctx.ui.notify(`Hashline Edit mode active`, "info");
     }
   });
 
   pi.registerCommand("toggle-auto-read", {
-    description: "Toggle automatic hashline anchors after write and replace operations",
+    description: "Toggle automatic hashline anchors after write and post-edit diffs after replace and undo_last_replace operations",
     handler: async (_args, ctx) => {
       autoRead = await toggleAutoRead();
-      regRead(pi, { autoRead });
       const state = autoRead ? "enabled" : "disabled";
-      ctx.ui.notify(`Auto-read after write/replace: ${state}`, "info");
+      ctx.ui.notify(`Auto-read anchors (write) and post-edit diffs (replace/undo): ${state}`, "info");
     },
   });
 
   pi.on("tool_result", async (event, ctx) => {
     if (event.isError) return;
+
     if (event.toolName === "write") {
       const writtenPath = (event.input as Record<string, unknown>)?.path;
       if (typeof writtenPath === "string") {
@@ -65,58 +63,64 @@ export default function (pi: ExtensionAPI): void {
           console.error("Failed to clear undo after write:", error);
         }
       }
+      if (!autoRead) return;
+      if (typeof writtenPath !== "string") return;
+      try {
+        const { normalized, fileHashes, absolutePath } = await readNormFile(
+          writtenPath, ctx.cwd, { maxLines: MAX_HASH_LINES },
+        );
+        const preview = await fmtReadPreview(
+          normalized,
+          {},
+          fileHashes,
+          absolutePath,
+          DEFAULT_MAX_BYTES,
+        );
+        return {
+          content: [
+            ...(event.content ?? []),
+            { type: "text", text: `\n\n--- Auto-read (hashline anchors) ---\n${preview.text}` },
+          ],
+        };
+      } catch (error) {
+        console.error("Auto-read after write failed:", error);
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [
+            ...(event.content ?? []),
+            { type: "text", text: `\n\n--- Auto-read failed: ${message} ---` },
+          ],
+        };
+      }
     }
-    if (!autoRead) return;
+
     if (
-      event.toolName !== "write" &&
       event.toolName !== "replace" &&
       event.toolName !== "undo_last_replace"
     ) return;
-    const filePath = (event.input as Record<string, unknown>)?.path;
-    if (typeof filePath !== "string") return;
+    if (!autoRead) return;
 
     const metrics = (event.details as { metrics?: RMetrics } | undefined)?.metrics;
-    if (event.toolName !== "write" && metrics?.classification === "noop") return;
+    if (metrics?.classification === "noop") return;
 
-    try {
-      const { normalized, fileHashes, absolutePath } = await readNormFile(
-        filePath, ctx.cwd, { maxLines: MAX_HASH_LINES },
-      );
-
-      const changedLines =
-        event.toolName === "replace" || event.toolName === "undo_last_replace"
-          ? metrics?.changed_lines
-          : undefined;
-      let offset: number | undefined;
-      let limit = AUTO_READ_MAX;
-      if (changedLines) {
-        offset = Math.max(1, changedLines.first - 2);
-        limit = Math.min(changedLines.last + 2 - offset + 1, AUTO_READ_MAX);
-      }
+    const diff = (event.details as { diff?: string } | undefined)?.diff;
+    if (!diff) return;
 
-      const preview = await fmtReadPreview(
-        normalized,
-        { offset, limit },
-        fileHashes,
-        absolutePath,
-        DEFAULT_MAX_BYTES,
-      );
-
-      return {
-        content: [
-          ...(event.content ?? []),
-          { type: "text", text: `\n\n--- Auto-read (hashline anchors) ---\n${preview.text}` },
-        ],
-      };
-    } catch (error) {
-      console.error("Auto-read after write/replace failed:", error);
-      const message = error instanceof Error ? error.message : String(error);
-      return {
-        content: [
-          ...(event.content ?? []),
-          { type: "text", text: `\n\n--- Auto-read failed: ${message} ---` },
-        ],
-      };
-    }
+    const rendered = (event.content ?? [])
+      .filter(
+        (entry): entry is { type: "text"; text: string } =>
+          entry.type === "text" && typeof entry.text === "string",
+      )
+      .map((entry) => entry.text)
+      .join("\n");
+    const warnings = extractWarnings(rendered);
+    return {
+      content: [
+        {
+          type: "text",
+          text: warnings ? `${diff}\n\n${warnings}` : diff,
+        },
+      ],
+    };
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "1.0.8",
+  "version": "1.1.0",
   "type": "module",
   "description": "Strict hashline read/replace tool for pi-coding-agent with hash-anchored edits (3-char, 62-symbol, perfect hashing)",
   "main": "index.ts",

package/prompts/read-guidelines.md

@@ -1,2 +1,2 @@
 - `read`: call before `replace` when you need fresh HASH anchors for a file.
-{{AUTO_READ_NOTE}}
+- `read`: call again after any edit to that file — changed lines get new anchors.

package/src/read.ts

@@ -21,11 +21,8 @@ const R_DESC = loadP("../prompts/read.md");
 
 const R_SNIPPET = loadP("../prompts/read-snippet.md");
 
-function readGuide(autoRead: boolean): string[] {
-	const note = "- `read`: call again after any edit to that file — changed lines get new anchors.";
-	return loadGuide("../prompts/read-guidelines.md", {
-		AUTO_READ_NOTE: autoRead ? "" : note,
-	});
+function readGuide(): string[] {
+	return loadGuide("../prompts/read-guidelines.md");
 }
 
 function normPosInt(
@@ -148,13 +145,13 @@ export async function fmtReadPreview(
 	};
 }
 
-export function regRead(pi: ExtensionAPI, opts?: { autoRead?: boolean }): void {
+export function regRead(pi: ExtensionAPI): void {
 	pi.registerTool({
 		name: "read",
 		label: "Read",
 		description: R_DESC,
 		promptSnippet: R_SNIPPET,
-		promptGuidelines: readGuide(opts?.autoRead ?? true),
+		promptGuidelines: readGuide(),
 		parameters: Type.Object({
 			path: Type.String({
 				description: "Path to the file to read (relative or absolute)",

package/src/replace-response.ts

@@ -126,7 +126,7 @@ export function buildChanged(input: SuccessInput): TResult {
   const { path, result, warnings, snapshotId, originalNormalized, editMeta, resultHashes } = input;
 
   const resultLines = visLines(result);
-  const diffResult = genDiff(originalNormalized, result, 2, resultHashes);
+  const diffResult = genDiff(originalNormalized, result, 1, resultHashes);
   const addedLines = editMeta.addedLines;
   const removedLines = editMeta.removedLines;
   const warningsBlock = warnBlock(warnings);

package/src/replace-undo.ts

@@ -157,6 +157,7 @@ export function regReplaceUndo(pi: ExtensionAPI): void {
         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).diff;
 
         await writeAtomic(
           mutationTargetPath,
@@ -192,6 +193,7 @@ export function regReplaceUndo(pi: ExtensionAPI): void {
             },
           ],
           details: {
+            diff: undoDiff,
             metrics: buildMetrics({
               classification: "applied",
               editsAttempted: 1,