pi-hashline-edit-pro 0.4.3 → 0.5.1

package/README.md

@@ -13,8 +13,7 @@ The original uses 2-character hashes of a 16-character alphabet, with the hash b
 This fork makes two changes that compound:
 
 1. **Bump hash length to 4 characters** of the 64-char URL-safe base64 alphabet. That gives 24 bits / 16 777 216 buckets. Birthday-paradox collisions are effectively nullified for any realistic file.
-2. **Make the hash occurrence-aware.** The hash for line N is `xxHash32("C{occurrence}:{content}")` where `occurrence` is the running count of that content string earlier in the file. Symbol-only lines use `"S{lineNumber}"` as the discriminator. Two `import {...}` statements at different positions now hash to different values, so the model can target a specific occurrence without resorting to `offset` + a small `limit` window.
-
+2. **Make the hash occurrence-aware.** The hash for line N is `xxHash32("C{occurrence}:{content}")` where `occurrence` is the running count of that content string earlier in the file. Two `import {...}` statements at different positions now hash to different values, so the model can target a specific occurrence without resorting to `offset` + a small `limit` window. All lines — including symbol-only lines like `}` — use the same occurrence-based discrimination.
 ## Installation
 
 From npm:
@@ -114,10 +113,10 @@ Hashes are computed with [xxhash-wasm](https://github.com/jungomi/xxhash-wasm) (
 
 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. The full 64 chars give maximum entropy per character, with case and digits included.
 
-Hashes are occurrence-aware: a discriminator prefix is mixed into the xxHash input before the line content. Symbol-only lines (lone `}`, etc.) use `S{lineNumber}` as the discriminator; content lines use `C{occurrence}` where `occurrence` is the running count of that canonical content earlier in the file. This way:
+Hashes are occurrence-aware: a discriminator prefix is mixed into the xxHash input before the line content. All lines (including symbol-only lines like `}`) use `C{occurrence}` as the discriminator, where `occurrence` is the running count of that canonical content earlier in the file. This way:
 
-- `}` on line 5 and `}` on line 17 hash differently (different `S{...}` prefix).
-- `import { foo } from 'bar';` on line 3 and the same string on line 47 hash differently (different `C{...}` prefix, 1 vs 2).
+- `}` on line 5 and `}` on line 17 hash differently (1st vs 2nd occurrence of `}`).
+- `import { foo } from 'bar';` on line 3 and the same string on line 47 hash differently (1st vs 2nd occurrence).
 
 The runtime always precomputes the full per-line hash array for a file via `computeLineHashes(content)`, then looks up by line number during validation and during `read` / `edit` response formatting. There is no per-line recomputation that could disagree with what the model saw in its last read.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "0.4.3",
+  "version": "0.5.1",
   "description": "Strict hashline read/edit tool override for pi-coding-agent with hash-anchored edits (4-char, 24-bit)",
   "main": "index.ts",
   "repository": {

package/prompts/edit.md

@@ -44,6 +44,7 @@ Rules:
 - `lines` is literal file content. No `HASH│` prefix, no leading `+`/`-` (those are read/diff metadata, not file content). Lines starting with 4 base64 chars + `│` are checked; if detected, the edit is rejected with `[E_BARE_HASH_PREFIX]`. For `.py` files, this becomes a `[W_BARE_HASH_PREFIX]` warning instead (Python syntax like `else:`, `except:` triggers the detector).
 - Copy anchors from the most recent `read` of the file. Do not guess or construct them.
 - All edits in one call must be non-conflicting. The runtime rejects with `[E_EDIT_CONFLICT]` if: two `replace` ranges overlap; two `append`/`prepend` target the same insertion boundary (e.g. two EOF appends on a newline-terminated file); or an `append`/`prepend` falls inside a `replace` range in the same call. Fix: merge into one, use different boundaries, or split into a follow-up `edit` call.
+- When building `replace` ranges, double-check that `start` is on the first line you want changed and `end` is on the last. If two edits would touch the same lines or adjacent lines, merge them into one `replace` with the combined new content.
 - If `lines` matches the current content byte-for-byte, the edit is classified as `Classification: noop` (file unchanged, not an error).
 
 On success (`changed` mode, default), the response text contains an `--- Anchors ---` block with fresh `HASH│content` for the changed region (2 lines of context, capped at ~12 lines / 50 KB). Use those for nearby follow-up edits instead of re-reading. If the response says `Anchors omitted; use read for subsequent edits`, the region was too large — call `read` again. For distant follow-ups, or on any error, call `read` again. `full` and `ranges` modes put previews in `details`; the model only needs what's in the text.

package/src/hashline/hash.ts

@@ -40,7 +40,7 @@ export const DIFF_MINUS_RE = /^-\s*\d+\s{4}/;
 
 export const HASHLINE_BARE_PREFIX_RE = new RegExp(`^\\s*(${HASH_CHARS_CLASS})│`);
 
-const RE_SIGNIFICANT = /[\p{L}\p{N}]/u;
+
 
 // Lazy-initialized xxhash-wasm hasher. Initialization starts at module load
 // time and completes in ~2ms. By the time any tool calls xxh32(), the hasher
@@ -64,50 +64,35 @@ hasherPromise = xxhash().then((h) => {
 
 // Export for tests that need to await readiness.
 export function ensureHasherReady(): Promise<Hasher> {
-	return hasherPromise!;
+	return hasherPromise!
 }
 
 function xxh32(input: string, seed = 0): number {
 	return getHasher().h32(input, seed) >>> 0;
 }
 
-const SYMBOL_DISCRIMINATOR = (lineNumber: number): string => `S${lineNumber}`;
-const CONTENT_DISCRIMINATOR = (occurrence: number): string => `C${occurrence}`;
+const DISCRIMINATOR = (occurrence: number): string => `C${occurrence}`;
 
 function canonicalizeLine(line: string): string {
 	return line.replace(/\r/g, "").trimEnd();
 }
 
-function isSymbolOnly(canonical: string): boolean {
-	return !RE_SIGNIFICANT.test(canonical);
-}
-
 export function computeLineHashes(content: string): string[] {
 	const lines = content.split("\n");
 	const hashes = new Array<string>(lines.length);
 	const counts = new Map<string, number>();
 	for (let i = 0; i < lines.length; i++) {
-		const lineNumber = i + 1;
 		const canonical = canonicalizeLine(lines[i]!);
-		let discriminator: string;
-		if (isSymbolOnly(canonical)) {
-			discriminator = SYMBOL_DISCRIMINATOR(lineNumber);
-		} else {
-			const occurrence = (counts.get(canonical) ?? 0) + 1;
-			counts.set(canonical, occurrence);
-			discriminator = CONTENT_DISCRIMINATOR(occurrence);
-		}
-		hashes[i] = hashToString(xxh32(`${discriminator}:${canonical}`));
+		const occurrence = (counts.get(canonical) ?? 0) + 1;
+		counts.set(canonical, occurrence);
+		hashes[i] = hashToString(xxh32(`${DISCRIMINATOR(occurrence)}:${canonical}`));
 	}
 	return hashes;
 }
 
 export function computeLineHash(idx: number, line: string): string {
 	const canonical = canonicalizeLine(line);
-	const discriminator = isSymbolOnly(canonical)
-		? SYMBOL_DISCRIMINATOR(idx)
-		: CONTENT_DISCRIMINATOR(1);
-	return hashToString(xxh32(`${discriminator}:${canonical}`));
+	return hashToString(xxh32(`${DISCRIMINATOR(1)}:${canonical}`));
 }
 
 export const HASH_FORMAT = {