pi-hashline-edit-pro 1.0.7 → 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
 
@@ -90,7 +90,7 @@ Exactly one edit per call, with `hash_range_inclusive` and `content_lines` at th
 | Field | Description |
 | --- | --- |
 | `hash_range_inclusive` | Pair of 3-char hashes from `read` output marking the first and last line of the range to replace (inclusive). |
-| `content_lines` | Replacement content, one string per line. Use `[]` to delete the range. |
+| `content_lines` | Replacement content, one string per line; entries must not contain line breaks. Use `[]` to delete the range. |
 
 Behavior:
 
@@ -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:
 
@@ -155,7 +157,7 @@ Settings live in `~/.config/pi-hashline-edit-pro/config.json`, created automatic
 
 | Code | Meaning |
 | --- | --- |
-| `[E_BAD_SHAPE]` | Request envelope or edit item has unknown, missing, or wrongly-typed fields. |
+| `[E_BAD_SHAPE]` | Request envelope or edit item has unknown, missing, or wrongly-typed fields, or a `content_lines` entry contains a line break. |
 | `[E_BAD_REF]` | An anchor in `hash_range_inclusive` is not a bare 3-char hash. |
 | `[E_STALE_ANCHOR]` | An anchor does not match any line in the current file; call `read` for fresh anchors. |
 | `[E_AMBIGUOUS_ANCHOR]` | An anchor matches multiple lines; call `read` for fresh anchors. |
@@ -183,7 +185,7 @@ The alphabet is sized for an LLM consumer: the model tokenizes rather than squin
 
 - **Stale anchors fail, per line.** A hash mismatch means that line's content changed since the last `read`. The error says so and, when only one anchor of a pair is stale, shows the current lines around the still-valid anchor so the range can be re-located without a full re-read. Mismatched anchors are never silently relocated to a "close enough" line — correctness over convenience.
 - **Autocorrection only when the intent is unambiguous**, and always visible: hash-prefix and diff-row stripping produce a warning; the boundary-duplication fix is silent because the duplicate never reaches the file. Literal content is never silently altered when the intent is ambiguous (numbered deletion rows and unified-diff lines are written verbatim).
-- **Byte-exact preservation.** UTF-8 BOMs, CRLF, LF, and CR-only line endings, file permissions, and trailing newlines survive edits and undo.
+- **Byte-exact preservation.** UTF-8 BOMs, CRLF, LF, and CR-only line endings, file permissions, and trailing newlines survive edits and undo; files with mixed line endings are normalized to a single line ending on edit.
 - **Atomic and ordered writes.** Files are written via temp-file-then-rename; symlink chains are resolved so the target is updated without replacing the symlink; hard-linked files are updated in place; concurrent edits to the same underlying file serialize through a per-target mutation queue.
 - **One edit per call.** The request shape stays `{path, hash_range_inclusive, content_lines}` from schema through validation to application; there is no batching dialect.
 

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.7",
+  "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/prompts/replace-guidelines.md

@@ -1,3 +1,4 @@
 - `replace`: hash_range_inclusive must use only anchors from the most recent read of the same file.
 - `replace`: content_lines is a native JSON array of strings — never a serialized JSON string. When copying a line from read output, remove its HASH│ prefix and keep the leading whitespace exactly as shown.
-- `replace`: minimize the replaced range — anchor only the lines that actually change; for insertions use a single-line range (e.g. the line after the insertion point) instead of a whole block, so fewer unchanged lines must be reproduced byte-exact.
+- `replace`: minimize the replaced range — anchor only the lines that actually change; for insertions use a single-line range (e.g. the line after the insertion point) instead of a whole block, so fewer unchanged lines must be reproduced byte-exact.
+- `replace`: content_lines entries are single lines — never embed a line break inside an entry; pass each line as its own array entry.

package/src/file-kind.ts

@@ -39,12 +39,6 @@ function isTextType(mimeType: string): boolean {
   return mimeType.startsWith("text/") || TEXT_TYPES.has(mimeType);
 }
 
