pi-hashline-edit-pro 0.13.0 → 0.13.1

package/index.ts

@@ -4,7 +4,7 @@ import { join, isAbsolute } from "path";
 import { lineHashes, initHasher, fmtRegion } from "./src/hashline";
 import { regReplace } from "./src/replace";
 import { regRead, formatPaginationHint } from "./src/read";
-import { toLF } from "./src/replace-diff";
+import { toLF, stripBOM } from "./src/replace-diff";
 import { visLines } from "./src/utils";
 import { AUTO_READ_MAX } from "./src/constants";
 
@@ -12,10 +12,15 @@ export default function (pi: ExtensionAPI): void {
   regRead(pi);
   regReplace(pi);
 
+  const debugValue = process.env.PI_HASHLINE_DEBUG;
+
   pi.on("session_start", async (_event, ctx) => {
     const active = pi.getActiveTools();
     pi.setActiveTools(active.filter((t) => t !== "edit"));
     await initHasher();
+    if (debugValue === "1" || debugValue === "true") {
+      ctx.ui.notify("Hashline Edit mode active", "info");
+    }
   });
 
   const autoReadValue = process.env.PI_HASHLINE_AUTO_READ;
@@ -40,8 +45,8 @@ export default function (pi: ExtensionAPI): void {
     try {
       const absolutePath = isAbsolute(filePath) ? filePath : join(ctx.cwd, filePath);
       const content = await readFile(absolutePath, "utf-8");
-
-      const normalized = toLF(content);
+      const { text: rawContent } = stripBOM(content);
+      const normalized = toLF(rawContent);
       const visibleLines = visLines(normalized);
 
       if (visibleLines.length === 0) return;
@@ -65,14 +70,9 @@ export default function (pi: ExtensionAPI): void {
           ],
         };
       }
-    } catch {
+    } catch (error) {
+      console.error("Auto-read after write failed:", error);
     }
   });
 
