pi-hashline-edit-pro 3.0.3 → 3.0.4

package/README.md

@@ -99,8 +99,8 @@ One edit per call, with `remove_from`, `remove_to`, and `replacement_lines` at t
 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 `anchor│` prefix (including a truncated or expanded prefix of up to 6 characters, e.g. `L3│` or `ab12│`) in `replacement_lines` 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 identify known files in the hash store (reported as a warning); when the anchors match multiple known files the most recently touched file is picked, with the candidates named. `file_path` works as an alias for `path` in all five tools.
-- An edit that produces identical content reports `No changes made` and leaves the anchors alone. When such a noop happened because a boundary anti-duplication cut removed lines from the replacement (the cut blocked a line that duplicates the block next to the range from being added), the same replacement sent once more runs with the edge anti-duplication turned off for that single call and is applied literally. The duplicated lines are kept, and the result carries a `[E_BOUNDARY_BYPASS]` notice. The pending bypass is per file and keyed to that payload; copied `anchor│` prefixes, diff markers, and stray whitespace in the resend are normalized before matching, so a copy-paste resend still hits it. Any applied edit clears it, and a successful `write` also clears it.
+- Common copy-paste slips are fixed automatically and reported: a leftover `anchor│` prefix (including a truncated or expanded prefix of up to 6 characters, e.g. `L3│` or `ab12│`) in `replacement_lines` 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 identify known files in the hash store (reported as a warning); when the anchors match multiple known files the most recently touched file is picked, with up to 3 candidate paths named. `file_path` works as an alias for `path` in all five tools, and `replace_from`/`replace_to` work as aliases for `remove_from`/`remove_to` in `replace`.
+- An edit that produces identical content reports `No changes made` and leaves the anchors alone. When such a noop happened because a boundary anti-duplication cut removed lines from the replacement (the cut blocked a line that duplicates the block next to the range from being added), the same replacement sent once more runs with the edge anti-duplication turned off for that single call and is applied literally. The duplicated lines are kept, and the result carries a `[W_BOUNDARY_BYPASS]` notice. The pending bypass is per file and keyed to that payload; copied `anchor│` prefixes, diff markers, and stray whitespace in the resend are normalized before matching, so a copy-paste resend still hits it. Any applied edit clears it, and a successful `write` also clears it.
 - Every line in the removed range must match what was last shown to you. The extension records the `anchor│content` rows it serves (`read` output, the auto-read block after `write`, the `+anchor│`/` anchor│` rows of post-edit diffs (replace, insert, and undo), the current-range rows of `[E_RANGE_STALE]` feedback, and the context rows of stale/ambiguous-anchor feedback) and verifies the whole range against that record before writing. If an interior line changed on disk since it was shown (external editor, formatter-on-save, code generation) or was never shown, the edit is refused with `[E_RANGE_STALE]` and the current range is returned with fresh anchors, so the retry needs no `read`. Edits outside the served record are only possible for files that were never read (for example right after a `write` with auto-read disabled); once the file has been served, every replaced line must have been shown.
 - After a successful edit you get the post-edit diff with fresh anchors, so you can keep editing without re-reading. The diff is capped at 50KB: a row longer than 50KB is shown as a marker that keeps the row's anchor (so the line stays editable via the diff), and when the total cap is hit the diff ends with a truncation note. Only the rows shown in the capped diff are recorded as served. The same caps apply to the `insert` and `undo_last_change` diffs, to the interactive previews, and to `details.patch` (which is flagged with `details.patchTruncated` when it was cut and can no longer be applied as-is).
 - Do not issue multiple replace or insert 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.
@@ -127,7 +127,7 @@ Notes:
 
 Notes:
 