-export type FKind =
-  | { kind: "directory" }
-  | { kind: "image"; mimeType: string }
-  | { kind: "text" }
-  | { kind: "binary"; description: string };
-
 export type LFile =
   | { kind: "directory" }
   | { kind: "image"; mimeType: string }
@@ -149,17 +143,3 @@ export async function loadFileKindAndText(
     await fileHandle.close();
   }
 }
-
-export async function classifyFileKind(filePath: string): Promise<FKind> {
-  const loaded = await loadFileKindAndText(filePath);
-  switch (loaded.kind) {
-    case "directory":
-      return loaded;
-    case "image":
-      return loaded;
-    case "binary":
-      return loaded;
-    case "text":
-      return { kind: "text" };
-  }
-}

package/src/fs-write.ts

@@ -9,8 +9,6 @@ import {
 	rm,
 	stat,
 	writeFile,
-	copyFile,
-	chmod,
 } from "fs/promises";
 import { dirname, join, parse, resolve, sep } from "path";
 import { errCode } from "./utils";
@@ -153,20 +151,6 @@ export async function writeAtomic(
     await rename(tempPath, targetPath);
     await syncDir(dir);
   } catch (error: unknown) {
-    if (errCode(error) === "EXDEV") {
-      try {
-        await copyFile(tempPath, targetPath);
-        if (existingStats) {
-          await chmod(targetPath, existingStats.mode & 0o7777);
-        }
-        await rm(tempPath, { force: true });
-        await syncDir(dir);
-        return;
-      } catch {
-        try { await rm(tempPath, { force: true }); } catch {}
-        throw error;
-      }
-    }
     if (process.platform === "win32" && errCode(error) === "EPERM") {
       try {
         await writeFile(targetPath, content, "utf-8");

package/src/hash-store.ts

@@ -324,10 +324,6 @@ export function upsertSnapshot(
   store.stmts.upsert(path, checksum, lineCount, JSON.stringify(hashes), Date.now());
 }
 
-export function deleteSnapshot(store: HashStore, path: string): void {
-  store.stmts.deleteOne(path);
-}
-
 export function upsertUndo(store: HashStore, path: string, entry: UndoRecord): void {
   store.stmts.undoUpsert(
     path,

package/src/hashline/parse.ts

@@ -46,5 +46,11 @@ export function parseText(edit: string[] | string | null): string[] {
   if (typeof edit === "string") {
     throw new Error(CONTENT_LINES_NOT_STRING_MSG);
   }
+  const lineBreakIndex = edit.findIndex((line) => /[\r\n]/.test(line));
+  if (lineBreakIndex >= 0) {
+    throw new Error(
+      `[E_BAD_SHAPE] "content_lines" entry at index ${lineBreakIndex} contains a \\r or \\n line break. Pass each line as its own array entry.`,
+    );
+  }
   return edit;
 }

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,

package/src/replace.ts

@@ -47,7 +47,7 @@ import { loadHashStore, type HashStore } from "./hash-store";
 
 const contentLinesSchema = Type.Array(Type.String(), {
   description:
-    "Replacement content, one string per line. Use [] to delete the range."
+    "Replacement content, one string per line; entries must not contain line breaks. Use [] to delete the range."
 });
 
 const hashRangeInclSchema = Type.Array(
@@ -78,7 +78,6 @@ export type ReplaceDetails = {
   firstChangedLine?: number;
   snapshotId?: string;
   classification?: "noop";
-  structureOutline?: string[];
   metrics?: RMetrics;
 };
 

package/src/validation.ts

@@ -35,8 +35,3 @@ export function valKind(file: LFile, path: string): asserts file is { kind: "tex
 	}
 }
 
-
-export function isText(file: LFile): file is { kind: "text"; text: string; hadUtf8DecodeErrors?: true } {
-	return file.kind === "text";
-}
-