pi-hashline-edit-pro 0.16.9 → 0.16.11

package/index.ts

@@ -7,6 +7,7 @@ import { regReplaceFlat } from "./src/replace-flat";
 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 {
@@ -88,13 +89,14 @@ export default function (pi: ExtensionAPI): void {
 
     try {
       const absolutePath = isAbsolute(filePath) ? filePath : join(ctx.cwd, filePath);
-      const content = await readFile(absolutePath, "utf-8");
+      const resolvedPath = await resolveTarget(absolutePath);
+      const content = await readFile(resolvedPath, "utf-8");
       const { text: rawContent } = stripBOM(content);
       const normalized = toLF(rawContent);
 
       if (visLines(normalized).length === 0) return;
 
-      const preview = await fmtReadPreview(normalized, { limit: AUTO_READ_MAX }, undefined, absolutePath);
+      const preview = await fmtReadPreview(normalized, { limit: AUTO_READ_MAX }, undefined, resolvedPath);
 
       return {
         content: [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "0.16.9",
+  "version": "0.16.11",
   "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/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/fs-write.ts

@@ -1,13 +1,14 @@
 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";
@@ -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

@@ -3,7 +3,16 @@ import { stat } from "fs/promises";
 import { hashStorePath, hashStoreDir } from "./paths";
 import { errCode } from "./validation";
 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/hash.ts

@@ -1,6 +1,7 @@
 import xxhash from "xxhash-wasm";
 import * as Diff from "diff";
 import { loadHashStore, saveHashStore } from "../hash-store";
+import { MAX_HASH_RETRIES } from "../constants";
 
 export const HASH_LEN = 3;
 export const ANCHOR_LEN = HASH_LEN;
@@ -79,6 +80,7 @@ export function _lineHashesPure(content: string): string[] {
 		let retry = 0;
 		while (assigned.has(hash)) {
 			retry++;
+			if (retry > MAX_HASH_RETRIES) throw new Error("Hash space exhausted");
 			hash = h2s(xxh32(`${c}:R${retry}`));
 		}
 		assigned.add(hash);
@@ -170,6 +172,7 @@ function mapStableHashes(
     let hash = h2s(xxh32(c));
     while (used.has(hash)) {
       retry++;
+      if (retry > MAX_HASH_RETRIES) throw new Error("Hash space exhausted");
       hash = h2s(xxh32(`${c}:R${retry}`));
     }
     used.add(hash);

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;

package/src/hashline/resolve.ts

@@ -2,6 +2,7 @@ import { abortIf } from "../runtime";
 import { rejectUnknownFields } from "../utils";
 import { HL_BARE_PREFIX_RE } from "./hash";
 import { parseHashRef, parseText, type Anchor } from "./parse";
+import { CONTENT_LINES_NOT_STRING_MSG } from "../constants";
 
 export type RAnchor = {
 	line: number;
@@ -25,7 +26,6 @@ export interface BDupWarn {
 	kind: "trailing" | "leading";
 	survivingLineContent: string;
 	survivingLineIndex: number;
-	occurrence: number;
 	replacementLineContent: string;
 	editIndex: number;
 }
@@ -48,16 +48,12 @@ export type HTEdit = {
   hash_range_inclusive: [string, string];
 };
 
-function resAnchor(
+function resAnchorFromMap(
 	ref: Anchor,
-	fileLines: string[],
-	fileHashes: string[],
+	hashIndex: Map<string, number[]>,
 ): RAnchor | HMismatch {
-	const hashMatches: number[] = [];
-	for (let i = 0; i < fileHashes.length; i++) {
-		if (fileHashes[i] === ref.hash) hashMatches.push(i + 1);
-	}
-	if (hashMatches.length === 0) {
+	const hashMatches = hashIndex.get(ref.hash);
+	if (!hashMatches || hashMatches.length === 0) {
 		return { ref, kind: "not_found" };
 	}
 	if (hashMatches.length === 1) {
@@ -157,10 +153,7 @@ function assertItem(edit: Record<string, unknown>, index: number): void {
   if ("content_lines" in edit && !isStrArr(edit.content_lines)) {
     const val = edit.content_lines;
     if (typeof val === "string") {
-      throw new Error(
-        `[E_BAD_SHAPE] Edit ${index} field "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);
     }
     throw new Error(`[E_BAD_SHAPE] Edit ${index} field "content_lines" must be a string array.`);
   }
@@ -238,24 +231,22 @@ export function descEdit(edit: RHEdit): string {
 }
 
 function checkBoundaryDup(
-  adjacentLine: string | undefined,
-  replacementEdge: string | undefined,
-  kind: "trailing" | "leading",
-  survivingLineIndex: number,
-  fileLines: string[],
-  editIndex: number,
+	adjacentLine: string | undefined,
+	replacementEdge: string | undefined,
+	kind: "trailing" | "leading",
+	survivingLineIndex: number,
+	editIndex: number,
 ): BDupWarn | null {
-  if (
-    adjacentLine === undefined ||
-    replacementEdge === undefined ||
-    replacementEdge.length === 0 ||
-    replacementEdge !== adjacentLine
-  ) return null;
+	if (
+		adjacentLine === undefined ||
+		replacementEdge === undefined ||
+		replacementEdge.length === 0 ||
+		replacementEdge !== adjacentLine
+	) return null;
   return {
     kind,
     survivingLineContent: adjacentLine,
     survivingLineIndex,
-    occurrence: fileLines.slice(0, survivingLineIndex).filter((l) => l === adjacentLine).length,
     replacementLineContent: replacementEdge,
     editIndex,
   };
@@ -263,54 +254,62 @@ function checkBoundaryDup(
 
 
 export function valEdits(
-  edits: HEdit[],
-  fileLines: string[],
-  fileHashes: string[],
-  warnings: string[],
-  signal: AbortSignal | undefined,
+	edits: HEdit[],
+	fileLines: string[],
+	fileHashes: string[],
+	warnings: string[],
+	signal: AbortSignal | undefined,
 ): { resolved: RHEdit[]; mismatches: HMismatch[]; boundaryWarnings: BDupWarn[] } {
-  assertAligned(fileLines, fileHashes, "valEdits");
-  const resolved: RHEdit[] = [];
-  const mismatches: HMismatch[] = [];
-  const boundaryWarnings: BDupWarn[] = [];
-
-  const tryResolve = (ref: Anchor): RAnchor | undefined => {
-    const result = resAnchor(ref, fileLines, fileHashes);
-    if ("kind" in result) {
-      mismatches.push(result);
-      return undefined;
-    }
-    return result;
-  };
+	assertAligned(fileLines, fileHashes, "valEdits");
+	const resolved: RHEdit[] = [];
+	const mismatches: HMismatch[] = [];
+	const boundaryWarnings: BDupWarn[] = [];
 
-  for (const edit of edits) {
-    abortIf(signal);
-    const startResolved = tryResolve(edit.hash_range_inclusive[0]);
-    const endResolved = tryResolve(edit.hash_range_inclusive[1]);
-    if (!startResolved || !endResolved) {
-      continue;
-    }
-    if (startResolved.line > endResolved.line) {
-      throw new Error(
-        `[E_BAD_OP] Range start line ${startResolved.line} must be <= end line ${endResolved.line} (anchors ${edit.hash_range_inclusive[0].hash} and ${edit.hash_range_inclusive[1].hash}).`,
-      );
-    }
-    const endLine = endResolved.line;
-    const nextLine = fileLines[endLine];
-    const replacementLastLine = edit.content_lines.at(-1);
-    const trailing = checkBoundaryDup(nextLine, replacementLastLine, "trailing", endLine, fileLines, resolved.length);
-    if (trailing) boundaryWarnings.push(trailing);
-    const prevLine = fileLines[startResolved.line - 2];
-    const replacementFirstLine = edit.content_lines[0];
-    const leading = checkBoundaryDup(prevLine, replacementFirstLine, "leading", startResolved.line - 2, fileLines, resolved.length);
-    if (leading) boundaryWarnings.push(leading);
-    resolved.push({
-      content_lines: edit.content_lines,
-      hash_range_inclusive: [startResolved, endResolved],
-    });
-  }
+	const hashIndex = new Map<string, number[]>();
+	for (let i = 0; i < fileHashes.length; i++) {
+		const h = fileHashes[i]!;
+		const list = hashIndex.get(h) ?? [];
+		list.push(i + 1);
+		hashIndex.set(h, list);
+	}
+
+	const tryResolve = (ref: Anchor): RAnchor | undefined => {
+		const result = resAnchorFromMap(ref, hashIndex);
+		if ("kind" in result) {
+			mismatches.push(result);
+			return undefined;
+		}
+		return result;
+	};
+
+	for (const edit of edits) {
+		abortIf(signal);
+		const startResolved = tryResolve(edit.hash_range_inclusive[0]);
+		const endResolved = tryResolve(edit.hash_range_inclusive[1]);
+		if (!startResolved || !endResolved) {
+			continue;
+		}
+		if (startResolved.line > endResolved.line) {
+			throw new Error(
+				`[E_BAD_OP] Range start line ${startResolved.line} must be <= end line ${endResolved.line} (anchors ${edit.hash_range_inclusive[0].hash} and ${edit.hash_range_inclusive[1].hash}).`,
+			);
+		}
+		const endLine = endResolved.line;
+		const nextLine = fileLines[endLine];
+		const replacementLastLine = edit.content_lines.at(-1);
+		const trailing = checkBoundaryDup(nextLine, replacementLastLine, "trailing", endLine, resolved.length);
+		if (trailing) boundaryWarnings.push(trailing);
+		const prevLine = fileLines[startResolved.line - 2];
+		const replacementFirstLine = edit.content_lines[0];
+		const leading = checkBoundaryDup(prevLine, replacementFirstLine, "leading", startResolved.line - 2, resolved.length);
+		if (leading) boundaryWarnings.push(leading);
+		resolved.push({
+			content_lines: edit.content_lines,
+			hash_range_inclusive: [startResolved, endResolved],
+		});
+	}
 
-  return { resolved, mismatches, boundaryWarnings };
+	return { resolved, mismatches, boundaryWarnings };
 }
 
 export { warnUnicodeEsc };

package/src/replace-normalize.ts

@@ -1,15 +1,12 @@
 import { isRec, has } from "./utils";
-
+import { CONTENT_LINES_NOT_STRING_MSG } from "./constants";
 function assertContentLinesNotString(
-  value: unknown,
-  label: string,
+	value: unknown,
+	label: string,
 ): void {
-  if (typeof value === "string") {
-    throw new Error(
-      `[E_BAD_SHAPE] ${label}: "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"].`
-    );
-  }
+	if (typeof value === "string") {
+		throw new Error(CONTENT_LINES_NOT_STRING_MSG);
+	}
 }
 
 export function normalizeFilePath(record: Record<string, unknown>): void {