pi-hashline-edit-pro 0.17.4 → 0.17.6

package/README.md

@@ -154,6 +154,8 @@ 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.
 
+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.
+
 **Perfect hashing (collision resolution):** When computing hashes for a file, if a line's base hash collides with an already-assigned hash, the hash is incremented (using a retry counter: `:R{retry}`) until a unique hash is found. This ensures every line in a file gets a unique anchor, even with the shorter 3-character hash space. Two byte-identical lines (e.g. repeated `}` or repeated `import` statements) get different hashes automatically.
 The runtime always precomputes the full per-line hash array for a file via `lineHashes(content, path)`, then looks up by line number during validation and during `read` / `replace` response formatting. There is no per-line recomputation that could disagree with what the model saw in its last read. When `path` is provided, `lineHashes` uses a persistent store to preserve hashes for unchanged lines across edits — see [Stable hashing across edits](#stable-hashing-across-edits).
 `HASH_LEN` in `src/hashline/hash.ts` sets the hash body length; bump it to 4 if you need even more entropy without collision resolution.

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "0.17.4",
+  "version": "0.17.6",
+  "type": "module",
   "description": "Strict hashline read/replace tool for pi-coding-agent with hash-anchored edits (3-char, 18-bit, perfect hashing)",
   "main": "index.ts",
   "repository": {
@@ -45,15 +46,20 @@
   "scripts": {
     "test": "vitest run",
     "test:watch": "vitest",
+    "lint": "eslint 'src/**/*.ts' 'index.ts'",
     "typecheck": "tsc --noEmit",
-    "postinstall": "node scripts/ensure-better-sqlite3.js"
+    "postinstall": "node scripts/ensure-better-sqlite3.js",
+    "preuninstall": "node scripts/cleanup-better-sqlite3.js"
   },
   "devDependencies": {
     "@earendil-works/pi-coding-agent": "^0.74.0",
+    "@eslint/js": "^10.0.1",
     "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^22.0.0",
     "@types/sql.js": "^1.4.11",
+    "eslint": "^10.7.0",
     "typescript": "^5.8.0",
+    "typescript-eslint": "^8.65.0",
     "vitest": "^4.1.8"
   },
   "allowScripts": {

package/scripts/cleanup-better-sqlite3.js

@@ -0,0 +1,17 @@
+const fs = require("fs");
+const path = require("path");
+
+const parentNodeModules = path.resolve(__dirname, "..", "node_modules");
+if (!fs.existsSync(parentNodeModules)) process.exit(0);
+
+const entries = fs.readdirSync(parentNodeModules, { withFileTypes: true });
+for (const entry of entries) {
+  if (entry.name.startsWith(".better-sqlite3-")) {
+    const full = path.join(parentNodeModules, entry.name);
+    try {
+      fs.rmSync(full, { recursive: true, force: true });
+      console.error("Cleaned up stale better-sqlite3 build artifact:", entry.name);
+    } catch {
+    }
+  }
+}

package/scripts/ensure-better-sqlite3.js

@@ -3,15 +3,38 @@ const fs = require("fs");
 const path = require("path");
 
 const root = path.resolve(__dirname, "..");
+const bsqlDir = path.join(root, "node_modules", "better-sqlite3");
+
+function removeStaleArtifacts() {
+  for (const dir of [root, bsqlDir]) {
+    if (!fs.existsSync(dir)) continue;
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name.startsWith(".better-sqlite3-")) {
+        const full = path.join(dir, entry.name);
+        try {
+          fs.rmSync(full, { recursive: true, force: true });
+          console.error("Removed stale artifact:", entry.name);
+        } catch {
+        }
+      }
+    }
+  }
+  const buildDir = path.join(bsqlDir, "build");
+  if (fs.existsSync(buildDir)) {
+    fs.rmSync(buildDir, { recursive: true, force: true });
+  }
+}
 
 try {
-  require(path.join(root, "node_modules", "better-sqlite3"));
+  require(bsqlDir);
   process.exit(0);
 } catch (e) {
   const msg = e && typeof e.message === "string" ? e.message : String(e);
   if (/GLIBC|Cannot find module|dlo|not found/i.test(msg)) {
     console.error("better-sqlite3 prebuilt incompatible, rebuilding from source...");
-    const prebuildDir = path.join(root, "node_modules", "better-sqlite3", "prebuilds");
+    removeStaleArtifacts();
+    const prebuildDir = path.join(bsqlDir, "prebuilds");
     if (fs.existsSync(prebuildDir)) {
       const platform = process.platform + "-" + process.arch;
       const prebuilt = path.join(prebuildDir, platform + ".node");
@@ -20,11 +43,12 @@ try {
         console.error("Removed incompatible prebuilt:", platform + ".node");
       }
     }
+
     try {
-      execSync("npm rebuild better-sqlite3", {
-        cwd: root,
+      execSync("npx --yes node-gyp rebuild", {
+        cwd: bsqlDir,
         stdio: "inherit",
-        timeout: 120000,
+        timeout: 300000,
       });
       console.error("better-sqlite3 rebuilt successfully from source.");
     } catch (rebuildErr) {

package/src/hash-store.ts

@@ -36,7 +36,7 @@ function isValidSnapshot(value: unknown): value is LegacySnapshot {
   return true;
 }
 
-// ── Backend handle abstraction ──────────────────────────────────────
+
 
 interface BackendHandle {
   store: HashStore;
@@ -47,7 +47,7 @@ interface BackendHandle {
 
 let cachedHandle: { path: string; handle: BackendHandle } | null = null;
 
-// ── better-sqlite3 backend ──────────────────────────────────────────
+
 
 let BetterDatabase: any = undefined;
 
@@ -104,7 +104,7 @@ function openBetterDb(storePath: string): BackendHandle {
   };
 }
 
-// ── sql.js backend ──────────────────────────────────────────────────
+
 
 let SqlJsDatabase: any = null;
 let sqlJsPromise: Promise<void> | null = null;
@@ -182,7 +182,7 @@ function openSqlJsDb(storePath: string): BackendHandle {
   };
 }
 
-// ── Init ────────────────────────────────────────────────────────────
+
 
 let backendPromise: Promise<void> | null = null;
 
@@ -195,7 +195,7 @@ async function initBackend(): Promise<void> {
   return backendPromise;
 }
 
-// ── Public API ──────────────────────────────────────────────────────
+
 
 export async function loadHashStore(): Promise<HashStore> {
   const storePath = hashStorePath();
@@ -234,7 +234,7 @@ export function shutdownHashStore(): void {
   }
 }
 
-// ── Internal helpers ────────────────────────────────────────────────
+
 
 function withStore(store: HashStore, fn: () => void): void {
   const h = cachedHandle?.handle;
@@ -296,7 +296,7 @@ async function migrateLegacy(handle: BackendHandle): Promise<void> {
   }
 }
 
-// ── Snapshot operations ─────────────────────────────────────────────
+
 
 export function getSnapshot(
   store: HashStore,

package/src/hashline/apply.ts

@@ -9,14 +9,12 @@ import {
 	type RHEdit,
 	type NEdit,
 	type HEdit,
-	type BDupWarn,
 	type AutoFix,
 } from "./resolve";
 
 type LIdx = {
 	fileLines: string[];
 	lineStarts: number[];
-	hasTerminalNewline: boolean;
 };
 
 export function buildIdx(content: string): LIdx {
@@ -35,7 +33,6 @@ export function buildIdx(content: string): LIdx {
 	return {
 		fileLines,
 		lineStarts,
-		hasTerminalNewline: content.endsWith("\n"),
 	};
 };
 
@@ -73,7 +70,7 @@ function resToSpan(
   lineIndex: LIdx,
   noopEdits: NEdit[],
 ): RESpan | null {
-  const { fileLines, lineStarts, hasTerminalNewline } = lineIndex;
+  const { fileLines, lineStarts } = lineIndex;
 
   const startLine = edit.hash_range_inclusive[0].line;
   const endLine = edit.hash_range_inclusive[1].line;

package/src/hashline/hash.ts

@@ -25,7 +25,7 @@ export const HASH_CLASS = `[${ALPH_SAFE}]{${HASH_LEN}}`;
 function h2s(h: number): string {
 	const totalBits = HASH_LEN * ALPH_BITS;
 	const shift = 32 - totalBits;
-	let n = h >>> shift;
+	const n = h >>> shift;
 	let out = "";
 	for (let j = 0; j < HASH_LEN; j++) {
 		out +=
@@ -142,12 +142,13 @@ function mapStableHashes(
     if (!candidates || candidates.length === 0) continue;
 
     let bestIdx = 0;
-    if (removedHashes && removedHashes.size > 0) {
-      for (let j = 0; j < candidates.length; j++) {
-        if (!removedHashes.has(candidates[j]!.hash)) {
-          bestIdx = j;
-          break;
-        }
+    let bestDist = Infinity;
+    for (let j = 0; j < candidates.length; j++) {
+      if (removedHashes?.has(candidates[j]!.hash)) continue;
+      const dist = Math.abs(candidates[j]!.index - i);
+      if (dist < bestDist) {
+        bestDist = dist;
+        bestIdx = j;
       }
     }
 

package/src/hashline/parse.ts

@@ -1,7 +1,6 @@
 import {
 	ANCHOR_LEN,
 	ALPH_RE,
-	HASH_CLASS,
 	HL_PREFIX_PLUS_RE,
 	DIFF_MINUS_RE,
 } from "./hash";

package/src/replace-diff.ts

@@ -45,16 +45,12 @@ export function genDiff(
   newContent: string,
   contextLines = 2,
   newContentHashes?: string[],
-  oldHashes?: string[],
+  _oldHashes?: string[],
 ): { diff: string; firstChangedLine: number | undefined } {
-  const oldLines = oldContent.split("\n");
-  const newLines = newContent.split("\n");
-  const effectiveOldHashes = oldHashes ?? _lineHashesPure(oldContent);
   const effectiveNewHashes = newContentHashes ?? _lineHashesPure(newContent);
 
   const parts = Diff.diffLines(oldContent, newContent);
   const output: string[] = [];
-  let oldLineNum = 1;
   let newLineNum = 1;
   let lastWasChange = false;
   let firstChangedLine: number | undefined;
@@ -74,7 +70,6 @@ export function genDiff(
           newLineNum++;
         } else {
           output.push(fmtDiffLine("-", displayLines[k]!, undefined));
-          oldLineNum++;
         }
       }
       lastWasChange = true;
@@ -86,7 +81,6 @@ export function genDiff(
     if (lastWasChange || nextPartIsChange) {
       let linesToShow = displayLines;
       let skipStart = 0;
-      let skipEnd = 0;
       let skipMiddle = 0;
 
       if (!lastWasChange) {
@@ -97,29 +91,24 @@ export function genDiff(
         linesToShow = [...displayLines.slice(0, contextLines), "__ELLIPSIS__", ...tail];
         skipMiddle = displayLines.length - contextLines * 2;
       } else if (linesToShow.length > contextLines) {
-        skipEnd = linesToShow.length - contextLines;
         linesToShow = linesToShow.slice(0, contextLines);
       }
 
       if (skipStart > 0) {
         output.push(" ...");
-        oldLineNum += skipStart;
         newLineNum += skipStart;
       }
       for (const line of linesToShow) {
         if (line === "__ELLIPSIS__") {
           output.push(" ...");
-          oldLineNum += skipMiddle;
           newLineNum += skipMiddle;
           continue;
         }
         const hash = effectiveNewHashes[newLineNum - 1];
         output.push(fmtDiffLine(" ", line, hash));
-        oldLineNum++;
         newLineNum++;
       }
     } else {
-      oldLineNum += displayLines.length;
       newLineNum += displayLines.length;
     }
     lastWasChange = false;

package/src/replace-normalize.ts

@@ -1,7 +1,7 @@
 import { isRec, has } from "./utils";
 import { CONTENT_LINES_NOT_STRING_MSG } from "./constants";
 
-function tryParseContentLines(record: Record<string, unknown>, key: string, label: string): void {
+function tryParseContentLines(record: Record<string, unknown>, key: string): void {
   const val = record[key];
   if (typeof val !== "string") return;
   try {
@@ -11,7 +11,7 @@ function tryParseContentLines(record: Record<string, unknown>, key: string, labe
       return;
     }
   } catch {
-    // fall through to error
+    
   }
   throw new Error(CONTENT_LINES_NOT_STRING_MSG);
 }
@@ -43,7 +43,7 @@ function normalizeField(
         record[to] = [parsed];
       }
     } catch {
-      // not valid JSON, leave as-is for downstream validation
+      
     }
   }
   if (from !== to) delete record[from];
@@ -59,7 +59,7 @@ export function normReq(input: unknown): unknown {
   normalizeFilePath(record);
 
   if (has(record, "content_lines") && typeof record.content_lines === "string") {
-    tryParseContentLines(record, "content_lines", "Top-level");
+    tryParseContentLines(record, "content_lines");
   }
 
   normalizeField(record, "changes", "changes");
@@ -69,7 +69,7 @@ export function normReq(input: unknown): unknown {
     for (let i = 0; i < record.changes.length; i++) {
       const item = record.changes[i];
       if (isRec(item) && has(item, "content_lines") && typeof item.content_lines === "string") {
-        tryParseContentLines(item, "content_lines", `changes[${i}]`);
+        tryParseContentLines(item, "content_lines");
       }
     }
   }

package/src/replace-response.ts

@@ -1,6 +1,6 @@
 import type { ReplaceDetails } from "./replace";
 import { genDiff } from "./replace-diff";
-import { visLines, cntDiff } from "./utils";
+import { visLines } from "./utils";
 
 type TResult = {
 	content: Array<{ type: "text"; text: string }>;