pi-hashline-edit-pro 0.17.11 → 0.17.13

package/index.ts

@@ -13,12 +13,6 @@ import {
 import { loadHashStore, pruneMissing } 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);
@@ -26,6 +20,13 @@ function registerReplaceTool(pi: ExtensionAPI, mode: string, autoRead?: boolean)
     regReplace(pi, autoRead);
   }
 }
+
+export default function (pi: ExtensionAPI): void {
+  regRead(pi);
+
+  regReplace(pi);
+  regReplaceUndo(pi);
+
   const debugValue = process.env.PI_HASHLINE_DEBUG;
   const autoReadValue = process.env.PI_HASHLINE_AUTO_READ;
   let autoRead = autoReadValue === "1" || autoReadValue === "true";
@@ -80,7 +81,7 @@ function registerReplaceTool(pi: ExtensionAPI, mode: string, autoRead?: boolean)
     if (typeof filePath !== "string") return;
 
     try {
-      const { normalized, fileHashes, absolutePath } = await readNormFile(filePath, ctx.cwd, undefined);
+      const { normalized, fileHashes, absolutePath } = await readNormFile(filePath, ctx.cwd);
 
       if (visLines(normalized).length === 0) return;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "0.17.11",
+  "version": "0.17.13",
   "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",

package/scripts/cleanup-better-sqlite3.cjs

@@ -1,17 +1,21 @@
 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 {
+function cleanNodeModules(nm) {
+  if (!fs.existsSync(nm)) return;
+  const entries = fs.readdirSync(nm, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name.startsWith(".better-sqlite3-")) {
+      const full = path.join(nm, entry.name);
+      try {
+        fs.rmSync(full, { recursive: true, force: true });
+        console.error("Cleaned up stale better-sqlite3 build artifact:", entry.name);
+      } catch {
+      }
     }
   }
 }
+
+const pkgDir = path.resolve(__dirname, "..");
+cleanNodeModules(path.resolve(pkgDir, "node_modules"));
+cleanNodeModules(path.resolve(pkgDir, "..", "node_modules"));

package/src/file-kind.ts

@@ -81,24 +81,19 @@ export async function loadFileKindAndText(
     }
 
 
-    const decoder = new TextDecoder("utf-8");
-    const fatalDecoder = new TextDecoder("utf-8", { fatal: true });
+    const decoder = new TextDecoder("utf-8", { fatal: false });
     let hadUtf8DecodeErrors = false;
-    const noteUtf8Err = (chunk?: Uint8Array): void => {
-      if (hadUtf8DecodeErrors) return;
-      try {
-        fatalDecoder.decode(chunk, { stream: chunk !== undefined });
-      } catch (error: unknown) {
-        if (error instanceof TypeError) {
-          hadUtf8DecodeErrors = true;
-          return;
-        }
-        throw error;
+    const parts: string[] = [];
+
+    function decodeChunk(chunk: Uint8Array, stream: boolean): string {
+      const decoded = decoder.decode(chunk, { stream });
+      if (!hadUtf8DecodeErrors && decoded.includes("\uFFFD")) {
+        hadUtf8DecodeErrors = true;
       }
-    };
+      return decoded;
+    }
 
-    noteUtf8Err(sample);
-    const parts: string[] = [decoder.decode(sample, { stream: true })];
+    parts.push(decodeChunk(sample, true));
 
     let position = bytesRead;
     while (true) {
@@ -113,12 +108,10 @@ export async function loadFileKindAndText(
       }
 
       const chunk = buffer.subarray(0, chunkBytesRead);
-      noteUtf8Err(chunk);
-      parts.push(decoder.decode(chunk, { stream: true }));
+      parts.push(decodeChunk(chunk, true));
       position += chunkBytesRead;
     }
-    noteUtf8Err();
-    parts.push(decoder.decode());
+    parts.push(decodeChunk(new Uint8Array(0), false));
 
     return {
       kind: "text",

package/src/file-reader.ts

@@ -38,23 +38,29 @@ export async function fileSnap(absolutePath: string): Promise<SnapInfo> {
   };
 }
 
+export interface ReadNormOptions {
+  signal?: AbortSignal;
+  accessMode?: number;
+  preloadedFile?: LFile;
+  maxLines?: number;
+  store?: HashStore;
+}
+
 export async function readNormFile(
   path: string,
   cwd: string,
-  signal: AbortSignal | undefined,
-  accessMode: number = constants.R_OK,
-  preloadedFile?: LFile,
-  maxLines?: number,
-  store?: HashStore,
+  options?: ReadNormOptions,
 ): Promise<NormFile> {
   const absolutePath = toCwd(path, cwd);
   const resolvedPath = await resolveTarget(absolutePath);
+  const signal = options?.signal;
+  const accessMode = options?.accessMode ?? constants.R_OK;
 
   abortIf(signal);
   await valAccess(resolvedPath, path, accessMode);
 
   abortIf(signal);
-  const file = preloadedFile ?? (await loadFileKindAndText(resolvedPath));
+  const file = options?.preloadedFile ?? (await loadFileKindAndText(resolvedPath));
   valKind(file, path);
 
   abortIf(signal);
@@ -62,16 +68,16 @@ export async function readNormFile(
   const originalEnding = detectEnding(rawContent);
   const normalized = toLF(rawContent);
 
-  if (maxLines !== undefined) {
+  if (options?.maxLines !== undefined) {
     const lineCount = visLines(normalized).length;
-    if (lineCount > maxLines) {
+    if (lineCount > options.maxLines) {
       throw new Error(
-        `[E_FILE_TOO_LARGE] ${path} has ${lineCount} lines, exceeding the ${maxLines}-line edit limit. Hashline editing targets source-sized files; for very large files use write or a non-line-based approach.`,
+        `[E_FILE_TOO_LARGE] ${path} has ${lineCount} lines, exceeding the ${options.maxLines}-line edit limit. Hashline editing targets source-sized files; for very large files use write or a non-line-based approach.`,
       );
     }
   }
 
-  const fileHashes = await lineHashes(normalized, resolvedPath, undefined, store);
+  const fileHashes = await lineHashes(normalized, resolvedPath, undefined, options?.store);
   return {
     absolutePath: resolvedPath,
     normalized,

package/src/read.ts

@@ -163,9 +163,9 @@ export function regRead(pi: ExtensionAPI): void {
 				) => ReturnType<typeof builtinRead.execute>;
 				return executeBuiltinRead(_toolCallId, params, signal, _onUpdate, ctx);
 			}
-			const { normalized, fileHashes, hadUtf8DecodeErrors } = await readNormFile(
-				rawPath, ctx.cwd, signal, undefined, file,
-			);
+      const { normalized, fileHashes, hadUtf8DecodeErrors } = await readNormFile(
+        rawPath, ctx.cwd, { signal, preloadedFile: file },
+      );
 			const preview = await fmtReadPreview(
 				normalized,
 				{

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): void {
+export function tryParseContentLines(record: Record<string, unknown>, key: string): void {
   const val = record[key];
   if (typeof val !== "string") return;
   try {

package/src/replace-response.ts

@@ -53,7 +53,7 @@ export interface SuccessInput {
 }
 
 
-function buildM(args: {
+export function buildMetrics(args: {
 	classification: "applied" | "noop";
 	editsAttempted: number;
 	noopEditsCount: number;
@@ -109,7 +109,7 @@ export function buildNoop(input: NoopInput): TResult {
 
 	const text = `No changes made to ${path}\nClassification: noop\n${noopDetailsText}`;
 
-	const metrics = buildM({
+	const metrics = buildMetrics({
 		classification: "noop",
 		editsAttempted: editMeta.editsAttempted,
 		noopEditsCount: editMeta.noopEditsCount,
@@ -146,7 +146,7 @@ export function buildChanged(input: SuccessInput): TResult {
       ? `${successPrefix}${lineSummary}${warningsBlock}`
       : `${successPrefix}${lineSummary}`;
 
-  const metrics = buildM({
+  const metrics = buildMetrics({
     classification: "applied",
     editsAttempted: editMeta.editsAttempted,
     noopEditsCount: editMeta.noopEditsCount,

package/src/replace-undo.ts

@@ -9,6 +9,7 @@ import { toCwd } from "./paths";
 import { toLF, stripBOM, genDiff, restoreEndings } from "./replace-diff";
 import { cntDiff } from "./utils";
 import { loadP, loadGuide } from "./prompts";
+import { buildMetrics } from "./replace-response";
 export interface UndoEntry {
   content: string;
   bom: string;
@@ -107,11 +108,14 @@ export function regReplaceUndo(pi: ExtensionAPI): void {
             },
           ],
           details: {
-            metrics: {
-              added_lines: linesRemovedByReplace,
-              removed_lines: linesAddedByReplace,
-              classification: "applied" as const,
-            },
+            metrics: buildMetrics({
+              classification: "applied",
+              editsAttempted: 1,
+              noopEditsCount: 0,
+              warningsCount: 0,
+              addedLines: linesRemovedByReplace,
+              removedLines: linesAddedByReplace,
+            }),
           },
         };
       });

package/src/replace.ts

@@ -11,7 +11,7 @@ import {
   restoreEndings,
 } from "./replace-diff";
 import { readNormFile } from "./file-reader";
-import { normReq, normalizeFilePath } from "./replace-normalize";
+import { normReq, normalizeFilePath, tryParseContentLines } from "./replace-normalize";
 import { isRec, has, rejectUnknownFields, abortIf } from "./utils";
 import { MAX_HASH_LINES } from "./constants";
 import { resolveTarget, writeAtomic } from "./fs-write";
@@ -148,13 +148,17 @@ export function assertReq(
     throw new Error('[E_BAD_SHAPE] Edit request requires a "changes" array. Each change is { content_lines: [...], hash_range_inclusive: ["<START>", "<END>"] }.');
   }
 }
+export interface ExecPipelineOptions {
+  accessMode?: number;
+  signal?: AbortSignal;
+  store?: HashStore;
+  noPersist?: boolean;
+}
+
 export async function execPipeline(
   params: ReqParams,
   cwd: string,
-  accessMode: number,
-  signal?: AbortSignal,
-  store?: HashStore,
-  noPersist?: boolean,
+  options?: ExecPipelineOptions,
 ): Promise<PipelineResult> {
 
   const path = params.path;
@@ -166,17 +170,17 @@ export async function execPipeline(
     throw new Error('[E_BAD_SHAPE] Edit request requires a non-empty "changes" array.');
   }
 
-  const hashStore = store ?? await loadHashStore();
+  const hashStore = options?.store ?? await loadHashStore();
 
   const { normalized: originalNormalized, bom, originalEnding, fileHashes: originalHashes, hadUtf8DecodeErrors, absolutePath } = await readNormFile(
-    path, cwd, signal, accessMode, undefined, MAX_HASH_LINES, hashStore,
+    path, cwd, { signal: options?.signal, accessMode: options?.accessMode, maxLines: MAX_HASH_LINES, store: hashStore },
   );
 
   const resolved = resEdits(toolEdits);
   const anchorResult = applyEdits(
     originalNormalized,
     resolved,
-    signal,
+    options?.signal,
     originalHashes,
     path,
   );
@@ -196,6 +200,7 @@ export async function execPipeline(
     }
   }
 
+  const noPersist = options?.noPersist;
   const resultHashes = await lineHashes(result, absolutePath, {
     content: originalNormalized,
     hashes: originalHashes,
@@ -248,10 +253,7 @@ export async function compPreview(
     const { path, originalNormalized, originalHashes, result, resultHashes } = await execPipeline(
       normalized,
       cwd,
-      constants.R_OK,
-      undefined,
-      undefined,
-      true,
+      { accessMode: constants.R_OK, noPersist: true },
     );
 
     if (originalNormalized === result) {
@@ -336,10 +338,7 @@ export function buildToolDef(opts: { flat: boolean; autoRead?: boolean }): ToolD
           const record = { ...args };
           normalizeFilePath(record);
           if (has(record, "content_lines") && typeof record.content_lines === "string") {
-            try {
-              const parsed = JSON.parse(record.content_lines as string);
-              if (Array.isArray(parsed)) record.content_lines = parsed;
-            } catch {}
+            tryParseContentLines(record, "content_lines");
           }
           return record;
         }
@@ -461,8 +460,7 @@ export function buildToolDef(opts: { flat: boolean; autoRead?: boolean }): ToolD
         } = await execPipeline(
           normalizedParams,
           ctx.cwd,
-          constants.R_OK | constants.W_OK,
-          signal,
+          { accessMode: constants.R_OK | constants.W_OK, signal },
         );
 
         const editsAttempted = opts.flat