pi-hashline-edit-pro 0.20.0 → 0.21.0

package/README.md

@@ -1,6 +1,6 @@
 # pi-hashline-edit-pro
 
-A [pi-coding-agent](https://github.com/badlogic/pi-mono/tree/main/packages/coding-agent) extension that replaces the built-in `read` and `edit` tools with a hash-anchored line-replacing workflow. Strict semantics, no silent relocation, no autocorrection, no fuzzy fallback. Every line gets a unique content hash, so edits stay precise and stale anchors are caught before they reach the file.
+A [pi-coding-agent](https://github.com/badlogic/pi-mono/tree/main/packages/coding-agent) extension that replaces the built-in `read` and `edit` tools with a hash-anchored line-replacing workflow. Strict semantics, no silent relocation, no fuzzy fallback. Unambiguous copy-paste mistakes are autocorrected with a visible warning. Every line gets a unique content hash, so edits stay precise and stale anchors are caught before they reach the file.
 
 Fork of [pi-hashline-edit](https://github.com/RimuruW/pi-hashline-edit) by RimuruW. The strict-semantics policy is unchanged. This fork extends the upstream design with 3-character hashes and collision resolution for unique per-line anchors.
 
@@ -163,10 +163,10 @@ The file is created automatically when any setting is toggled. Both fields are i
 | `[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. |
-| `[E_INVALID_PATCH]` | `content_lines` contains diff-preview rows (`+HASH│`, `-HASH│`, `-   │`, `-N   `). |
-| `[E_BARE_HASH_PREFIX]` | A `content_lines` entry starts with a hash-like `HASH│` prefix. |
+| `[E_INVALID_PATCH]` | A `content_lines` entry is a diff-preview row (`+HASH│`, `-HASH│`, `-   │`) — the marker is stripped automatically with a warning. |
+| `[E_BARE_HASH_PREFIX]` | A `content_lines` entry starts with a hash-like `HASH│` prefix — the prefix is stripped automatically with a warning. |
 | `[E_LEGACY_SHAPE]` | The request uses the unsupported `oldText`/`newText` dialect. |
-| `[E_BAD_OP]` | Range start line is after range end line. |
+| `[E_BAD_OP]` | Range start line is after range end line — the pair is swapped automatically with a warning. |
 | `[E_EDIT_CONFLICT]` | Two edits in one batch overlap the same original lines. |
 | `[E_WOULD_EMPTY]` | An edit would empty a non-empty file; use `write` instead. |
 | `[E_FILE_TOO_LARGE]` | The file exceeds the 238,328-line hashline limit. |
@@ -175,19 +175,20 @@ The file is created automatically when any setting is toggled. Both fields are i
 
 - **Stale anchors fail (per-line).** A hash mismatch means that specific line's content changed since the last `read`; the error tells the model to call `read()` to get fresh anchors, then copy the 3-character HASH of the start and end of the range being replaced into `hash_range_inclusive` of the next replace call. When a range has one stale and one still-valid anchor, the error also shows the current lines (with fresh hashes) around the resolved anchor, so the model can re-locate the range without a full re-read. Because staleness is per-line, editing or appending lines does **not** invalidate anchors for lines whose content is unchanged — anchors for untouched regions stay valid across edits to other regions.
 - **No fallback relocation.** Mismatched anchors are never silently relocated to a "close enough" line. This trades convenience for correctness.
-- **Strict patch content.** If `content_lines` contains diff-preview rows — `+HASH│` addition prefixes, `-HASH│` or `-   │` deletion rows (the padded format the diff preview emits), or `-N   ` numbered deletion rows — the edit is rejected with `[E_INVALID_PATCH]`. This narrowly guards against pasting the tool's own diff-preview rows back as content; standard unified-diff lines (`+x`, `-x`, ` x`, `@@ … @@`) are **not** rejected — they are written literally, since literal content must never be silently altered. Bare `HASH│` content (the first 4 chars of a `content_lines` entry looking like 3 alphanumeric chars + `│`) is rejected with `[E_BARE_HASH_PREFIX]`. When the suspect's prefix happens to match a real file-line anchor, the error message flags that as strong evidence the model copied an anchor from the read output.
+- **Strict patch content.** Diff-preview rows pasted into `content_lines` are autocorrected instead of rejected: `+HASH│` addition prefixes and `-HASH│` / `-   │` deletion rows (the padded format the diff preview emits) have their markers stripped, with a warning, and only the literal content is written. `-N   ` numbered deletion rows and standard unified-diff lines (`+x`, `-x`, ` x`, `@@ … @@`) are **not** altered — they are written literally, since literal content must never be silently changed when the intent is ambiguous. Bare `HASH│` content (the first 4 chars of a `content_lines` entry looking like 3 alphanumeric chars + `│`) is autocorrected: the prefix is stripped and only the literal content after `│` is written, with a warning. When the stripped hash happens to match a real file-line anchor, the warning flags that as strong evidence the model copied an anchor from the read output.
 
 - **BOM preservation.** A UTF-8 BOM is stripped for display and hashing but restored on write, so edits (and undo) never silently strip a BOM from a file that has one.
 - **Atomic writes.** Files are written via temp-file-then-rename to avoid corruption from interrupted writes. Symlink chains are resolved so the target file is updated without replacing the symlink. Hard-linked files are updated in place to preserve the shared inode. File permissions are preserved across atomic renames.
 - **Per-file mutation queue.** Edits queue by the canonical write target, so concurrent edits through different symlink paths still serialize onto the same underlying file.
 - **Boundary duplication auto-fix.** When the last line of a replacement matches the next surviving line (or the first line matches the preceding one), the runtime automatically strips the duplicate from `content_lines` before applying the edit. This catches a common LLM pattern where closing delimiters like `}`, `});`, or `} else {` are accidentally duplicated. The auto-fix is completely silent — the model sees a normal successful edit. The duplicate never reaches the file. Raw line comparison (not trimmed) avoids false positives when indentation differs.
+- **Reversed range auto-swap.** When `hash_range_inclusive` is given in reverse order (start anchor after end anchor), both anchors are still valid file lines, so the intent is unambiguous: the pair is swapped automatically and the edit applies, with a warning.
 - **Flat mode normalization.** When flat mode is active, the tool's `execute` function wraps the top-level `hash_range_inclusive` and `content_lines` into a single-element `changes` array internally, then runs the same pipeline as bulk mode. The `normReq` function in `replace-normalize.ts` also handles flat format directly, so any code path that normalizes input (e.g. `compPreview`) works with both formats.
 - **Persistent hash store.** `lineHashes` is async and uses a persistent store to preserve hashes for unchanged lines across edits. The store is a SQLite database at `~/.config/pi-hashline-edit-pro/hash-store.sqlite` (per-path snapshots keyed by resolved path storing a 64-bit content checksum + line hashes; auto-created on first use). When called from the replace pipeline, it maps old vs new content and copies hashes for unchanged lines. When called from read, it returns saved hashes if the content's checksum matches, otherwise computes fresh hashes via `_lineHashesPure`. Stale snapshots are pruned on session start. This ensures that editing one part of a file does not cascade to change hashes of unrelated lines. Per-operation work scales with the target file, not cumulative history. If the database is corrupt or unreadable it is quarantined (renamed to `hash-store.sqlite.corrupt-<timestamp>`) and rebuilt from content on the next session start — the store is a cache, never a source of truth.
 ## Hashing
 
 Hashes are computed with [xxhash-wasm](https://github.com/jungomi/xxhash-wasm) (xxHash32 via WebAssembly), then mapped to a 3-character string from the alphanumeric alphabet `A-Za-z0-9`. That's 62 distinct characters, 62³ = 238,328 possible anchors (≈17.9 bits of entropy per anchor).
 
-The alphabet is sized for an LLM consumer. The model tokenizes, it doesn't squint at pixel glyphs, so the human-readability heuristics used by smaller hand-curated alphabets (no G/L/I/O because they look like digits, no vowels so the hash doesn't accidentally spell a word, no hex digits so it can't be confused with `0xFF`) don't apply — case and digits are all included. The URL-safe specials `-` and `_` are deliberately excluded: a hash starting with `-` is shape-identical to a diff-preview deletion row (`-HASH│`), and `-`/`_` at a line start are markdown-active (list bullet, emphasis), so they invite mis-copying and false `[E_INVALID_PATCH]`/`[E_BARE_HASH_PREFIX]` rejections. The 9% hash-space cost (238,328 vs 262,144) is irrelevant for real files.
+The alphabet is sized for an LLM consumer. The model tokenizes, it doesn't squint at pixel glyphs, so the human-readability heuristics used by smaller hand-curated alphabets (no G/L/I/O because they look like digits, no vowels so the hash doesn't accidentally spell a word, no hex digits so it can't be confused with `0xFF`) don't apply — case and digits are all included. The URL-safe specials `-` and `_` are deliberately excluded: a hash starting with `-` is shape-identical to a diff-preview deletion row (`-HASH│`), and `-`/`_` at a line start are markdown-active (list bullet, emphasis), so they invite mis-copying and false `[E_INVALID_PATCH]`/`[E_BARE_HASH_PREFIX]` autocorrections. The 9% hash-space cost (238,328 vs 262,144) is irrelevant for real files.
 
 Before hashing, each line is normalized: carriage returns are stripped and trailing whitespace is trimmed. This `canon()` normalization prevents insignificant whitespace changes from cascade-triggering hash churn across the file. Two lines that differ only in trailing spaces or `\r` characters produce the same hash, so anchor stability is preserved across editor-save cycles that add or remove trailing whitespace.
 
@@ -199,7 +200,7 @@ The 3-character space holds 238,328 unique anchors, so files are capped at 238,3
 
 ### Bare-prefix detector
 
-With the `│` delimiter format, the bare-prefix detector regex `^\s*([A-Za-z0-9_\-]{3})│` is highly specific. It only matches lines starting with a hash-like prefix. This eliminates false positives from common code patterns like `init:`, `data:`, `else:`, etc. The detector rejects edit lines matching this pattern with `[E_BARE_HASH_PREFIX]` to prevent the model from accidentally pasting hash anchors into file content.
+With the `│` delimiter format, the bare-prefix detector regex `^\s*([A-Za-z0-9_\-]{3})│` is highly specific. It only matches lines starting with a hash-like prefix. This eliminates false positives from common code patterns like `init:`, `data:`, `else:`, etc. The detector strips the prefix from edit lines matching this pattern (with a warning) instead of writing the anchor into the file content.
 
 ## Development
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "0.20.0",
+  "version": "0.21.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/src/hashline/apply.ts

@@ -2,7 +2,9 @@ import { abortIf, splitLines, lastNonEmptyIndex, firstNonEmptyIndex } from "../u
 import { _lineHashesPure, HASH_SEP } from "./hash";
 import {
 	valEdits,
-	assertNoBarePrefix,
+	stripBarePrefixes,
+	stripDiffPrefixes,
+	swapReversedRanges,
 	warnUnicodeEsc,
 	fmtMismatch,
 	descEdit,
@@ -246,8 +248,14 @@ export function applyEdits(
 	const noopEdits: NEdit[] = [];
 	const warnings: string[] = [];
 
+	const rangeFixed = swapReversedRanges(edits, fileHashes, warnings);
+	const prefixFixed = stripDiffPrefixes(
+		stripBarePrefixes(rangeFixed, fileHashes, warnings),
+		warnings,
+	);
+
 	const { resolved: initialResolved, mismatches, boundaryWarnings } = valEdits(
-		edits,
+		prefixFixed,
 		lineIndex.fileLines,
 		fileHashes,
 		warnings,
@@ -259,14 +267,13 @@ export function applyEdits(
 		);
 	}
 
-	assertNoBarePrefix(edits, lineIndex.fileLines, fileHashes);
-	warnUnicodeEsc(edits, warnings);
+	warnUnicodeEsc(prefixFixed, warnings);
 
 	let resolved = initialResolved;
 	let autoFixes: AutoFix[] | undefined;
 	if (boundaryWarnings.length > 0) {
 		autoFixes = [];
-		const correctedEdits: HEdit[] = edits.map(e => ({
+		const correctedEdits: HEdit[] = prefixFixed.map(e => ({
 			...e,
 			content_lines: [...e.content_lines],
 		}));

package/src/hashline/hash.ts

@@ -48,7 +48,6 @@ export const HL_PREFIX_PLUS_RE = new RegExp(
 export const HL_PREFIX_MINUS_RE = new RegExp(
 	`^-(?:\\s*${HASH_CLASS}│| {${ANCHOR_LEN}}│)`,
 );
-export const DIFF_MINUS_RE = /^-\s*\d+\s{4}/;
 
 export const HL_BARE_PREFIX_RE = new RegExp(`^\\s*(${HASH_CLASS})│`);
 

package/src/hashline/index.ts

@@ -7,7 +7,6 @@ export {
 	MAX_HASH_LINES,
 	HL_PREFIX_PLUS_RE,
 	HL_PREFIX_MINUS_RE,
-	DIFF_MINUS_RE,
 	HL_BARE_PREFIX_RE,
 	lineHashes,
 	_lineHashesPure,
@@ -31,7 +30,9 @@ export {
 	descEdit,
 	resEdits,
 	valEdits,
-	assertNoBarePrefix,
+	stripBarePrefixes,
+	stripDiffPrefixes,
+	swapReversedRanges,
 	fmtMismatch,
 } from "./resolve";
 export {

package/src/hashline/parse.ts

@@ -1,12 +1,8 @@
 import {
 	ANCHOR_LEN,
 	ALPH_RE,
-	HL_PREFIX_PLUS_RE,
-	HL_PREFIX_MINUS_RE,
-	DIFF_MINUS_RE,
 } from "./hash";
 import { CONTENT_LINES_NOT_STRING_MSG } from "../constants";
-import { clipLine } from "../utils";
 
 export type Anchor = { hash: string };
 
@@ -43,21 +39,6 @@ function parseRef(ref: string): Anchor {
 
 export const parseHashRef = parseRef;
 
-function assertNoPrefixes(lines: string[]): void {
-	for (const line of lines) {
-		if (!line.length) continue;
-		if (
-			HL_PREFIX_PLUS_RE.test(line) ||
-			HL_PREFIX_MINUS_RE.test(line) ||
-			DIFF_MINUS_RE.test(line)
-		) {
-			throw new Error(
-			`[E_INVALID_PATCH] "content_lines" must contain literal file content. Offending line looks like a diff preview row (e.g. +HASH│ or -HASH│): ${JSON.stringify(clipLine(line))}. Use literal file content only — plain + or - lines are written literally.`
-			);
-		}
-	}
-}
-
 export function parseText(edit: string[] | string | null): string[] {
   if (edit === null) {
     throw new Error('[E_BAD_SHAPE] "content_lines" must be a string array; use [] to delete a range.');
@@ -65,6 +46,5 @@ export function parseText(edit: string[] | string | null): string[] {
   if (typeof edit === "string") {
     throw new Error(CONTENT_LINES_NOT_STRING_MSG);
   }
-  assertNoPrefixes(edit);
   return edit;
 }

package/src/hashline/resolve.ts

@@ -1,5 +1,5 @@
 import { abortIf, rejectUnknownFields, lastNonEmpty, firstNonEmpty, clipLine } from "../utils";
-import { HL_BARE_PREFIX_RE } from "./hash";
+import { HL_BARE_PREFIX_RE, HL_PREFIX_PLUS_RE, HL_PREFIX_MINUS_RE } from "./hash";
 import { parseHashRef, parseText, type Anchor } from "./parse";
 import { CONTENT_LINES_NOT_STRING_MSG } from "../constants";
 
@@ -213,39 +213,98 @@ function warnUnicodeEsc(
   }
 }
 
-export function assertNoBarePrefix(
-  edits: HEdit[],
-  fileLines: string[],
-  fileHashes: string[],
-): void {
-  const suspects: { line: string; hash: string; editIndex: number; lineIndex: number }[] = [];
-  for (let editIndex = 0; editIndex < edits.length; editIndex++) {
-    const edit = edits[editIndex]!;
-    for (let lineIndex = 0; lineIndex < edit.content_lines.length; lineIndex++) {
-      const line = edit.content_lines[lineIndex]!;
-      const match = line.match(HL_BARE_PREFIX_RE);
-      if (match) suspects.push({ line, hash: match[1]!, editIndex, lineIndex });
-    }
-  }
-  if (suspects.length === 0) return;
-  const locations = suspects
-    .map((s) => `edit ${s.editIndex}, content_lines[${s.lineIndex}]`)
-    .join("; ");
-
-  const fileHashSet = new Set(fileHashes);
-  const matched = suspects.filter((s) => fileHashSet.has(s.hash));
-  const matchedCount = matched.length;
-
-  const exampleLine = `${suspects[0]!.hash}│${clipLine(suspects[0]!.line)}`;
+export function stripBarePrefixes(
+	edits: HEdit[],
+	fileHashes: string[],
+	warnings: string[],
+): HEdit[] {
+	const fileHashSet = new Set(fileHashes);
+	let changed = false;
+	const corrected = edits.map((edit, editIndex) => {
+		const stripped: { lineIndex: number; matched: boolean }[] = [];
+		const contentLines = edit.content_lines.map((line, lineIndex) => {
+			const match = line.match(HL_BARE_PREFIX_RE);
+			if (!match) return line;
+			stripped.push({ lineIndex, matched: fileHashSet.has(match[1]!) });
+			return line.slice(match[0].length);
+		});
+		if (stripped.length === 0) return edit;
+		changed = true;
+		const locations = stripped
+			.map((s) => `content_lines[${s.lineIndex}]`)
+			.join(", ");
+		const matchedCount = stripped.filter((s) => s.matched).length;
+		const evidence =
+			matchedCount === 0
+				? "none of the stripped hashes match current file lines"
+				: `${matchedCount} of ${stripped.length} stripped hash(es) match current file lines`;
+		warnings.push(
+			`Autocorrected edit ${editIndex}: stripped "HASH│" prefix copied from read output in ${locations} (${evidence}).`
+		);
+		return { ...edit, content_lines: contentLines };
+	});
+	return changed ? corrected : edits;
+}
 
-  const linesHint =
-    matchedCount === 0
-      ? `None match file line hashes.`
-      : `${matchedCount} match file line hashes — strong evidence the prefix was copied from read output.`;
+export function stripDiffPrefixes(
+	edits: HEdit[],
+	warnings: string[],
+): HEdit[] {
+	let changed = false;
+	const corrected = edits.map((edit, editIndex) => {
+		const stripped: number[] = [];
+		const contentLines = edit.content_lines.map((line, lineIndex) => {
+			const plus = line.match(HL_PREFIX_PLUS_RE);
+			if (plus) {
+				stripped.push(lineIndex);
+				return line.slice(plus[0].length);
+			}
+			const minus = line.match(HL_PREFIX_MINUS_RE);
+			if (minus) {
+				stripped.push(lineIndex);
+				return line.slice(minus[0].length);
+			}
+			return line;
+		});
+		if (stripped.length === 0) return edit;
+		changed = true;
+		const locations = stripped.map((i) => `content_lines[${i}]`).join(", ");
+		warnings.push(
+			`Autocorrected edit ${editIndex}: stripped diff-preview marker copied from the diff preview in ${locations}.`
+		);
+		return { ...edit, content_lines: contentLines };
+	});
+	return changed ? corrected : edits;
+}
 
-  throw new Error(
-    `[E_BARE_HASH_PREFIX] ${suspects.length} edit line(s) start with a hash-like prefix (${locations}). Example: ${JSON.stringify(exampleLine)}. ${linesHint} Remove the "HASH│" prefix from each affected content_lines entry; keep only the literal line content that appears after "│" in read output. Remember: content_lines uses file content only, hash_range_inclusive uses hash anchors.`
-  );
+export function swapReversedRanges(
+	edits: HEdit[],
+	fileHashes: string[],
+	warnings: string[],
+): HEdit[] {
+	const lineByHash = new Map<string, number>();
+	for (let i = 0; i < fileHashes.length; i++) {
+		lineByHash.set(fileHashes[i]!, i + 1);
+	}
+	let changed = false;
+	const corrected = edits.map((edit, editIndex) => {
+		const [startRef, endRef] = edit.hash_range_inclusive;
+		const startLine = lineByHash.get(startRef.hash);
+		const endLine = lineByHash.get(endRef.hash);
+		if (
+			startLine === undefined ||
+			endLine === undefined ||
+			startLine <= endLine
+		) {
+			return edit;
+		}
+		changed = true;
+		warnings.push(
+			`Autocorrected edit ${editIndex}: hash_range_inclusive was reversed (start ${startRef.hash} is after end ${endRef.hash}); swapped the pair.`
+		);
+		return { ...edit, hash_range_inclusive: [endRef, startRef] as [Anchor, Anchor] };
+	});
+	return changed ? corrected : edits;
 }
 
 export function descEdit(edit: RHEdit): string {

package/src/replace.ts

@@ -175,7 +175,9 @@ function collectRemovedHashes(
     const startLine = originalHashes.indexOf(startHash);
     const endLine = originalHashes.indexOf(endHash);
     if (startLine >= 0 && endLine >= 0) {
-      for (let i = startLine; i <= endLine; i++) {
+      const firstLine = Math.min(startLine, endLine);
+      const lastLine = Math.max(startLine, endLine);
+      for (let i = firstLine; i <= lastLine; i++) {
         removedHashes.add(originalHashes[i]!);
       }
     }
@@ -197,7 +199,7 @@ function countLineChanges(
     const startLine = originalHashes.indexOf(edit.hash_range_inclusive[0].hash);
     const endLine = originalHashes.indexOf(edit.hash_range_inclusive[1].hash);
     if (startLine >= 0 && endLine >= 0) {
-      totalRemovedLines += endLine - startLine + 1;
+      totalRemovedLines += Math.abs(endLine - startLine) + 1;
     }
     totalAddedLines += edit.content_lines.length;
   }