pi-hashline-edit-pro 0.16.10 → 0.16.12

package/index.ts

@@ -1,28 +1,31 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { readFile } from "fs/promises";
-import { join, isAbsolute } from "path";
 import { initHasher } from "./src/hashline";
-import { regReplace } from "./src/replace";
-import { regReplaceFlat } from "./src/replace-flat";
+import { regReplace, regReplaceFlat } from "./src/replace";
 import { regReplaceUndo } from "./src/replace-undo";
 import { regRead, fmtReadPreview } from "./src/read";
-import { toLF, stripBOM } from "./src/replace-diff";
-import { resolveTarget } from "./src/fs-write";
 import { visLines } from "./src/utils";
 import { AUTO_READ_MAX } from "./src/constants";
 import {
-  readReplaceMode,
+  readConfig,
   toggleReplaceMode,
-  readAutoRead,
   toggleAutoRead,
 } from "./src/config";
 import { loadHashStore, pruneHashStore } from "./src/hash-store";
+import { readNormFile } from "./src/file-reader";
 
 export default function (pi: ExtensionAPI): void {
   regRead(pi);
 
   regReplace(pi);
   regReplaceUndo(pi);
+
+function registerReplaceTool(pi: ExtensionAPI, mode: string, autoRead?: boolean): void {
+  if (mode === "flat") {
+    regReplaceFlat(pi, autoRead);
+  } else {
+    regReplace(pi, autoRead);
+  }
+}
   const debugValue = process.env.PI_HASHLINE_DEBUG;
   const autoReadValue = process.env.PI_HASHLINE_AUTO_READ;
   let autoRead = autoReadValue === "1" || autoReadValue === "true";
@@ -37,14 +40,11 @@ export default function (pi: ExtensionAPI): void {
     } catch (err) {
       console.error("Failed to load or prune hash store:", err);
     }
-    const mode = await readReplaceMode();
-    if (mode === "flat") {
-      regReplaceFlat(pi);
-    } else {
-      regReplace(pi);
-    }
+    const config = await readConfig();
+    const mode = config.replaceMode;
+    autoRead = config.autoRead;
+    registerReplaceTool(pi, mode, autoRead);
 
-    autoRead = await readAutoRead();
 
     if (debugValue === "1" || debugValue === "true") {
       ctx.ui.notify(`Hashline Edit mode active (${mode} replace)`, "info");
@@ -55,11 +55,7 @@ export default function (pi: ExtensionAPI): void {
     description: "Toggle replace tool between bulk (changes array) and flat (single edit at top level) mode",
     handler: async (_args, ctx) => {
       const mode = await toggleReplaceMode();
-      if (mode === "flat") {
-        regReplaceFlat(pi);
-      } else {
-        regReplace(pi);
-      }
+      registerReplaceTool(pi, mode, autoRead);
       ctx.ui.notify(`Replace mode switched to: ${mode}`, "info");
     },
   });
@@ -68,12 +64,8 @@ export default function (pi: ExtensionAPI): void {
     description: "Toggle automatic hashline anchors after write and replace operations",
     handler: async (_args, ctx) => {
       autoRead = await toggleAutoRead();
-      const mode = await readReplaceMode();
-      if (mode === "flat") {
-        regReplaceFlat(pi);
-      } else {
-        regReplace(pi);
-      }
+      const mode = (await readConfig()).replaceMode;
+      registerReplaceTool(pi, mode, autoRead);
       const state = autoRead ? "enabled" : "disabled";
       ctx.ui.notify(`Auto-read after write/replace: ${state}`, "info");
     },
@@ -88,15 +80,11 @@ export default function (pi: ExtensionAPI): void {
     if (typeof filePath !== "string") return;
 
     try {
-      const absolutePath = isAbsolute(filePath) ? filePath : join(ctx.cwd, filePath);
-      const resolvedPath = await resolveTarget(absolutePath);
-      const content = await readFile(resolvedPath, "utf-8");
-      const { text: rawContent } = stripBOM(content);
-      const normalized = toLF(rawContent);
+      const { normalized, fileHashes, absolutePath } = await readNormFile(filePath, ctx.cwd, undefined);
 
       if (visLines(normalized).length === 0) return;
 
-      const preview = await fmtReadPreview(normalized, { limit: AUTO_READ_MAX }, undefined, resolvedPath);
+      const preview = await fmtReadPreview(normalized, { limit: AUTO_READ_MAX }, fileHashes, absolutePath);
 
       return {
         content: [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "0.16.10",
+  "version": "0.16.12",
   "description": "Strict hashline read/replace tool for pi-coding-agent with hash-anchored edits (3-char, 18-bit, perfect hashing)",
   "main": "index.ts",
   "repository": {

package/prompts/read.md

@@ -1,5 +1,7 @@
 Read a text file. Each line is returned as `HASH│content`.
 
+Key rule: line numbers are NOT part of the output. Use the 3-char HASH to reference lines in replace calls. A HASH may change when the line content changes.
+
 HASH format:
 - The HASH is 3 characters from the URL-safe base64 alphabet `A-Za-z0-9-_` (e.g. `aB3`, `4yN`, `-qk`).
 - The content after the `│` separator is the line verbatim.

package/prompts/replace-guidelines.md

@@ -0,0 +1,6 @@
+{{MODE_PREFIX}}
+- After a successful replace, the response shows the change summary. {{AUTO_READ_GUIDANCE}}
+- On [E_STALE_ANCHOR], call read to get fresh anchors, copy the 3-character HASH of the start and end of the range into hash_range_inclusive, and retry.
+- hash_range_inclusive replaces the ENTIRE range inclusively. Every line from the first anchor through the second anchor is deleted. Only put replacement lines in content_lines — do not include lines that already exist outside the range.
+- Preserve leading whitespace exactly. The content after │ in read output includes all leading spaces and tabs — copy them into content_lines unchanged.
+- content_lines must be a native JSON array of strings, not a JSON string.

package/prompts/replace-snippet.md

@@ -0,0 +1 @@
+Replace lines in a text file via HASH anchors from read, {{MODE_PREFIX}}

package/prompts/replace.md

@@ -0,0 +1,33 @@
+Replace lines in a text file using HASH anchors from `read`.{{MODE_DESCRIPTION}}
+
+Workflow:
+1. Call `read` to get `HASH│content` lines for the file.
+2. Identify the range to replace using the 3-char hashes from the read output.
+3. Call `replace` with `hash_range_inclusive` (the two hashes) and `content_lines` (the new lines).
+4. On `[E_STALE_ANCHOR]`, call `read` again for fresh anchors, then retry.
+5. On success, call `read` to get fresh anchors for follow-up edits.
+
+Request structure:
+{{MODE_REQUEST_STRUCTURE}}
+
+Fields:
+- content_lines — replacement lines as a JSON array of strings. File content only — no HASH│ prefix.
+- hash_range_inclusive — [start_hash, end_hash] from read output. 3-char base64 hash only — no │ or line content.
+- path — file to edit.
+
+Examples:
+{{MODE_EXAMPLES}}
+
+Rules:
+- Anchors must be 3-char base64 hashes from the most recent read. Stale anchors fail with [E_STALE_ANCHOR].
+- The range is inclusive: every line from start_hash through end_hash is deleted.
+- Those lines are replaced with content_lines — nothing is inserted, nothing is appended.
+- content_lines is literal file content. Never include the HASH│ prefix — that goes in hash_range_inclusive.
+- content_lines must be a native JSON array of strings, not a serialized string.
+- Preserve leading whitespace exactly as it appears after │ in read output.
+- To delete lines, use content_lines: [].
+- If content_lines matches current content, the edit is a noop (file unchanged).
+{{MODE_RULES}}
+On success, the response shows the change summary. {{AUTO_READ_GUIDANCE}}
+
+Recovery: If a replace produces incorrect results, call undo_last_replace with the file path to revert.

package/src/config.ts

@@ -1,10 +1,8 @@
-import { readFileSync } from "fs";
 import { readFile, writeFile, mkdir } from "fs/promises";
 import { configDir, configPath } from "./paths";
-import { errCode } from "./validation";
+import { errCode } from "./utils";
 
 export type ReplaceMode = "bulk" | "flat";
-
 export interface Config {
   replaceMode: ReplaceMode;
   autoRead: boolean;
@@ -15,14 +13,17 @@ const DEFAULT_CONFIG: Config = {
   autoRead: false
 };
 
+function parseConfig(content: string): Config {
+  const parsed = JSON.parse(content) as Partial<Config>;
+  return {
+    replaceMode: parsed.replaceMode === "flat" ? "flat" : "bulk",
+    autoRead: parsed.autoRead === true,
+  };
+}
 export async function readConfig(): Promise<Config> {
   try {
     const content = await readFile(configPath(), "utf-8");
-    const parsed = JSON.parse(content) as Partial<Config>;
-    return {
-      replaceMode: parsed.replaceMode === "flat" ? "flat" : "bulk",
-      autoRead: parsed.autoRead === true,
-    };
+    return parseConfig(content);
   } catch (error: unknown) {
     if (errCode(error) !== "ENOENT") {
       console.error("Config file corrupted, using defaults:", error);
@@ -30,38 +31,11 @@ export async function readConfig(): Promise<Config> {
     return { ...DEFAULT_CONFIG };
   }
 }
-
-export function readConfigSync(): Config {
-  try {
-    const content = readFileSync(configPath(), "utf-8");
-    const parsed = JSON.parse(content) as Partial<Config>;
-    return {
-      replaceMode: parsed.replaceMode === "flat" ? "flat" : "bulk",
-      autoRead: parsed.autoRead === true,
-    };
-  } catch (error: unknown) {
-    if (errCode(error) !== "ENOENT") {
-      console.error("Config file corrupted, using defaults:", error);
-    }
-    return { ...DEFAULT_CONFIG };
-  }
-}
-
 export async function writeConfig(config: Config): Promise<void> {
   await mkdir(configDir(), { recursive: true });
   await writeFile(configPath(), JSON.stringify(config, null, 2), "utf-8");
 }
 
-export async function readReplaceMode(): Promise<ReplaceMode> {
-  const config = await readConfig();
-  return config.replaceMode;
-}
-
-export async function writeReplaceMode(mode: ReplaceMode): Promise<void> {
-  const config = await readConfig();
-  config.replaceMode = mode;
-  await writeConfig(config);
-}
 
 export async function toggleReplaceMode(): Promise<ReplaceMode> {
   const config = await readConfig();
@@ -70,21 +44,6 @@ export async function toggleReplaceMode(): Promise<ReplaceMode> {
   return config.replaceMode;
 }
 
-export async function readAutoRead(): Promise<boolean> {
-  const config = await readConfig();
-  return config.autoRead;
-}
-
-export function readAutoReadSync(): boolean {
-  const config = readConfigSync();
-  return config.autoRead;
-}
-
-export async function writeAutoRead(value: boolean): Promise<void> {
-  const config = await readConfig();
-  config.autoRead = value;
-  await writeConfig(config);
-}
 
 export async function toggleAutoRead(): Promise<boolean> {
   const config = await readConfig();

package/src/constants.ts

@@ -3,3 +3,8 @@ export const SNIFF_BYTES = 8192;
 export const MAX_BYTES = 100 * 1024 * 1024;
 
 export const MAX_HASH_LINES = 1_000_000;
+export const MAX_HASH_RETRIES = 262_144;
+
+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/file-reader.ts

@@ -1,12 +1,14 @@
 import { constants } from "fs";
+import { stat } from "fs/promises";
 import { lineHashes } from "./hashline";
 import { loadFileKindAndText, type LFile } from "./file-kind";
 import { resolveTarget } from "./fs-write";
-import { toCwd } from "./path-utils";
+import { toCwd } from "./paths";
 import { detectEnding, toLF, stripBOM } from "./replace-diff";
-import { abortIf } from "./runtime";
-import { assertText, valAccess } from "./validation";
+import { abortIf } from "./utils";
+import { valKind, valAccess } from "./validation";
 import { visLines } from "./utils";
+import type { HashStore } from "./hash-store";
 export interface NormFile {
   absolutePath: string;
   normalized: string;
@@ -16,6 +18,26 @@ export interface NormFile {
   hadUtf8DecodeErrors: boolean;
 }
 
+export type SnapInfo = {
+  snapshotId: string;
+  mtimeMs: number;
+  size: number;
+};
+
+function fmtSnapId(canonicalPath: string, info: { mtimeMs: number; size: number }): string {
+  return `v1|${canonicalPath}|${info.mtimeMs}|${info.size}`;
+}
+
+export async function fileSnap(absolutePath: string): Promise<SnapInfo> {
+  const canonicalPath = await resolveTarget(absolutePath);
+  const stats = await stat(canonicalPath);
+  return {
+    snapshotId: fmtSnapId(canonicalPath, stats),
+    mtimeMs: stats.mtimeMs,
+    size: stats.size,
+  };
+}
+
 export async function readNormFile(
   path: string,
   cwd: string,
@@ -23,6 +45,7 @@ export async function readNormFile(
   accessMode: number = constants.R_OK,
   preloadedFile?: LFile,
   maxLines?: number,
+  store?: HashStore,
 ): Promise<NormFile> {
   const absolutePath = toCwd(path, cwd);
   const resolvedPath = await resolveTarget(absolutePath);
@@ -32,7 +55,7 @@ export async function readNormFile(
 
   abortIf(signal);
   const file = preloadedFile ?? (await loadFileKindAndText(resolvedPath));
-  assertText(file, path);
+  valKind(file, path);
 
   abortIf(signal);
   const { bom, text: rawContent } = stripBOM(file.text);
@@ -48,7 +71,7 @@ export async function readNormFile(
     }
   }
 
-  const fileHashes = await lineHashes(normalized, resolvedPath);
+  const fileHashes = await lineHashes(normalized, resolvedPath, undefined, store);
   return {
     absolutePath: resolvedPath,
     normalized,

package/src/fs-write.ts

@@ -1,16 +1,17 @@
 import { randomUUID } from "crypto";
 import {
-  lstat,
-  mkdir,
-  open,
-  readlink,
-  rename,
-  rm,
-  stat,
-  writeFile,
+	lstat,
+	mkdir,
+	open,
+	readlink,
+	rename,
+	rm,
+	stat,
+	writeFile,
+	copyFile,
 } from "fs/promises";
 import { dirname, join, parse, resolve, sep } from "path";
-import { errCode } from "./validation";
+import { errCode } from "./utils";
 
 export async function resolveTarget(path: string): Promise<string> {
   const absolutePath = resolve(path);
@@ -108,6 +109,17 @@ export async function writeAtomic(
     await tempHandle.close();
     await rename(tempPath, targetPath);
   } catch (error: unknown) {
+    if (errCode(error) === "EXDEV") {
+      try {
+        await tempHandle.close();
+        await copyFile(tempPath, targetPath);
+        await rm(tempPath, { force: true });
+        return;
+      } catch {
+        try { await rm(tempPath, { force: true }); } catch {}
+        throw error;
+      }
+    }
     try { await rm(tempPath, { force: true }); } catch {}
     throw error;
   }

package/src/hash-store.ts

@@ -1,9 +1,18 @@
 import { readFile, mkdir } from "fs/promises";
 import { stat } from "fs/promises";
 import { hashStorePath, hashStoreDir } from "./paths";
-import { errCode } from "./validation";
+import { errCode } from "./utils";
 import { writeAtomic } from "./fs-write";
-
+function isValidSnapshot(value: unknown): value is FileSnapshot {
+  if (typeof value !== "object" || value === null) return false;
+  const v = value as Record<string, unknown>;
+  if (typeof v.content !== "string") return false;
+  if (!Array.isArray(v.hashes)) return false;
+  for (const h of v.hashes) {
+    if (typeof h !== "string") return false;
+  }
+  return true;
+}
 export interface FileSnapshot {
   content: string;
   hashes: string[];
@@ -18,10 +27,16 @@ export async function loadHashStore(): Promise<HashStore> {
   try {
     const content = await readFile(hashStorePath(), "utf-8");
     const parsed = JSON.parse(content) as Partial<HashStore>;
-    return {
-      version: 1,
-      snapshots: parsed.snapshots ?? {},
-    };
+    const raw = parsed.snapshots;
+    const snapshots: Record<string, FileSnapshot> = {};
+    if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+      for (const [key, value] of Object.entries(raw)) {
+        if (isValidSnapshot(value)) {
+          snapshots[key] = value;
+        }
+      }
+    }
+    return { version: 1, snapshots };
   } catch (error: unknown) {
     if (errCode(error) !== "ENOENT") {
       console.error("Hash store corrupted, creating fresh store:", error);

package/src/hashline/apply.ts

@@ -1,4 +1,4 @@
-import { abortIf } from "../runtime";
+import { abortIf } from "../utils";
 import { _lineHashesPure, HASH_SEP } from "./hash";
 import {
 	valEdits,
@@ -12,7 +12,7 @@ import {
 	type BDupWarn,
 	type AutoFix,
 } from "./resolve";
-import { cntLines } from "../utils";
+import { visLines } from "../utils";
 
 type LIdx = {
 	fileLines: string[];
@@ -377,14 +377,14 @@ export function changedRange(
 	if (original.length === 0) {
 		return {
 			firstChangedLine: 1,
-			lastChangedLine: cntLines(result),
+			lastChangedLine: visLines(result).length,
 		};
 	}
 
 	if (result.startsWith(original) && original.endsWith("\n")) {
 		return {
-			firstChangedLine: cntLines(original) + 1,
-			lastChangedLine: cntLines(result),
+			firstChangedLine: visLines(original).length + 1,
+			lastChangedLine: visLines(result).length,
 		};
 	}
 
@@ -417,7 +417,7 @@ export function changedRange(
 	const firstChangedLine = idxToLine(firstDiff + 1, result);
 	let lastChangedLine: number;
 	if (lastRes < firstDiff) {
-		lastChangedLine = result.length === 0 ? 1 : cntLines(result);
+		lastChangedLine = result.length === 0 ? 1 : visLines(result).length;
 	} else if (
 		firstDiff === 0 &&
 		original.length > 0 &&

package/src/hashline/hash.ts

@@ -1,6 +1,7 @@
 import xxhash from "xxhash-wasm";
 import * as Diff from "diff";
-import { loadHashStore, saveHashStore } from "../hash-store";
+import { loadHashStore, saveHashStore, type HashStore } from "../hash-store";
+import { MAX_HASH_RETRIES } from "../constants";
 
 export const HASH_LEN = 3;
 export const ANCHOR_LEN = HASH_LEN;
@@ -69,19 +70,25 @@ function canon(line: string): string {
 	return line.replace(/\r/g, "").trimEnd();
 }
 
+function nextUniqueHash(content: string, used: Set<string>): string {
+	let retry = 0;
+	let hash = h2s(xxh32(content));
+	while (used.has(hash)) {
+		retry++;
+		if (retry > MAX_HASH_RETRIES) throw new Error("Hash space exhausted");
+		hash = h2s(xxh32(`${content}:R${retry}`));
+	}
+	used.add(hash);
+	return hash;
+}
+
 export function _lineHashesPure(content: string): string[] {
 	const lines = content.split("\n");
 	const hashes = new Array<string>(lines.length);
 	const assigned = new Set<string>();
 	for (let i = 0; i < lines.length; i++) {
 		const c = canon(lines[i]!);
-		let hash = h2s(xxh32(c));
-		let retry = 0;
-		while (assigned.has(hash)) {
-			retry++;
-			hash = h2s(xxh32(`${c}:R${retry}`));
-		}
-		assigned.add(hash);
+		const hash = nextUniqueHash(c, assigned);
 		hashes[i] = hash;
 	}
 	return hashes;
@@ -91,12 +98,13 @@ export async function lineHashes(
   content: string,
   path?: string,
   previous?: { content: string; hashes: string[]; removedHashes?: Set<string> },
+  store?: HashStore,
 ): Promise<string[]> {
   if (!path) {
     return _lineHashesPure(content);
   }
 
-  const store = await loadHashStore();
+  const hashStore = store ?? await loadHashStore();
 
   if (previous) {
     const newHashes = mapStableHashes(
@@ -104,19 +112,19 @@ export async function lineHashes(
       content,
       previous.removedHashes,
     );
-    store.snapshots[path] = { content, hashes: newHashes };
-    await saveHashStore(store);
+    hashStore.snapshots[path] = { content, hashes: newHashes };
+    await saveHashStore(hashStore);
     return newHashes;
   }
 
-  const snapshot = store.snapshots[path];
+  const snapshot = hashStore.snapshots[path];
   if (snapshot && snapshot.content === content) {
     return snapshot.hashes;
   }
 
   const newHashes = _lineHashesPure(content);
-  store.snapshots[path] = { content, hashes: newHashes };
-  await saveHashStore(store);
+  hashStore.snapshots[path] = { content, hashes: newHashes };
+  await saveHashStore(hashStore);
   return newHashes;
 }
 
@@ -166,13 +174,7 @@ function mapStableHashes(
   for (let i = 0; i < newLines.length; i++) {
     if (newHashes[i]) continue;
     const c = canon(newLines[i]!);
-    let retry = 0;
-    let hash = h2s(xxh32(c));
-    while (used.has(hash)) {
-      retry++;
-      hash = h2s(xxh32(`${c}:R${retry}`));
-    }
-    used.add(hash);
+    const hash = nextUniqueHash(c, used);
     newHashes[i] = hash;
   }
   return newHashes;

package/src/hashline/parse.ts

@@ -5,6 +5,7 @@ import {
 	HL_PREFIX_PLUS_RE,
 	DIFF_MINUS_RE,
 } from "./hash";
+import { CONTENT_LINES_NOT_STRING_MSG } from "../constants";
 
 export type Anchor = { hash: string };
 
@@ -58,10 +59,7 @@ function assertNoPrefixes(lines: string[]): void {
 export function parseText(edit: string[] | string | null): string[] {
   if (edit === null) return [];
   if (typeof edit === "string") {
-    throw new Error(
-      `[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"].`
-    );
+    throw new Error(CONTENT_LINES_NOT_STRING_MSG);
   }
   assertNoPrefixes(edit);
   return edit;