pi-hashline-edit-pro 2.3.0 → 2.4.0

package/README.md

@@ -28,8 +28,9 @@ kQm│}
 ```json
 {
   "path": "src/main.ts",
-  "hash_bounds": ["szJ", "szJ"],
-  "new_content": "  console.log('hi');"
+  "remove_from": "szJ",
+  "remove_to": "szJ",
+  "replacement_text": "  console.log('hi');"
 }
 ```
 
@@ -73,25 +74,27 @@ Edge cases:
 
 The built-in `edit` tool is disabled. `replace` is the only edit path, and it takes the hash anchors from `read` output.
 
-One edit per call, with `hash_bounds` and `new_content` at the top level:
+One edit per call, with `remove_from`, `remove_to`, and `replacement_text` at the top level:
 
 ```json
 {
   "path": "src/main.ts",
-  "hash_bounds": ["szJ", "kQm"],
-  "new_content": "  console.log('hi');\n}"
+  "remove_from": "szJ",
+  "remove_to": "kQm",
+  "replacement_text": "  console.log('hi');\n}"
 }
 ```
 
 | Field | Description |
 | --- | --- |
-| `hash_bounds` | Pair of 3-char hashes from `read` output marking the first and last line of the range to replace (inclusive). |
-| `new_content` | Replacement content as a single string with `\n` line separators; every `\n` separates lines, so a trailing `\n` adds a final empty line — mirror the replaced range's lines exactly, blank lines included (a replacement that is only blank lines is written as one `\n` per blank line). Use `""` to delete the range. |
+| `remove_from` | 3-char hash from `read` output marking the FIRST line to remove (inclusive). |
+| `remove_to` | 3-char hash from `read` output marking the LAST line to remove (inclusive). |
+| `replacement_text` | Replacement text as a single string with `\n` line separators; every `\n` separates lines, so a trailing `\n` adds a final empty line — mirror the removed lines exactly, blank lines included (a replacement that is only blank lines is written as one `\n` per blank line). Use `""` to delete the range. |
 
 Notes:
 
 - The request is checked before any file I/O, so a bad request never touches the file.
-- Common copy-paste slips are fixed automatically and reported: a leftover `HASH│` prefix in `new_content` or `hash_bounds`, diff-preview rows pasted into the replacement, a reversed range, or a boundary line pasted twice. New lines that re-include a block adjacent to the range are stripped automatically when that block is unique in the file — the whole run is stripped as one unit (including repeated structural lines like `}`), so re-including an unchanged block next to the range never duplicates it. A missing `path` is resolved from the anchors when they uniquely identify a file in the hash store (reported as a warning); when the anchors match multiple known files the request is rejected with the candidate paths named. `file_path` works as an alias for `path` in all three tools.
+- Common copy-paste slips are fixed automatically and reported: a leftover `HASH│` prefix in `replacement_text` or `remove_from`/`remove_to`, diff-preview rows pasted into the replacement, a reversed range, or a boundary line pasted twice. New lines that re-include a block adjacent to the range are stripped automatically when that block is unique in the file — the whole run is stripped as one unit (including repeated structural lines like `}`), so re-including an unchanged block next to the range never duplicates it. A missing `path` is resolved from the anchors when they uniquely identify a file in the hash store (reported as a warning); when the anchors match multiple known files the request is rejected with the candidate paths named. `file_path` works as an alias for `path` in all three tools.
 - An edit that produces identical content reports `No changes made` and leaves the anchors alone.
 - After a successful edit you get the post-edit diff with fresh anchors, so you can keep editing without re-reading.
 - Do not issue multiple replace calls on the same file in one message; parallel edits split attention across the post-edit diffs and removed lines are easy to miss. Verify each diff before the next edit on that file.
@@ -150,12 +153,12 @@ A no-op replace never changes the file, so anchors remain valid. On first run af
 
 | Code | Meaning |
 | --- | --- |