-- A missing `path` is resolved from the anchor the same way as `replace` (reported as a warning); when the anchor matches multiple known files the most recently touched file is picked, with the candidates named.
+- A missing `path` is resolved from the anchor the same way as `replace` (reported as a warning); when the anchor matches multiple known files the most recently touched file is picked, with up to 3 candidate paths named.
 - The anchor line must have been shown to you (read output, a post-edit diff row, anchor_grep output, or stale-range feedback). The same verification as `replace` applies: a stale or unshown anchor is rejected with `[E_STALE_ANCHOR]`, `[E_AMBIGUOUS_ANCHOR]`, or `[E_RANGE_STALE]` and the retry needs no `read`.
 - Lines are applied literally: nothing is removed, and a line that duplicates its neighbor is kept. `replace`'s boundary anti-duplication never runs for `insert`.
 - To seed an empty file, read it and insert after the `anchor│` empty-line row.
@@ -224,17 +224,21 @@ Two guarantees make this safe even with duplicated content:
 
 A no-op replace never changes the file, so anchors remain valid. On first run after upgrading from an older version, the previous `hash-store.json` is imported once and renamed to `hash-store.json.bak`.
 
-## Error codes
+## Error and warning codes
+
+Codes starting with `E_` are errors (the operation failed); codes starting with `W_` are warnings (the operation succeeded with a notice).
 
 | Code | Meaning |
 | --- | --- |
 | `[E_BAD_SHAPE]` | Request envelope or edit item has unknown, missing, or wrongly-typed fields (for example `replacement_lines` must be an array of strings, one element per line). |
+| `[W_BAD_SHAPE]` | Auto-corrected request slip reported as a warning (for example unwrapped JSON array syntax, embedded newlines split into lines, or a missing `path` resolved from anchors). |
 | `[E_BAD_REF]` | An anchor in `remove_from`/`remove_to` is not a bare 4-char anchor. |
