pi-hashline-edit-pro 2.2.0 → 2.3.0

package/README.md

@@ -86,14 +86,15 @@ One edit per call, with `hash_bounds` and `new_content` at the top level:
 | 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; a trailing newline is the last line's ending, not an extra empty line. Use `""` to delete the range. |
+| `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. |
 
 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 duplicate unique lines adjacent to the range are stripped automatically — consecutive duplicates are stripped as a run, so re-including a whole unchanged block next to the range never duplicates it. `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 `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.
 - 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.
 
 ## Undo
 

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "type": "module",
-  "description": "Strict hashline read/replace tool for pi-coding-agent with hash-anchored edits (3-char, 62-symbol, perfect hashing)",
+  "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",
   "repository": {
     "type": "git",
@@ -16,7 +16,14 @@
     "extension",
     "hashline",
     "hash-anchored",
-    "strict"
+    "hash",
+    "anchors",
+    "read",
+    "replace",
+    "edit",
+    "undo",
+    "file-editing",
+    "stable"
   ],
   "license": "MIT",
   "files": [

package/prompts/replace-guidelines.md

@@ -2,5 +2,6 @@
 - `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`: when copying a line from read output, remove its HASH│ prefix and keep the leading whitespace exactly as shown.
-- `replace`: to add a blank line, end new_content with an explicit empty line (e.g. ending with \n\n).
+- `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.

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.
+- `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.

package/src/hash-store.ts

@@ -11,6 +11,7 @@ type SqlParams = (string | number)[];
 interface Prepared {
   get: (...params: SqlParams) => Record<string, unknown> | undefined;
   allPaths: (...params: SqlParams) => Record<string, unknown>[];
+  allHashes: (...params: SqlParams) => Record<string, unknown>[];
   deleteOne: (...params: SqlParams) => void;
   upsert: (...params: SqlParams) => void;
   undoUpsert: (...params: SqlParams) => void;
@@ -159,6 +160,7 @@ function buildStore(
   ).run(String(HASH_STORE_VERSION));
   const getStmt = db.prepare("SELECT hashes FROM snapshots WHERE path = ? AND checksum = ? AND line_count = ?");
   const allStmt = db.prepare("SELECT path FROM snapshots UNION SELECT path FROM undo");
+  const allHashesStmt = db.prepare("SELECT path, hashes FROM snapshots");
   const delStmt = db.prepare("DELETE FROM snapshots WHERE path = ?");
   const upsertStmt = db.prepare(
     "INSERT INTO snapshots (path, checksum, line_count, hashes, updated_at) VALUES (?, ?, ?, ?, ?) " +
@@ -175,6 +177,7 @@ function buildStore(
   const stmts: Prepared = {
     get: (...params) => getStmt.get(...params) as Record<string, unknown> | undefined,
     allPaths: (...params) => allStmt.all(...params) as Record<string, unknown>[],
+    allHashes: (...params) => allHashesStmt.all(...params) as Record<string, unknown>[],
     deleteOne: (...params) => { withBusyRetry(() => { delStmt.run(...params); }); },
     upsert: (...params) => { withBusyRetry(() => { upsertStmt.run(...params); }); },
     undoUpsert: (...params) => { withBusyRetry(() => { undoUpsertStmt.run(...params); }); },
@@ -459,3 +462,18 @@ export async function pruneMissing(store: HashStore): Promise<void> {
     }
   });
 }
+
+export function findSnapshotPaths(store: HashStore, hashes: string[]): string[] {
+  const rows = store.stmts.allHashes() as { path: string; hashes: string }[];
+  const matches: string[] = [];
+  for (const row of rows) {
+    try {
+      const parsed = JSON.parse(row.hashes) as unknown;
+      if (!isValidHashList(parsed)) continue;
+      if (hashes.every((h) => parsed.includes(h))) matches.push(row.path);
+    } catch {
+      continue;
+    }
+  }
+  return matches;
+}

package/src/hashline/parse.ts

@@ -45,7 +45,6 @@ export function parseText(edit: string): string[] {
   }
   const normalized = edit.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
   if (normalized === "") return [];
-  const lines = normalized.split("\n");
-  if (normalized.endsWith("\n")) lines.pop();
-  return lines;
+  if (/^\n+$/.test(normalized)) return new Array(normalized.length).fill("");
+  return normalized.split("\n");
 }

package/src/hashline/resolve.ts

@@ -315,22 +315,41 @@ function leadingDups(
 	return dups;
 }
 
+function sectionIsUnique(
+	canonLines: string[],
+	start: number,
+	length: number,
+): boolean {
+	let count = 0;
+	for (let i = 0; i + length <= canonLines.length; i++) {
+		let k = 0;
+		while (k < length && canonLines[i + k] === canonLines[start + k]) k++;
+		if (k < length) continue;
+		count++;
+		if (count > 1) return false;
+	}
+	return true;
+}
+
 function firstNewAfterDups(
 	contentLines: string[],
 	rangeLines: string[],
-	fileLines: string[],
+	canonLines: string[],
 	endLine: number,
-	fileCounts: Map<string, number>,
 ): BDup[] {
 	const firstNew = findNewEdge(contentLines, rangeLines, false);
 	if (!firstNew) return [];
+	const maxK = Math.min(contentLines.length - firstNew.index, canonLines.length - endLine);
+	let runLen = 0;
+	while (
+		runLen < maxK &&
+		canon(contentLines[firstNew.index + runLen]!) === canonLines[endLine + runLen]!
+	) {
+		runLen++;
+	}
+	if (runLen === 0 || !sectionIsUnique(canonLines, endLine, runLen)) return [];
 	const dups: BDup[] = [];
-	const maxK = Math.min(contentLines.length - firstNew.index, fileLines.length - endLine);
-	for (let k = 0; k < maxK; k++) {
-		const newLine = contentLines[firstNew.index + k]!;
-		const fileLine = fileLines[endLine + k]!;
-		if (canon(newLine) !== canon(fileLine)) break;
-		if ((fileCounts.get(canon(fileLine)) ?? 0) !== 1) break;
+	for (let k = 0; k < runLen; k++) {
 		dups.push({ kind: "first-new-after", replacementLineIndex: firstNew.index + k });
 	}
 	return dups;
@@ -339,19 +358,24 @@ function firstNewAfterDups(
 function lastNewBeforeDups(
 	contentLines: string[],
 	rangeLines: string[],
-	fileLines: string[],
+	canonLines: string[],
 	startLine: number,
-	fileCounts: Map<string, number>,
 ): BDup[] {
 	const lastNew = findNewEdge(contentLines, rangeLines, true);
 	if (!lastNew) return [];
-	const dups: BDup[] = [];
 	const maxK = Math.min(lastNew.index + 1, startLine - 1);
-	for (let k = 0; k < maxK; k++) {
-		const newLine = contentLines[lastNew.index - k]!;
-		const fileLine = fileLines[startLine - 2 - k]!;
-		if (canon(newLine) !== canon(fileLine)) break;
-		if ((fileCounts.get(canon(fileLine)) ?? 0) !== 1) break;
+	let runLen = 0;
+	while (
+		runLen < maxK &&
+		canon(contentLines[lastNew.index - runLen]!) === canonLines[startLine - 2 - runLen]!
+	) {
+		runLen++;
+	}
+	if (runLen === 0) return [];
+	const sectionStart = startLine - 1 - runLen;
+	if (!sectionIsUnique(canonLines, sectionStart, runLen)) return [];
+	const dups: BDup[] = [];
+	for (let k = 0; k < runLen; k++) {
 		dups.push({ kind: "last-new-before", replacementLineIndex: lastNew.index - k });
 	}
 	return dups;
@@ -436,12 +460,12 @@ export function valEdit(
 	}
 	const endLine = endResolved.line;
 	const rangeLines = fileLines.slice(startResolved.line - 1, endLine);
-	const fileCounts = canonCounts(fileLines);
+	const canonLines = fileLines.map((line) => canon(line));
 	boundaryDups.push(
 		...trailingDups(edit.content_lines, fileLines, endLine),
 		...leadingDups(edit.content_lines, fileLines, startResolved.line),
-		...firstNewAfterDups(edit.content_lines, rangeLines, fileLines, endLine, fileCounts),
-		...lastNewBeforeDups(edit.content_lines, rangeLines, fileLines, startResolved.line, fileCounts),
+		...firstNewAfterDups(edit.content_lines, rangeLines, canonLines, endLine),
+		...lastNewBeforeDups(edit.content_lines, rangeLines, canonLines, startResolved.line),
 	);
 
 	return {

package/src/replace.ts

@@ -18,6 +18,7 @@ import { resolveTarget, writeAtomic } from "./fs-write";
 import { applyEdit,
   lineHashes,
   resEdit,
+  parseHashRef,
   MAX_HASH_LINES,
   type HEdit,
   type NEdit,
@@ -43,11 +44,11 @@ import {
 } from "./replace-render";
 import { loadP, loadGuide } from "./prompts";
 import { saveUndo } from "./replace-undo";
-import { loadHashStore, type HashStore } from "./hash-store";
+import { loadHashStore, findSnapshotPaths, type HashStore } from "./hash-store";
 
 const newContentSchema = Type.String({
   description:
-    "Replacement content as a single string with \\n line separators; a trailing newline is the last line's ending, not an extra empty line. Use \"\" to delete the range."
+    "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."
 });
 
 const hashBoundsSchema = Type.Array(
@@ -61,7 +62,7 @@ const hashBoundsSchema = Type.Array(
 
 export const editToolSchema = Type.Object(
   {
-    path: Type.String({ description: "Path to edit" }),
+    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,
   },
@@ -122,6 +123,42 @@ export function assertReq(
   }
 }
 
+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 hashes: string[] = [];
+  for (const ref of bounds) {
+    if (typeof ref !== "string") return undefined;
+    try {
+      hashes.push(parseHashRef(ref).hash);
+    } catch {
+      return undefined;
+    }
+  }
+  let store: HashStore;
+  try {
+    store = await loadHashStore();
+  } catch {
+    return undefined;
+  }
+  const matches = findSnapshotPaths(store, hashes);
+  if (matches.length === 1) {
+    return {
+      path: matches[0]!,
+      warning: `[E_BAD_SHAPE] Autocorrected: missing "path" resolved to ${matches[0]} — the only file whose stored hashes contain both anchors.`,
+    };
+  }
+  if (matches.length > 1) {
+    throw new Error(
+      `[E_BAD_SHAPE] Edit request requires a non-empty "path" string; the anchors match multiple known files: ${matches.join(", ")}. Include the intended path.`,
+    );
+  }
+  return undefined;
+}
+
 export interface ExecPipelineOptions {
   accessMode?: number;
   signal?: AbortSignal;
@@ -405,6 +442,10 @@ export function buildToolDef(): ToolDef {
 
     async execute(_toolCallId, params, signal, _onUpdate, ctx) {
       const canonical = normReq(params);
+      const resolution = isRec(canonical) ? await resolveMissingPath(canonical) : undefined;
+      if (resolution && isRec(canonical)) {
+        canonical.path = resolution.path;
+      }
       assertReq(canonical);
 
       const normalizedParams = canonical;
@@ -434,6 +475,10 @@ export function buildToolDef(): ToolDef {
           { accessMode: constants.R_OK | constants.W_OK, signal },
         );
 
+        if (resolution) {
+          warnings.unshift(resolution.warning);
+        }
+
         const editsAttempted = 1;
         if (originalNormalized === result) {
           let noopSnapshotId: string | undefined;