-| `[E_BAD_SHAPE]` | Request envelope or edit item has unknown, missing, or wrongly-typed fields (for example `new_content` must be a string with `\n` line separators). |
-| `[E_BAD_REF]` | An anchor in `hash_bounds` is not a bare 3-char hash. |
+| `[E_BAD_SHAPE]` | Request envelope or edit item has unknown, missing, or wrongly-typed fields (for example `replacement_text` must be a string with `\n` line separators). |
+| `[E_BAD_REF]` | An anchor in `remove_from`/`remove_to` 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. |
-| `[E_INVALID_PATCH]` | A `new_content` line is a diff-preview row (`+HASH│`, `-HASH│`, `-   │`). The marker is stripped automatically with a warning. |
-| `[E_BARE_HASH_PREFIX]` | A `new_content` line starts with a hash-like `HASH│` prefix. The prefix is stripped automatically with a warning. |
+| `[E_INVALID_PATCH]` | A `replacement_text` line is a diff-preview row (`+HASH│`, `-HASH│`, `-   │`). The marker is stripped automatically with a warning. |
+| `[E_BARE_HASH_PREFIX]` | A `replacement_text` line starts with a hash-like `HASH│` prefix. The prefix is stripped automatically with a warning. |
 | `[E_BAD_OP]` | Range start line is after range end line. The pair is swapped automatically with a warning. |
 | `[E_WOULD_EMPTY]` | An edit would empty a non-empty file; use `write` instead. |
 | `[E_NOT_FOUND]` | The path does not exist. |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "type": "module",
   "description": "Hash-anchored read/replace/undo tools for pi-coding-agent. Every line gets a unique 3-char hash (A-Za-z0-9) that stays stable across edits; stale or ambiguous anchors are rejected, never fuzzy-matched. Undo persists across restarts.",
   "main": "index.ts",

package/prompts/replace-guidelines.md

@@ -1,7 +1,7 @@
-- `replace`: hash_bounds marks the exact lines that are REMOVED, and new_content is their complete replacement applied in order; nothing outside the range changes. Every line inside the range that is not reproduced byte-exact in new_content is deleted from the file — including closing braces and other structural lines.
-- `replace`: minimize the replaced range — anchor only the lines that actually change, so few unchanged lines must be reproduced byte-exact.
-- `replace`: to replace a single line, repeat its hash in both positions of hash_bounds: ["<HASH>", "<HASH>"] — never extend the range to neighboring lines for a one-line edit.
+- `replace`: remove_from and remove_to mark the exact lines that are REMOVED, and replacement_text is their complete replacement applied in order; nothing outside the range changes. Every line inside the range that is not reproduced byte-exact in replacement_text is deleted from the file.
+- `replace`: keep the range as tight as the change — anchor only the first and last line that actually change, never a whole function, class, or import block when only part of it changes.
+- `replace`: to replace a single line, set both remove_from and remove_to to the same hash: remove_from: "<HASH>", remove_to: "<HASH>".
 - `replace`: when copying a line from read output, remove its HASH│ prefix and keep the leading whitespace exactly as shown.
-- `replace`: every `\n` in new_content separates lines, so a trailing `\n` adds a final empty line. Mirror the replaced range's lines exactly: a range that ends on a blank line must end new_content with `\n` (e.g. `"code\n"`), and a replacement whose last line is not blank must not end with `\n`. To add a blank line after a line, end new_content with an explicit empty line after it (e.g. `"X\n"` adds a blank after X). A replacement that is only blank lines is written as one `\n` per blank line (e.g. `"\n"` is a single blank line).
-- `replace`: when auto-read shows the post-edit diff, its rows are the fresh anchors for the new file — `+HASH│` and ` HASH│` rows carry current hashes and unchanged lines keep their previous hashes, so you can anchor follow-up edits on the diff without re-reading. `-HASH│` rows show removed lines with their old hashes; those hashes are stale after the edit.
-- `replace`: do not issue multiple replace calls on the same file in one message — parallel edits on one file split attention across the diffs, and removed lines are easy to miss. Issue the next edit only after verifying the previous diff.
+- `replace`: every `\n` in replacement_text separates lines, so a trailing `\n` adds a final empty line. Mirror the removed lines exactly: a range that ends on a blank line must end replacement_text with `\n` (e.g. `"code\n"`), and a replacement whose last line is not blank must not end with `\n`. To add a blank line after a line, end replacement_text with an explicit empty line after it (e.g. `"X\n"` adds a blank after X). A replacement that is only blank lines is written as one `\n` per blank line.
+- `replace`: when auto-read shows the post-edit diff, its rows are the fresh anchors for the new file — `+HASH│` and ` HASH│` rows carry current hashes and unchanged lines keep their previous hashes, so you can anchor follow-up edits on the diff without re-reading.
+- `replace`: do not issue multiple replace calls on the same file in one message. Issue the next edit only after verifying the previous diff.

