pi-hashline-edit-pro 1.1.2 → 1.2.1

package/README.md

@@ -121,7 +121,7 @@ A no-op replace never changes the file, so anchors remain valid. On first run af
 Enabled by default. After a successful `write` that changes the file, the extension reads the file and appends an `--- Auto-read (hashline anchors) ---` block to the result, so the model gets immediate `HASH│content` anchors without a separate `read` call.
 
 - A no-op `replace` produces no diff — the file is unchanged, so existing anchors remain valid.
-- After `replace` / `undo_last_replace`, the success summary is replaced by the post-edit diff (the same `+HASH│` / `-   │` / ` HASH│` rows used for replace) plus any warnings, so the model sees the change like a git diff instead of line counts; no anchor block is appended — call `read` for fresh anchors.
+- After `replace` / `undo_last_replace`, the success summary is replaced by the post-edit diff (the same `+HASH│` / `-   │` / ` HASH│` rows used for replace) plus any warnings, so the model sees the change like a git diff instead of line counts; no anchor block is appended — the diff rows themselves are the fresh anchors (`+HASH│` and ` HASH│` rows carry the current hashes, and unchanged lines keep their previous hashes), so follow-up edits can anchor on the diff directly; call `read` when you want the full file's anchors.
 - With auto-read disabled, `replace` / `undo_last_replace` results keep the plain summary in the model-visible text — no diff and no anchor block reach the model (the post-edit diff is still shown to the user).
 - After `write`, the block dumps from the top of the file. For files over 2000 lines, the dump is truncated with a pagination hint — use `read` with `offset` to continue.
 - Auto-read keeps a 50KB display budget: lines over 50KB are skipped with a marker instead of their content (use `read` for lines up to 200KB).