+| `[W_BAD_REF]` | A pasted `anchor│` or diff-preview marker was stripped from an anchor field with a warning. |
 | `[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 `replacement_lines` element is a diff-preview row (`+anchor│`, `-anchor│`, `-    │`). The marker is stripped automatically with a warning. |
-| `[E_BARE_HASH_PREFIX]` | A `replacement_lines` element starts with an `anchor│` prefix (the anchor plus the separator). 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. |
+| `[W_INVALID_PATCH]` | A `replacement_lines` element is a diff-preview row (`+anchor│`, `-anchor│`, `-    │`). The marker is stripped automatically with a warning. |
+| `[W_BARE_HASH_PREFIX]` | A `replacement_lines` element starts with an `anchor│` prefix (the anchor plus the separator). The prefix is stripped automatically with a warning. |
+| `[W_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. |
 | `[E_ACCESS]` | The file is not readable or writable. |
@@ -242,7 +246,7 @@ A no-op replace never changes the file, so anchors remain valid. On first run af
 | `[E_UNDO_STALE]` | `undo_last_change` refused: the file was modified after the last edit. The undo record is kept until the file matches the edited state again or a new edit replaces it. |
 | `[E_UNDO_UNAVAILABLE]` | Undo history could not be persisted to the hash store; the edit was refused and the file was left unchanged. |
 | `[E_RANGE_STALE]` | A line in the replaced range no longer matches what was last shown (the file changed on disk, or the line was never shown). The edit was refused; the current range is returned with fresh anchors. |
-| `[E_BOUNDARY_BYPASS]` | The boundary anti-duplication was turned off for one replace call (an identical replacement had previously been cut to a noop); the duplicate lines were applied literally. The dedup is restored for the next call. |
+| `[W_BOUNDARY_BYPASS]` | The boundary anti-duplication was turned off for one replace call (an identical replacement had previously been cut to a noop); the duplicate lines were applied literally. The dedup is restored for the next call. |
 | `[E_FILE_TOO_LARGE]` | The file exceeds the 257,795-line hashline limit or the 100MB size limit. |
 | `[E_WRITE_HASH_ECHO]` | A `write` `content` line begins with the exact `anchor│` served for this file at the same line. The write is refused, file byte-identical; retry with bare content (remove the copied anchors). |
 | `[E_PATH_CHANGED]` | A write target changed identity after it was read; the write was refused to avoid following a swapped symlink or overwriting a replacement file. |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "3.0.3",
+  "version": "3.0.4",
   "type": "module",
   "description": "Hash-anchored read/replace/insert/grep tools for pi-coding-agent. Every line gets a unique 4-char tokenizer-friendly anchor that stays stable across edits; stale or ambiguous anchors are rejected, never fuzzy-matched. Undo persists across restarts.",
   "main": "index.ts",

package/src/hash-store.ts

@@ -636,21 +636,20 @@ export function pathActivity(store: HashStore, path: string): number {
   return activity;
 }
 
-export function pickRecentPath(store: HashStore, candidates: string[]): string {
-  let best = candidates[0]!;
-  let bestSession = -1;
-  let bestActivity = -1;
-  for (const candidate of candidates) {
+export function rankRecentPaths(store: HashStore, candidates: string[]): string[] {
+  const scored = candidates.map((candidate) => {
     const rank = sessionRank(candidate) ?? -1;
-    let activity = -1;
-    if (rank < 0) {
-      activity = pathActivity(store, candidate);
-    }
-    if (rank > bestSession || (rank === bestSession && activity > bestActivity)) {
-      best = candidate;
-      bestSession = rank;
-      bestActivity = activity;
-    }
-  }
-  return best;
+    const activity = rank < 0 ? pathActivity(store, candidate) : -1;
+    return { candidate, rank, activity };
+  });
+  scored.sort((a, b) => {
+    if (a.rank !== b.rank) return b.rank - a.rank;
+    if (a.activity !== b.activity) return b.activity - a.activity;
+    return a.candidate < b.candidate ? -1 : a.candidate > b.candidate ? 1 : 0;
+  });
+  return scored.map((entry) => entry.candidate);
+}
+
+export function pickRecentPath(store: HashStore, candidates: string[]): string {
+  return rankRecentPaths(store, candidates)[0]!;
 }

package/src/hashline/parse.ts

@@ -63,14 +63,14 @@ function unwrapJsonEnvelope(line: string, warnings?: string[]): string {
     const parsed: unknown = JSON.parse(withoutDot);
     if (Array.isArray(parsed) && parsed.length === 1 && typeof parsed[0] === "string") {
       warnings?.push(
-        '[E_BAD_SHAPE] Unwrapped JSON array syntax from a replacement_lines element.',
+        '[W_BAD_SHAPE] Unwrapped JSON array syntax from a replacement_lines element.',
       );
       return parsed[0];
     }
     return line;
   } catch {
     warnings?.push(
-      '[E_BAD_SHAPE] Unwrapped JSON array syntax from a replacement_lines element.',
+      '[W_BAD_SHAPE] Unwrapped JSON array syntax from a replacement_lines element.',
     );
     return match[1]!;
   }
@@ -90,7 +90,7 @@ export function parseText(edit: string[], warnings?: string[]): string[] {
   }
   if (split) {
     warnings?.push(
-      "[E_BAD_SHAPE] replacement_lines contained embedded newlines; split into one line each.",
+      "[W_BAD_SHAPE] replacement_lines contained embedded newlines; split into one line each.",
     );
   }
   return out;

package/src/hashline/resolve.ts

@@ -195,7 +195,7 @@ export function stripAnchorRow(
 			: match[1] === "-"
 				? 'leading "-" marker'
 				: '"anchor│" prefix';
-	warnings?.push(`[E_BAD_REF] Stripped ${marker} from ${entryLabel} "${clipLine(trimmed, 48)}".`);
+  warnings?.push(`[W_BAD_REF] Stripped ${marker} from ${entryLabel} "${clipLine(trimmed, 48)}".`);
 	return match[2]!;
 }
 
@@ -241,7 +241,7 @@ export function stripBarePrefixes(
 		.map((s) => `replacement_lines line ${s.lineIndex + 1}`)
 		.join(", ");
 	warnings.push(
-		`[E_BARE_HASH_PREFIX] Stripped "anchor│" prefix from ${locations}.`
+    `[W_BARE_HASH_PREFIX] Stripped "anchor│" prefix from ${locations}.`
 	);
 	return { ...edit, content_lines: contentLines };
 }
@@ -260,7 +260,7 @@ export function stripDiffPrefixes(
 	if (stripped.length === 0) return edit;
 	const locations = stripped.map((i) => `replacement_lines line ${i + 1}`).join(", ");
 	warnings.push(
-		`[E_INVALID_PATCH] Stripped diff-preview marker from ${locations}.`
+    `[W_INVALID_PATCH] Stripped diff-preview marker from ${locations}.`
 	);
 	return { ...edit, content_lines: contentLines };
 }
@@ -285,7 +285,7 @@ export function swapReversedRanges(
 		return edit;
 	}
 	warnings.push(
-		`[E_BAD_OP] Swapped reversed remove_from/remove_to.`
+    `[W_BAD_OP] Swapped reversed remove_from/remove_to.`
 	);
 	return { ...edit, hash_bounds: [endRef, startRef] as [Anchor, Anchor] };
 }

package/src/insert.ts

@@ -181,7 +181,7 @@ export function buildInsertToolDef(): InsertToolDef {
       if (isRec(canonical)) {
         const expanded = decodeStringArray(canonical.lines);
         if (expanded) {
-          insertWarnings.push('[E_BAD_SHAPE] Unwrapped JSON array syntax from a lines element.');
+          insertWarnings.push('[W_BAD_SHAPE] Unwrapped JSON array syntax from a lines element.');
           canonical.lines = expanded;
         }
       }

package/src/missing-path.ts

@@ -1,4 +1,4 @@
-import { loadHashStore, findSnapshotPaths, findServedPaths, pickRecentPath } from "./hash-store";
+import { loadHashStore, findSnapshotPaths, findServedPaths, rankRecentPaths } from "./hash-store";
 import { parseHashRef } from "./hashline/parse";
 import { stripAnchorRow } from "./hashline/resolve";
 
@@ -13,11 +13,14 @@ export async function resolvePathFromHashes(hashes: string[]): Promise<{ path: s
   if (matches.length === 0) return undefined;
   if (matches.length === 1) {
     const single = matches[0]!;
-    return { path: single, warning: `[E_BAD_SHAPE] Missing "path" resolved to ${single}.` };
+    return { path: single, warning: `[W_BAD_SHAPE] Missing "path" resolved to ${single}.` };
   }
-  const sorted = [...matches].sort();
-  const picked = pickRecentPath(store, sorted);
-  return { path: picked, warning: `[E_BAD_SHAPE] Missing "path" resolved to ${picked} (picked most recent of ${sorted.length}: ${sorted.join(", ")}).` };
+  const ranked = rankRecentPaths(store, [...matches]);
+  const picked = ranked[0]!;
+  const shown = ranked.slice(0, 3);
+  const hidden = ranked.length - shown.length;
+  const listed = hidden > 0 ? `${shown.join(", ")}, ... (+${hidden} more)` : shown.join(", ");
+  return { path: picked, warning: `[W_BAD_SHAPE] Missing "path" resolved to ${picked} (picked most recent of ${ranked.length}: ${listed}).` };
 }
 
 export async function resolveReplacePath(request: Record<string, unknown>): Promise<{ path: string; warning: string } | undefined> {

package/src/payload-contract.ts

@@ -1,5 +1,5 @@
 import { Type } from "typebox";
-import { isRec, normalizeFilePath, rejectUnknownFields } from "./utils";
+import { isRec, normalizeAnchors, normalizeFilePath, rejectUnknownFields } from "./utils";
 
 const replacementLinesSchema = Type.Array(
   Type.String({
@@ -72,6 +72,7 @@ export function normReq(input: unknown): unknown {
   }
   const record: Record<string, unknown> = { ...input };
   normalizeFilePath(record);
+  normalizeAnchors(record);
   return record;
 }
 

package/src/replace-render.ts

@@ -2,6 +2,7 @@ import { Markdown, Text } from "@earendil-works/pi-tui";
 import { keyHint, type Theme } from "@earendil-works/pi-coding-agent";
 import type { ReplaceDetails } from "./replace";
 import { withLineNumbers } from "./utils";
+import { isDedupRow } from "./replace-response";
 import { getPreviewInput } from "./payload-contract";
 export { getPreviewInput };
 
@@ -24,9 +25,10 @@ export type RRState = {
 type DiffRowKind = "added" | "removed" | "context";
 
 function diffRowKind(line: string): DiffRowKind {
-	const stripped = line.replace(/^\s*\d+\s+│\s*/, "");
-	if (stripped.startsWith("+") && !stripped.startsWith("+++")) return "added";
-	if (stripped.startsWith("-") && !stripped.startsWith("---")) return "removed";
+	const withoutGutter = line.replace(/^\s*\d+\s+│\s*/, "");
+	if (isDedupRow(withoutGutter) || isDedupRow(withoutGutter.replace(/^\s*│\s*/, ""))) return "removed";
+	if (withoutGutter.startsWith("+") && !withoutGutter.startsWith("+++")) return "added";
+	if (withoutGutter.startsWith("-") && !withoutGutter.startsWith("---")) return "removed";
 	return "context";
 }
 

package/src/replace-response.ts

@@ -137,6 +137,10 @@ export function fmtDedupRow(line: string): string {
   return `${DEDUP_ANCHOR}${HASH_SEP}[Row is ${size}, exceeds ${limit}; content not shown. Use read to see the full line.]`;
 }
 
+export function isDedupRow(line: string): boolean {
+  return line.startsWith(`${DEDUP_ANCHOR}${HASH_SEP}`);
+}
+
 export function isChangeRow(line: string): boolean {
   return line.startsWith("+") || line.startsWith("-");
 }

package/src/replace.ts

@@ -130,7 +130,7 @@ export async function execPipeline(
   let replacementLines = params.replacement_lines;
   const expandedReplacement = decodeStringArray(replacementLines);
   if (expandedReplacement) {
-    editWarnings.push('[E_BAD_SHAPE] Unwrapped JSON array syntax from a replacement_lines element.');
+    editWarnings.push('[W_BAD_SHAPE] Unwrapped JSON array syntax from a replacement_lines element.');
     replacementLines = expandedReplacement;
   }
   const edit = resEdit(
@@ -286,7 +286,7 @@ export function buildToolDef(): ToolDef {
           { accessMode: constants.R_OK | constants.W_OK, signal, skipBoundaryDedup: boundaryBypass },
         );
         const appliedWarnings = boundaryBypass
-          ? ["[E_BOUNDARY_BYPASS] Boundary dedup was off for this call and is back on."]
+          ? ["[W_BOUNDARY_BYPASS] Boundary dedup was off for this call and is back on."]
           : [];
         return commitEdit(pipe, {
           path,

package/src/utils.ts

@@ -9,11 +9,23 @@ export function normalizeFilePath(record: Record<string, unknown>): void {
   }
 }
 
+export function normalizeAnchors(record: Record<string, unknown>): void {
+  if (typeof record.remove_from !== "string" && typeof record.replace_from === "string") {
+    record.remove_from = record.replace_from;
+    delete record.replace_from;
+  }
+  if (typeof record.remove_to !== "string" && typeof record.replace_to === "string") {
+    record.remove_to = record.replace_to;
+    delete record.replace_to;
+  }
+}
+
 export function makePrepareArguments(): (args: unknown) => any {
   return (args) => {
     if (!isRec(args)) return args;
     const record = { ...args };
     normalizeFilePath(record);
+    normalizeAnchors(record);
     return record;
   };
 }