-  const debugValue = process.env.PI_HASHLINE_DEBUG;
-  if (debugValue === "1" || debugValue === "true") {
-    pi.on("session_start", async (_event, ctx) => {
-      ctx.ui.notify("Hashline Edit mode active", "info");
-    });
-  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "0.13.0",
+  "version": "0.13.1",
   "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/hashline/hash.ts

@@ -98,8 +98,5 @@ export function lineHashes(content: string): string[] {
 	return hashes;
 }
 
-export function lineHash(idx: number, line: string): string {
-	return h2s(xxh32(canon(line)));
-}
 
 export { ALPH_RE };

package/src/hashline/index.ts

@@ -8,7 +8,6 @@ export {
 	DIFF_MINUS_RE,
 	HL_BARE_PREFIX_RE,
 	lineHashes,
-	lineHash,
 	initHasher,
 } from "./hash";
 

package/src/hashline/resolve.ts

@@ -222,6 +222,31 @@ export function descEdit(edit: RHEdit): string {
 	return `replace ${edit.hash_range_inclusive[0].hash}-${edit.hash_range_inclusive[1].hash}`;
 }
 
+function checkBoundaryDup(
+  adjacentLine: string | undefined,
+  replacementEdge: string | undefined,
+  kind: "trailing" | "leading",
+  survivingLineIndex: number,
+  fileLines: string[],
+  editIndex: number,
+): BDupWarn | 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,
+  };
+}
+
+
 export function valEdits(
   edits: HEdit[],
   fileLines: string[],
@@ -258,38 +283,12 @@ export function valEdits(
     const endLine = endResolved.line;
     const nextLine = fileLines[endLine];
     const replacementLastLine = edit.content_lines.at(-1);
-    if (
-      nextLine !== undefined &&
-      replacementLastLine !== undefined &&
-      replacementLastLine.length > 0 &&
-      replacementLastLine === nextLine
-    ) {
-      boundaryWarnings.push({
-        kind: "trailing",
-        survivingLineContent: nextLine,
-        survivingLineIndex: endLine,
-        occurrence: fileLines.slice(0, endLine).filter(l => l === nextLine).length,
-        replacementLineContent: replacementLastLine,
-        editIndex: resolved.length,
-      });
-    }
+    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];
-    if (
-      prevLine !== undefined &&
-      replacementFirstLine !== undefined &&
-      replacementFirstLine.length > 0 &&
-      replacementFirstLine === prevLine
-    ) {
-      boundaryWarnings.push({
-        kind: "leading",
-        survivingLineContent: prevLine,
-        survivingLineIndex: startResolved.line - 2,
-        occurrence: fileLines.slice(0, startResolved.line - 2).filter(l => l === prevLine).length,
-        replacementLineContent: replacementFirstLine,
-        editIndex: resolved.length,
-      });
-    }
+    const leading = checkBoundaryDup(prevLine, replacementFirstLine, "leading", startResolved.line - 2, fileLines, resolved.length);
+    if (leading) boundaryWarnings.push(leading);
     resolved.push({
       hash_range_inclusive: [startResolved, endResolved],
       content_lines: edit.content_lines,

package/src/replace-normalize.ts

@@ -1,46 +1,12 @@
 import { isRec, has } from "./utils";
 
-function coerceChangesArray(changes: unknown): unknown {
-  if (typeof changes !== "string") {
-    return changes;
-  }
+function tryParseJSON<T>(value: unknown, guard: (v: unknown) => v is T): T | undefined {
+  if (typeof value !== "string") return undefined;
   try {
-    const parsed: unknown = JSON.parse(changes);
-    return Array.isArray(parsed) ? parsed : changes;
-  } catch {
-    return changes;
-  }
-}
-
-function coerceContentLines(changes: unknown): unknown {
-  if (!Array.isArray(changes)) return changes;
-  return changes.map((change: unknown) => {
-    if (!isRec(change)) return change;
-    if (typeof change.content_lines !== "string") return change;
-    try {
-      const parsed: unknown = JSON.parse(change.content_lines);
-      if (Array.isArray(parsed) && parsed.every((item) => typeof item === "string")) {
-        return { ...change, content_lines: parsed };
-      }
-    } catch {
-      // not valid JSON, leave as-is for downstream validation
-    }
-    return change;
-  });
-}
-
-function coerceChangeItems(changes: unknown): unknown {
-  if (!Array.isArray(changes)) return changes;
-  return changes.map((item: unknown) => {
-    if (typeof item !== "string") return item;
-    try {
-      const parsed: unknown = JSON.parse(item);
-      if (isRec(parsed)) return parsed;
-    } catch {
-      // not valid JSON, leave as-is for downstream validation
-    }
-    return item;
-  });
+    const parsed: unknown = JSON.parse(value);
+    if (guard(parsed)) return parsed;
+  } catch {}
+  return undefined;
 }
 
 export function normReq(input: unknown): unknown {
@@ -59,14 +25,33 @@ export function normReq(input: unknown): unknown {
   const hasEditsField = has(record, "edits");
 
   if (hasChangesField) {
-    record.changes = coerceChangesArray(record.changes);
-    record.changes = coerceChangeItems(record.changes);
-    record.changes = coerceContentLines(record.changes);
+    const raw = tryParseJSON(record.changes, Array.isArray) ?? record.changes;
+    if (Array.isArray(raw)) {
+      record.changes = raw
+        .map((item: unknown) => tryParseJSON(item, isRec) ?? item)
+        .map((change: unknown) => {
+          if (!isRec(change)) return change;
+          if (typeof change.content_lines !== "string") return change;
+          const parsed = tryParseJSON(change.content_lines, (v): v is string[] =>
+            Array.isArray(v) && v.every((i) => typeof i === "string"),
+          );
+          return parsed ? { ...change, content_lines: parsed } : change;
+        });
+    }
   } else if (hasEditsField) {
-    // Accept "edits" as an alias for "changes" for backward compatibility
-    record.changes = coerceChangesArray(record.edits);
-    record.changes = coerceChangeItems(record.changes);
-    record.changes = coerceContentLines(record.changes);
+    const raw = tryParseJSON(record.edits, Array.isArray) ?? record.edits;
+    if (Array.isArray(raw)) {
+      record.changes = raw
+        .map((item: unknown) => tryParseJSON(item, isRec) ?? item)
+        .map((change: unknown) => {
+          if (!isRec(change)) return change;
+          if (typeof change.content_lines !== "string") return change;
+          const parsed = tryParseJSON(change.content_lines, (v): v is string[] =>
+            Array.isArray(v) && v.every((i) => typeof i === "string"),
+          );
+          return parsed ? { ...change, content_lines: parsed } : change;
+        });
+    }
     delete record.edits;
   }
 

package/src/replace.ts

@@ -86,6 +86,21 @@ export type ReplaceDetails = {
 	metrics?: RMetrics;
 };
 
+interface PipelineResult {
+  path: string;
+  toolEdits: HTEdit[];
+  originalNormalized: string;
+  result: string;
+  bom: string;
+  originalEnding: "\r\n" | "\n";
+  hadUtf8DecodeErrors: boolean;
+  warnings: string[];
+  noopEdits?: { editIndex: number; loc: string; currentContent: string }[];
+  firstChangedLine?: number;
+  lastChangedLine?: number;
+  originalHashes?: string[];
+}
+
 const E_DESC = loadP("../prompts/replace.md");
 const E_SNIPPET = loadP("../prompts/replace-snippet.md");
 const E_GUIDE = loadGuide("../prompts/replace-guidelines.md");
@@ -122,20 +137,7 @@ async function execPipeline(
   cwd: string,
   accessMode: number,
   signal?: AbortSignal,
-): Promise<{
-  path: string;
-  toolEdits: HTEdit[];
-  originalNormalized: string;
-  result: string;
-  bom: string;
-  originalEnding: "\r\n" | "\n";
-  hadUtf8DecodeErrors: boolean;
-  warnings: string[];
-  noopEdits?: { editIndex: number; loc: string; currentContent: string }[];
-  firstChangedLine?: number;
-  lastChangedLine?: number;
-  originalHashes?: string[];
-}> {
+): Promise<PipelineResult> {
 
   const path = params.path;
   const toolEdits = Array.isArray(params.changes)
@@ -205,6 +207,21 @@ type ToolDef = ToolDefinition<
 	ReplaceDetails,
 	RRState
 > & { renderShell?: "default" | "self" };
+function reuseText(context: any, content: string): Text {
+  const t = context.lastComponent instanceof Text
+    ? context.lastComponent
+    : new Text("", 0, 0);
+  t.setText(content);
+  return t;
+}
+
+function reuseMarkdown(context: any, content: string, theme: any): Markdown {
+  const m = context.lastComponent instanceof Markdown
+    ? context.lastComponent
+    : new Markdown("", 0, 0, mkMdTheme(theme));
+  m.setText(content);
+  return m;
+}
 
 const toolDef: ToolDef = {
 	name: "replace",
@@ -273,10 +290,7 @@ const toolDef: ToolDef = {
 
 	renderResult(result, { isPartial }, theme, context) {
 		if (isPartial) {
-			const text =
-				(context.lastComponent as Text | undefined) ?? new Text("", 0, 0);
-			text.setText(theme.fg("warning", "Editing..."));
-			return text;
+			return reuseText(context, theme.fg("warning", "Editing..."));
 		}
 
 		const typedResult = result as {
@@ -292,44 +306,18 @@ const toolDef: ToolDef = {
 		}
 
 		if (context.isError) {
-			if (!renderedText) {
-				return new Text("", 0, 0);
-			}
-			const text =
-				context.lastComponent instanceof Text
-					? context.lastComponent
-					: new Text("", 0, 0);
-			text.setText(`\n${theme.fg("error", renderedText)}`);
-			return text;
+			return renderedText
+				? reuseText(context, `\n${theme.fg("error", renderedText)}`)
+				: new Text("", 0, 0);
 		}
 
 		if (isApplied(typedResult.details)) {
-			const appliedChangedText = buildAppliedText(
-				renderedText,
-				typedResult.details,
-				theme,
-			);
-			if (!appliedChangedText) {
-				return new Text("", 0, 0);
-			}
-			const text =
-				context.lastComponent instanceof Text
-					? context.lastComponent
-					: new Text("", 0, 0);
-			text.setText(appliedChangedText);
-			return text;
-		}
-
-		if (!renderedText) {
-			return new Text("", 0, 0);
+			const appliedText = buildAppliedText(renderedText, typedResult.details, theme);
+			return appliedText ? reuseText(context, appliedText) : new Text("", 0, 0);
 		}
 
-		const markdown =
-			context.lastComponent instanceof Markdown
-				? context.lastComponent
-				: new Markdown("", 0, 0, mkMdTheme(theme));
-		markdown.setText(fmtResultMd(renderedText));
-		return markdown;
+		if (!renderedText) return new Text("", 0, 0);
+		return reuseMarkdown(context, fmtResultMd(renderedText), theme);
 	},
 
 	async execute(_toolCallId, params, signal, _onUpdate, ctx) {
@@ -353,7 +341,7 @@ const toolDef: ToolDef = {
 				firstChangedLine,
 				lastChangedLine,
 			} = await execPipeline(
-				normalized,
+				normalizedParams,
 				ctx.cwd,
 				constants.R_OK | constants.W_OK,
 				signal,