@@ -179,7 +179,7 @@ Each line is canonicalized (carriage returns stripped, trailing whitespace trimm
 
 The alphabet is sized for an LLM consumer: the model tokenizes rather than squinting at glyphs, so 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, and `-`/`_` at a line start are markdown-active, inviting mis-copying and false autocorrections.
 
-**Unique anchors by construction.** If a line's base hash collides with an already-assigned hash, the next free hash is allocated from a bitset (O(1) amortized). Every line in a file therefore gets a unique anchor — two byte-identical lines (repeated `}`, repeated `import` statements) never share one. The same guarantee sets the file size cap: at most 238,328 lines per file, beyond which `read` and `replace` reject with `[E_FILE_TOO_LARGE]` (use `write` for very large files).
+**Unique anchors by construction.** If a line's base hash collides with an already-assigned hash, the next free hash is allocated from a bitset by probing with a stride coprime to the hash space (O(1) amortized). The stride is `62² + 62 + 1`, so consecutive collisions — runs of blank lines, repeated `}` — land on anchors that differ in all three characters instead of sharing a prefix. Every line in a file therefore gets a unique anchor — two byte-identical lines (repeated `}`, repeated `import` statements) never share one. The same guarantee sets the file size cap: at most 238,328 lines per file, beyond which `read` and `replace` reject with `[E_FILE_TOO_LARGE]` (use `write` for very large files).
 
 ## Design decisions
 
@@ -193,8 +193,9 @@ The alphabet is sized for an LLM consumer: the model tokenizes rather than squin
 
 - **Stale anchors.** `[E_STALE_ANCHOR]` / `[E_AMBIGUOUS_ANCHOR]` mean the file changed since the anchors were read, or an earlier `read` never happened. Call `read` for fresh anchors and retry.
 - **Reset the hash store.** Anchors live in `~/.config/pi-hashline-edit-pro/hash-store.sqlite` (with `-wal`/`-shm` sidecars). Quit pi, delete those three files, and the store is rebuilt on the next session. Anchor history is lost, but no project files are touched.
+- **Upgrading.** A hash-allocation change clears the hash store once on the first run after upgrade — anchors are rebuilt on the next read and undo history is lost, but no project files are touched.
 - **Corrupt store.** If the store fails its health check it is renamed to `hash-store.sqlite.corrupt-<timestamp>` (plus `-wal`/`-shm` variants) and rebuilt automatically; the quarantined files can be deleted once a healthy store exists.
-- **Legacy migration.** On first run after upgrading from an older version, the previous `hash-store.json` is imported once and renamed to `hash-store.json.bak`, which can be deleted.
+- **Legacy migration.** On first run after upgrading from an older version, the previous `hash-store.json` is imported once and renamed to `hash-store.json.bak`, which can be deleted. Legacy snapshots containing duplicate hashes are skipped and rebuilt on the next read.
 - **`[E_UNDO_UNAVAILABLE]`.** The edit was refused because the undo record could not be written — check disk space and that the config directory is writable, then retry.
 
 ## Development

package/index.ts

@@ -7,6 +7,7 @@ import { regRead, fmtReadPreview } from "./src/read";
 import type { RMetrics } from "./src/replace-response";
 import { extractWarnings } from "./src/replace-render";
 import { MAX_HASH_LINES } from "./src/hashline";
+import { AUTO_READ_MAX } from "./src/constants";
 import {
   readConfig,
   toggleAutoRead,
@@ -81,6 +82,7 @@ export default function (pi: ExtensionAPI): void {
           fileHashes,
           absolutePath,
           DEFAULT_MAX_BYTES,
+          AUTO_READ_MAX,
         );
         return {
           content: [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "1.1.2",
+  "version": "1.2.1",
   "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/prompts/read-guidelines.md

@@ -1,2 +1,2 @@
 - `read`: call before `replace` when you need fresh HASH anchors for a file.
-- `read`: call again after any edit to that file — changed lines get new anchors.
+- `read`: call again after any edit to that file — changed lines get new anchors (the post-edit diff rows from replace/undo also carry fresh anchors for the changed range).

package/prompts/replace-guidelines.md

@@ -4,3 +4,4 @@
 - `replace`: to replace a single line, repeat its hash in both positions of hash_range_inclusive: ["<HASH>", "<HASH>"] — never extend the range to neighboring lines for a one-line edit.
 - `replace`: content_lines is a native JSON array of strings — never a serialized JSON string. When copying a line from read output, remove its HASH│ prefix and keep the leading whitespace exactly as shown.
 - `replace`: content_lines entries are single lines — never embed a line break inside an entry; pass each line as its own array entry.
+- `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.

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

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

@@ -4,7 +4,7 @@ export const MAX_BYTES = 100 * 1024 * 1024;
 export const MAX_READ_LINE_BYTES = 200 * 1024;
 
 export const HASH_STORE_BUSY_TIMEOUT = 1000;
-export const HASH_STORE_VERSION = 4;
+export const HASH_STORE_VERSION = 5;
 export const CONTENT_LINES_NOT_STRING_MSG =
   `[E_BAD_SHAPE] "content_lines" must be a native JSON array of strings, not a JSON string.`
   + ` Do not serialize the array (e.g. '["line1", "line2"]') — pass it as a proper JSON array: ["line1", "line2"].`;

package/src/hash-store.ts

@@ -318,6 +318,10 @@ async function migrateLegacy(db: DatabaseSync): Promise<void> {
   const rows: [string, string, number, string, number][] = [];
   for (const [key, value] of Object.entries(raw)) {
     if (!isValidSnapshot(value)) continue;
+    if (new Set(value.hashes).size !== value.hashes.length) {
+      console.warn(`Skipped legacy snapshot with duplicate hashes for ${key}; it will be re-hashed on next read.`);
+      continue;
+    }
     rows.push([
       key,
       contentChecksum(value.content),

package/src/hashline/hash.ts

@@ -22,6 +22,8 @@ export const HASH_CLASS = `[${ALPH_SAFE}]{${HASH_LEN}}`;
 export const HASH_SPACE = ALPH.length ** HASH_LEN;
 export const MAX_HASH_LINES = HASH_SPACE;
 
+export const HASH_PROBE_STRIDE = ALPH.length ** 2 + ALPH.length + 1;
+
 function idxToHash(idx: number): string {
   let out = "";
   for (let j = 0; j < HASH_LEN; j++) {
@@ -66,44 +68,13 @@ function setBit(bits: Uint32Array, idx: number): void {
 }
 
 function nextZeroBit(bits: Uint32Array, start: number): number {
-  const totalWords = bits.length;
   const totalBits = HASH_SPACE;
-  const lastWordBits = HASH_SPACE - (totalWords - 1) * 32;
-
-  if (start >= totalBits) start = 0;
-
-  const wordIdx = start >>> 5;
-  const bitOffset = start & 31;
-  const wordBits = (w: number): number => (w === totalWords - 1 ? lastWordBits : 32);
-
-  let word = bits[wordIdx];
-  for (let b = bitOffset; b < wordBits(wordIdx); b++) {
-    if ((word >>> b & 1) === 0) return wordIdx * 32 + b;
-  }
-
-  for (let w = wordIdx + 1; w < totalWords; w++) {
-    word = bits[w];
-    if (~word !== 0) {
-      for (let b = 0; b < wordBits(w); b++) {
-        if ((word >>> b & 1) === 0) return w * 32 + b;
-      }
-    }
+  let idx = start % totalBits;
+  for (let i = 0; i < totalBits; i++) {
+    if (!getBit(bits, idx)) return idx;
+    idx += HASH_PROBE_STRIDE;
+    if (idx >= totalBits) idx -= totalBits;
   }
-
-  for (let w = 0; w < wordIdx; w++) {
-    word = bits[w];
-    if (~word !== 0) {
-      for (let b = 0; b < wordBits(w); b++) {
-        if ((word >>> b & 1) === 0) return w * 32 + b;
-      }
-    }
-  }
-
-  word = bits[wordIdx];
-  for (let b = 0; b < bitOffset; b++) {
-    if ((word >>> b & 1) === 0) return wordIdx * 32 + b;
-  }
-
   throw new Error(
     `[E_FILE_TOO_LARGE] Cannot allocate a unique hash anchor: the file exceeds the ${HASH_SPACE}-line limit for ${HASH_LEN}-char hashline anchors. For very large files use write or a non-line-based approach.`,
   );
@@ -112,13 +83,12 @@ function nextZeroBit(bits: Uint32Array, start: number): number {
 function assignHash(used: Uint32Array, baseIdx: number, hint: { value: number }): string {
   if (!getBit(used, baseIdx)) {
     setBit(used, baseIdx);
-    hint.value = baseIdx + 1;
+    hint.value = baseIdx + HASH_PROBE_STRIDE;
     return hashAt(baseIdx);
   }
-  const start = hint.value > baseIdx + 1 ? hint.value : baseIdx + 1;
-  const nextIdx = nextZeroBit(used, start);
+  const nextIdx = nextZeroBit(used, hint.value);
   setBit(used, nextIdx);
-  hint.value = nextIdx + 1;
+  hint.value = nextIdx + HASH_PROBE_STRIDE;
   return hashAt(nextIdx);
 }
 
@@ -277,7 +247,7 @@ function mapStableHashes(
     const idx = hashToIndex(hash);
     if (idx >= 0) {
       setBit(used, idx);
-      if (idx + 1 > hint.value) hint.value = idx + 1;
+      if (idx + HASH_PROBE_STRIDE > hint.value) hint.value = idx + HASH_PROBE_STRIDE;
     }
   };
 

package/src/hashline/index.ts

@@ -4,6 +4,7 @@ export {
 	HASH_SEP,
 	HASH_CLASS,
 	HASH_SPACE,
+	HASH_PROBE_STRIDE,
 	MAX_HASH_LINES,
 	HL_PREFIX_PLUS_RE,
 	HL_PREFIX_MINUS_RE,

package/src/hashline/resolve.ts

@@ -224,8 +224,12 @@ export function stripBarePrefixes(
 		matchedCount === 0
 			? "none of the stripped hashes match current file lines"
 			: `${matchedCount} of ${stripped.length} stripped hash(es) match current file lines`;
+	const guidance =
+		matchedCount === 0
+			? " Verify that these lines were pasted from read output; literal content starting with 'HASH│' would be altered by this strip."
+			: "";
 	warnings.push(
-		`[E_BARE_HASH_PREFIX] Autocorrected: stripped "HASH│" prefix copied from read output in ${locations} (${evidence}).`
+		`[E_BARE_HASH_PREFIX] Autocorrected: stripped "HASH│" prefix copied from read output in ${locations} (${evidence}).${guidance}`
 	);
 	return { ...edit, content_lines: contentLines };
 }

package/src/read.ts

@@ -3,6 +3,7 @@ import {
 	createReadTool,
 	formatSize,
 	truncateHead,
+	DEFAULT_MAX_LINES,
 	type TruncationResult,
 } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
@@ -57,6 +58,7 @@ export async function fmtReadPreview(
 	precomputedHashes?: string[],
 	path?: string,
 	maxLineBytes = MAX_READ_LINE_BYTES,
+	maxTruncLines = DEFAULT_MAX_LINES,
 ): Promise<{ text: string; truncation?: TruncationResult; nextOffset?: number }> {
 	const allLines = visLines(text);
 	const totalLines = allLines.length;
@@ -99,7 +101,7 @@ export async function fmtReadPreview(
 				? `[Line ${row.lineNumber} is ${formatSize(row.bytes)}, exceeds ${formatSize(maxBytes)}; content not shown. Use bash: sed -n '${row.lineNumber}p' <path> | head -c ${maxBytes}]`
 				: fmtRegion([selectedHashes[index]!], [selected[index]!]),
 		);
-		const skippedTruncation = truncateHead(rows.join("\n"), { maxBytes });
+		const skippedTruncation = truncateHead(rows.join("\n"), { maxBytes, maxLines: maxTruncLines });
 		const shownRowCount = skippedTruncation.content === "" ? 0 : skippedTruncation.content.split("\n").length;
 		const lastShownLine = shownRowCount > 0 ? startLine + shownRowCount - 1 : startLine - 1;
 		const lineLabel = oversized.length === 1 ? `Line ${oversized[0]!.lineNumber}` : `Lines ${oversized.map((row) => row.lineNumber).join(", ")}`;
@@ -121,7 +123,7 @@ export async function fmtReadPreview(
 		};
 	}
 
-	const truncation = truncateHead(formatted, { maxBytes });
+	const truncation = truncateHead(formatted, { maxBytes, maxLines: maxTruncLines });
 
 	let preview = truncation.content;
 	let nextOffset: number | undefined;

package/src/replace.ts

@@ -190,16 +190,16 @@ export async function execPipeline(
 
   const path = params.path;
 
-  const hashStore = options?.store ?? await loadHashStore();
+  const edit = resEdit({
+    hash_range_inclusive: params.hash_range_inclusive,
+    content_lines: params.content_lines,
+  });
 
+  const hashStore = options?.store ?? await loadHashStore();
   const { normalized: originalNormalized, bom, originalEnding, fileHashes: originalHashes, hadUtf8DecodeErrors, absolutePath } = await readNormFile(
     path, cwd, { signal: options?.signal, accessMode: options?.accessMode, maxLines: MAX_HASH_LINES, store: hashStore },
   );
 
-  const edit = resEdit({
-    hash_range_inclusive: params.hash_range_inclusive,
-    content_lines: params.content_lines,
-  });
   const anchorResult = applyEdit(
     originalNormalized,
     edit,