package/prompts/replace-snippet.md

@@ -1 +1 @@
-Replace lines in a text file via HASH anchors from read, performing one edit per tool call
+Replace lines in a text file via HASH anchors from read, anchoring exactly the lines that change; one edit per tool call

package/prompts/undo-last-replace-guidelines.md

@@ -1,2 +1,2 @@
 - `undo_last_replace`: reverts only the most recent replace on the file — any write to the file clears the undo history, so call it immediately after a bad replace. A replace is bad when its post-edit diff shows `-HASH│` rows for lines you meant to keep (a closing brace, import, or declaration).
-- `undo_last_replace`: when auto-read shows the post-edit diff, its `+HASH│` and ` HASH│` rows are the fresh anchors for the restored file, so follow-up edits can anchor on the diff without re-reading. `-HASH│` rows show removed lines with their old hashes; those hashes are stale after the undo.
+- `undo_last_replace`: when auto-read shows the post-edit diff, its `+HASH│` and ` HASH│` rows are the fresh anchors for the restored file, so follow-up edits can anchor on the diff without re-reading.

package/src/constants.ts

@@ -6,5 +6,5 @@ export const MAX_READ_LINE_BYTES = 200 * 1024;
 export const HASH_STORE_BUSY_TIMEOUT = 1000;
 export const HASH_STORE_VERSION = 5;
 export const NEW_CONTENT_NOT_STRING_MSG =
-  `[E_BAD_SHAPE] "new_content" must be a string with \\n line separators, not an array.`
+  `[E_BAD_SHAPE] "replacement_text" must be a string with \\n line separators, not an array.`
   + ` Do not pass an array of lines — pass the replacement text as one string: "line1\\nline2". Use "" to delete a range.`;

package/src/hashline/parse.ts

@@ -18,7 +18,7 @@ function diagRef(ref: string): string {
 	}
 
 	if (trimmed.includes("│")) {
-		return `[E_BAD_REF] Invalid anchor "${trimmed}". hash_bounds must contain the 3-char hash only — remove everything from "│" onward.`;
+		return `[E_BAD_REF] Invalid anchor "${trimmed}". remove_from and remove_to must contain the 3-char hash only — remove everything from "│" onward.`;
 	}
 
 	return `[E_BAD_REF] Invalid anchor "${trimmed}". Expected a 3-char alphanumeric anchor (e.g. "aB3").`;

package/src/hashline/resolve.ts

@@ -39,8 +39,9 @@ export interface NEdit {
 }
 
 export type HTEdit = {
-  new_content: string;
-  hash_bounds: [string, string];
+  replacement_text: string;
+  remove_from: string;
+  remove_to: string;
 };
 
 function resAnchorFromMap(
@@ -88,7 +89,7 @@ export function fmtMismatch(
   const refList = notFound.map((m) => `"${m.ref.hash}"`).join(", ");
   if (notFound.length > 0) {
     out.push(
-      `[E_STALE_ANCHOR] ${notFound.length} stale anchor${notFound.length > 1 ? "s" : ""}${filePath ? ` in ${filePath}` : ""}: ${refList}. The file content has changed since those anchors were read. Call read() to get fresh anchors, then copy the 3-char HASH of the start and end of the range you are replacing into hash_bounds of your next replace call.`
+      `[E_STALE_ANCHOR] ${notFound.length} stale anchor${notFound.length > 1 ? "s" : ""}${filePath ? ` in ${filePath}` : ""}: ${refList}. The file content has changed since those anchors were read. Call read() to get fresh anchors, then copy the 3-char HASH of the start and end of the range you are replacing into remove_from and remove_to of your next replace call.`
     );
     for (const m of notFound) {
       const ctx = m.context;
@@ -106,7 +107,7 @@ export function fmtMismatch(
   if (ambiguous.length > 0) {
     if (out.length > 0) out.push("");
     out.push(
-      `[E_AMBIGUOUS_ANCHOR] ${ambiguous.length} ambiguous anchor${ambiguous.length > 1 ? "s" : ""}${filePath ? ` in ${filePath}` : ""}. Call read() to get fresh anchors, then copy the 3-char HASH of the start and end of the range you are replacing into hash_bounds of your next replace call.`
+      `[E_AMBIGUOUS_ANCHOR] ${ambiguous.length} ambiguous anchor${ambiguous.length > 1 ? "s" : ""}${filePath ? ` in ${filePath}` : ""}. Call read() to get fresh anchors, then copy the 3-char HASH of the start and end of the range you are replacing into remove_from and remove_to of your next replace call.`
     );
     for (const m of ambiguous) {
       const sample = (m.candidates ?? []).slice(0, 5);
@@ -129,33 +130,30 @@ export function fmtMismatch(
   return out.join("\n");
 }
 
-const ITEM_KS = new Set(["new_content", "hash_bounds"]);
-
-function isStrPair(value: unknown): value is [string, string] {
-	return (
-		Array.isArray(value) &&
-		value.length === 2 &&
-		value.every((item) => typeof item === "string")
-	);
-}
+const ITEM_KS = new Set(["replacement_text", "remove_from", "remove_to"]);
 
 function assertItem(edit: Record<string, unknown>): void {
-  rejectUnknownFields(edit, ITEM_KS, "Edit", "The edit takes only { new_content, hash_bounds }.");
+  rejectUnknownFields(edit, ITEM_KS, "Edit", "The edit takes only { replacement_text, remove_from, remove_to }.");
 
-  if ("hash_bounds" in edit && !isStrPair(edit.hash_bounds)) {
+  if ("remove_from" in edit && typeof edit.remove_from !== "string") {
+    throw new Error(
+      `[E_BAD_SHAPE] Field "remove_from" must be an anchor string (3-char hash).`,
+    );
+  }
+  if ("remove_to" in edit && typeof edit.remove_to !== "string") {
     throw new Error(
-      `[E_BAD_SHAPE] Field "hash_bounds" must be a pair of anchor strings [start, end].`,
+      `[E_BAD_SHAPE] Field "remove_to" must be an anchor string (3-char hash).`,
     );
   }
-  if (!("new_content" in edit)) {
-    throw new Error(`[E_BAD_SHAPE] The edit requires a "new_content" field. Provide the replacement text (use "" to delete).`);
+  if (!("replacement_text" in edit)) {
+    throw new Error(`[E_BAD_SHAPE] The edit requires a "replacement_text" field. Provide the replacement text (use "" to delete).`);
   }
-  if (typeof edit.new_content !== "string") {
+  if (typeof edit.replacement_text !== "string") {
     throw new Error(NEW_CONTENT_NOT_STRING_MSG);
   }
-  if (!isStrPair(edit.hash_bounds)) {
+  if (typeof edit.remove_from !== "string" || typeof edit.remove_to !== "string") {
     throw new Error(
-      `[E_BAD_SHAPE] The edit requires a "hash_bounds" pair of anchor strings [start, end].`,
+      `[E_BAD_SHAPE] The edit requires "remove_from" and "remove_to" anchor strings (3-char hashes from read output).`,
     );
   }
 }
@@ -165,18 +163,18 @@ const ANCHOR_ROW_RE = new RegExp(`^([+-]?)(${HASH_CLASS})│`);
 export function resEdit(edit: HTEdit, warnings?: string[]): HEdit {
   assertItem(edit as Record<string, unknown>);
 
-  const replaceLines = parseText(edit.new_content);
-  const bounds = edit.hash_bounds.map((ref) => {
+  const replaceLines = parseText(edit.replacement_text);
+  const bounds = [edit.remove_from, edit.remove_to].map((ref) => {
     const trimmed = ref.trim();
     const match = trimmed.match(ANCHOR_ROW_RE);
     if (match) {
       let message: string;
       if (match[1] === "+") {
-        message = `[E_BAD_REF] Autocorrected: stripped diff-preview marker copied from the diff preview in hash_bounds entry "${trimmed}".`;
+        message = `[E_BAD_REF] Autocorrected: stripped diff-preview marker copied from the diff preview in remove_from/remove_to entry "${trimmed}".`;
       } else if (match[1] === "-") {
-        message = `[E_BAD_REF] Autocorrected: stripped leading "-" marker in hash_bounds entry "${trimmed}".`;
+        message = `[E_BAD_REF] Autocorrected: stripped leading "-" marker in remove_from/remove_to entry "${trimmed}".`;
       } else {
-        message = `[E_BAD_REF] Autocorrected: stripped "HASH│" prefix copied from read output in hash_bounds entry "${trimmed}".`;
+        message = `[E_BAD_REF] Autocorrected: stripped "HASH│" prefix copied from read output in remove_from/remove_to entry "${trimmed}".`;
       }
       warnings?.push(message);
       return match[2]!;
@@ -215,7 +213,7 @@ export function stripBarePrefixes(
 	});
 	if (stripped.length === 0) return edit;
 	const locations = stripped
-		.map((s) => `new_content line ${s.lineIndex + 1}`)
+		.map((s) => `replacement_text line ${s.lineIndex + 1}`)
 		.join(", ");
 	const matchedCount = stripped.filter((s) => s.matched).length;
 	const evidence =
@@ -251,7 +249,7 @@ export function stripDiffPrefixes(
 		return line;
 	});
 	if (stripped.length === 0) return edit;
-	const locations = stripped.map((i) => `new_content line ${i + 1}`).join(", ");
+	const locations = stripped.map((i) => `replacement_text line ${i + 1}`).join(", ");
 	warnings.push(
 		`[E_INVALID_PATCH] Autocorrected: stripped diff-preview marker copied from the diff preview in ${locations}.`
 	);
@@ -278,7 +276,7 @@ export function swapReversedRanges(
 		return edit;
 	}
 	warnings.push(
-		`[E_BAD_OP] Autocorrected: hash_bounds was reversed (start ${startRef.hash} is after end ${endRef.hash}); swapped the pair.`
+		`[E_BAD_OP] Autocorrected: remove_from and remove_to were reversed (remove_from ${startRef.hash} is after remove_to ${endRef.hash}); swapped the pair.`
 	);
 	return { ...edit, hash_bounds: [endRef, startRef] as [Anchor, Anchor] };
 }

package/src/replace-render.ts

@@ -32,14 +32,19 @@ export function getPreviewInput(
 		return null;
 	}
 
-	if (!Array.isArray(normalized.hash_bounds) || typeof normalized.new_content !== "string") {
+	if (
+		typeof normalized.remove_from !== "string" ||
+		typeof normalized.remove_to !== "string" ||
+		typeof normalized.replacement_text !== "string"
+	) {
 		return null;
 	}
 
 	const request: ReqParams = {
 		path: normalized.path,
-		hash_bounds: normalized.hash_bounds as [string, string],
-		new_content: normalized.new_content,
+		remove_from: normalized.remove_from,
+		remove_to: normalized.remove_to,
+		replacement_text: normalized.replacement_text,
 	};
 	return request;
 }

package/src/replace.ts

@@ -46,32 +46,33 @@ import { loadP, loadGuide } from "./prompts";
 import { saveUndo } from "./replace-undo";
 import { loadHashStore, findSnapshotPaths, type HashStore } from "./hash-store";
 
-const newContentSchema = Type.String({
+const replacementTextSchema = Type.String({
   description:
-    "Replacement content as a single string with \\n line separators; every \\n separates lines, so a trailing \\n adds a final empty line. Mirror the replaced range's lines exactly, blank lines included. A replacement that is only blank lines is written as one \\n per blank line. Use \"\" to delete the range."
+    "Replacement text as a single string with \\n line separators; every \\n separates lines, so a trailing \\n adds a final empty line. Mirror the removed lines exactly, blank lines included. A replacement that is only blank lines is written as one \\n per blank line. Use \"\" to delete the range."
 });
 
-const hashBoundsSchema = Type.Array(
-  Type.String({ description: "A 3-char HASH from read output" }),
-  {
-    description: "Pair of 3-char hashes from read output marking the first and last line of the range to replace (inclusive).",
-    minItems: 2,
-    maxItems: 2,
-  },
-);
+const removeFromSchema = Type.String({
+  description: "3-char HASH from read output marking the FIRST line to remove (inclusive)",
+});
+
+const removeToSchema = Type.String({
+  description: "3-char HASH from read output marking the LAST line to remove (inclusive)",
+});
 
 export const editToolSchema = Type.Object(
   {
     path: Type.Optional(Type.String({ description: "Path to edit. Required — always provide it explicitly; it is only auto-resolved from the anchors as a fallback when omitted by mistake." })),
-    hash_bounds: hashBoundsSchema,
-    new_content: newContentSchema,
+    remove_from: removeFromSchema,
+    remove_to: removeToSchema,
+    replacement_text: replacementTextSchema,
   },
   { additionalProperties: false },
 );
 export type ReqParams = {
   path: string;
-  hash_bounds: [string, string];
-  new_content: string;
+  remove_from: string;
+  remove_to: string;
+  replacement_text: string;
 };
 
 export type ReplaceDetails = {
@@ -101,7 +102,7 @@ interface PipelineResult {
 
 const PREVIEW_DEBOUNCE_MS = 150;
 
-const ROOT_KS = new Set(["path", "new_content", "hash_bounds"]);
+const ROOT_KS = new Set(["path", "remove_from", "remove_to", "replacement_text"]);
 
 export function assertReq(
   request: unknown,
@@ -116,9 +117,13 @@ export function assertReq(
     throw new Error('[E_BAD_SHAPE] Edit request requires a non-empty "path" string.');
   }
 
-  if (!Array.isArray(request.hash_bounds) || typeof request.new_content !== "string") {
+  if (
+    typeof request.remove_from !== "string" ||
+    typeof request.remove_to !== "string" ||
+    typeof request.replacement_text !== "string"
+  ) {
     throw new Error(
-      '[E_BAD_SHAPE] Edit request requires both "hash_bounds" and "new_content" at the top level.',
+      '[E_BAD_SHAPE] Edit request requires "remove_from", "remove_to", and "replacement_text" at the top level.',
     );
   }
 }
@@ -127,11 +132,11 @@ async function resolveMissingPath(
   request: Record<string, unknown>,
 ): Promise<{ path: string; warning: string } | undefined> {
   if (typeof request.path === "string") return undefined;
-  const bounds = request.hash_bounds;
-  if (!Array.isArray(bounds) || bounds.length !== 2) return undefined;
+  const from = request.remove_from;
+  const to = request.remove_to;
+  if (typeof from !== "string" || typeof to !== "string") return undefined;
   const hashes: string[] = [];
-  for (const ref of bounds) {
-    if (typeof ref !== "string") return undefined;
+  for (const ref of [from, to]) {
     try {
       hashes.push(parseHashRef(ref).hash);
     } catch {
@@ -215,8 +220,9 @@ export async function execPipeline(
   const editWarnings: string[] = [];
   const edit = resEdit(
     {
-      hash_bounds: params.hash_bounds,
-      new_content: params.new_content,
+      remove_from: params.remove_from,
+      remove_to: params.remove_to,
+      replacement_text: params.replacement_text,
     },
     editWarnings,
   );