pi-hashline-edit-pro 0.13.0 → 0.13.2

package/index.ts

@@ -1,10 +1,10 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { readFile } from "fs/promises";
 import { join, isAbsolute } from "path";
-import { lineHashes, initHasher, fmtRegion } from "./src/hashline";
+import { initHasher } from "./src/hashline";
 import { regReplace } from "./src/replace";
-import { regRead, formatPaginationHint } from "./src/read";
-import { toLF } from "./src/replace-diff";
+import { regRead, fmtReadPreview } from "./src/read";
+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,39 +45,23 @@ export default function (pi: ExtensionAPI): void {
     try {
       const absolutePath = isAbsolute(filePath) ? filePath : join(ctx.cwd, filePath);
       const content = await readFile(absolutePath, "utf-8");
+      const { text: rawContent } = stripBOM(content);
+      const normalized = toLF(rawContent);
 
-      const normalized = toLF(content);
-      const visibleLines = visLines(normalized);
-
-      if (visibleLines.length === 0) return;
+      if (visLines(normalized).length === 0) return;
 
-      const truncated = visibleLines.length > AUTO_READ_MAX;
-      const displayLines = truncated ? visibleLines.slice(0, AUTO_READ_MAX) : visibleLines;
+      const preview = fmtReadPreview(normalized, { limit: AUTO_READ_MAX });
+      if (!preview.text) return;
 
-      const hashes = lineHashes(normalized);
-      const selectedHashes = hashes.slice(0, displayLines.length);
-      const hashlineOutput = fmtRegion(selectedHashes, displayLines);
-
-      const paginationHint = truncated
-        ? `\n\n${formatPaginationHint(1, AUTO_READ_MAX, visibleLines.length, AUTO_READ_MAX + 1)}`
-        : "";
-
-      if (hashlineOutput) {
-        return {
-          content: [
-            ...(event.content ?? []),
-            { type: "text", text: `\n\n--- Auto-read (hashline anchors) ---\n${hashlineOutput}${paginationHint}` },
-          ],
-        };
-      }
-    } catch {
+      return {
+        content: [
+          ...(event.content ?? []),
+          { type: "text", text: `\n\n--- Auto-read (hashline anchors) ---\n${preview.text}` },
+        ],
+      };
+    } 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.2",
   "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

@@ -1,16 +1,4 @@
 export const AUTO_READ_MAX = 2000;
-export const ANCHOR_BUDGET = 50 * 1024;
-
-/**
- * Context lines of post-edit anchor surfacing. Intentionally 0: after a
- * successful `replace` the response text is empty by design (the model calls
- * `read` for fresh anchors — see "Chained edits" in the README). With 0,
- * `affRange` returns null, so the anchor-block branch in `buildChanged`
- * (`src/replace-response.ts`) is dormant. Set this > 0 (and likely bump
- * MAX_OUT) to revive surfacing a small anchor window after each edit.
- */
-export const CTX_LINES = 0;
-export const MAX_OUT = 12;
 export const SNIFF_BYTES = 8192;
 export const MAX_BYTES = 100 * 1024 * 1024;
 

package/src/hashline/apply.ts

@@ -12,7 +12,6 @@ import {
 	type BDupWarn,
 } from "./resolve";
 import { cntLines } from "../utils";
-import { CTX_LINES, MAX_OUT } from "../constants";
 
 type LIdx = {
 	fileLines: string[];
@@ -271,6 +270,7 @@ export function applyEdits(
 	content: string;
 	firstChangedLine: number | undefined;
 	lastChangedLine: number | undefined;
+	resultHashes?: string[];
 	warnings?: string[];
 	noopEdits?: NEdit[];
 } {
@@ -350,52 +350,12 @@ export function applyEdits(
 		content: result,
 		firstChangedLine: range?.firstChangedLine,
 		lastChangedLine: range?.lastChangedLine,
+		resultHashes,
 		...(warnings.length ? { warnings } : {}),
 		...(noopEdits.length ? { noopEdits } : {}),
 	};
 }
 
-export function affRange(params: {
-	firstChangedLine: number | undefined;
-	lastChangedLine: number | undefined;
-	resultLineCount: number;
-	contextLines?: number;
-	maxOutputLines?: number;
-}): { start: number; end: number } | null {
-	const {
-		firstChangedLine,
-		lastChangedLine,
-		resultLineCount,
-		contextLines = CTX_LINES,
-		maxOutputLines = MAX_OUT,
-	} = params;
-
-	if (firstChangedLine === undefined || lastChangedLine === undefined) {
-		return null;
-	}
-
-	if (contextLines === 0) {
-		return null;
-	}
-
-	if (resultLineCount === 0) {
-		return null;
-	}
-
-	const start = Math.max(1, firstChangedLine - contextLines);
-	const end = Math.min(resultLineCount, lastChangedLine + contextLines);
-
-	if (end < start) {
-		return null;
-	}
-
-	if (end - start + 1 > maxOutputLines) {
-		return null;
-	}
-
-	return { start, end };
-}
-
 export function fmtRegion(
 	hashes: string[],
 	lines: string[],

package/src/hashline/hash.ts

@@ -55,6 +55,9 @@ function getH(): Hasher {
 hasherP = xxhash().then((h) => {
 	hasher = h;
 	return h;
+}).catch((err) => {
+	console.error("xxhash-wasm initialization failed:", err);
+	throw err;
 });
 
 export function initHasher(): Promise<Hasher> {
@@ -98,8 +101,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";
 
@@ -35,7 +34,6 @@ export {
 export {
 	buildIdx,
 	applyEdits,
-	affRange,
 	fmtRegion,
 	changedRange,
 } from "./apply";

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,30 @@
 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;
-  }
+    const parsed: unknown = JSON.parse(value);
+    if (guard(parsed)) return parsed;
+  } catch {}
+  return undefined;
 }
 
-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;
-  });
+/**
+ * Coerces an array of edit items: JSON-string items → objects,
+ * JSON-string content_lines → string arrays. Shared by the `changes`
+ * and `edits` normalization branches.
+ */
+function coerceEditArray(items: unknown[]): unknown[] {
+  return items
+    .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;
+    });
 }
 
 export function normReq(input: unknown): unknown {
@@ -59,16 +43,14 @@ 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 = coerceEditArray(raw);
   } 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 = coerceEditArray(raw);
     delete record.edits;
   }
 
   return record;
 }
+

package/src/replace-response.ts

@@ -1,12 +1,9 @@
 import type { ReplaceDetails } from "./replace";
 import { genDiff } from "./replace-diff";
 import {
-	affRange,
 	lineHashes,
-	fmtRegion,
 } from "./hashline";
 import { visLines } from "./utils";
-import { ANCHOR_BUDGET } from "./constants";
 
 type TResult = {
 	content: Array<{ type: "text"; text: string }>;
@@ -153,34 +150,9 @@ export function buildChanged(input: SuccessInput): TResult {
 	const addedLines = cntDiff(diffResult.diff, "+");
 	const removedLines = cntDiff(diffResult.diff, "-");
 	const warningsBlock = warnBlock(warnings);
-	const anchorRange = affRange({
-		firstChangedLine: editMeta.firstChangedLine,
-		lastChangedLine: editMeta.lastChangedLine,
-		resultLineCount: resultLines.length,
-	});
-	const anchorsBlock = anchorRange
-		? (() => {
-				const region = resultLines.slice(
-					anchorRange.start - 1,
-					anchorRange.end,
-				);
-				const regionHashes = resultHashes.slice(
-					anchorRange.start - 1,
-					anchorRange.end,
-				);
-				const formatted = fmtRegion(regionHashes, region);
-				const block = `--- Anchors ---\n${formatted}`;
-				return Buffer.byteLength(block, "utf8") <=
-					ANCHOR_BUDGET
-					? block
-					: "Anchors omitted; use read for subsequent edits.";
-			})()
-		: resultLines.length === 0
-			? "File is empty. Use replace to insert content."
-			: "";
-	const text = [anchorsBlock, warningsBlock.trimStart()]
-		.filter((section) => section.length > 0)
-		.join("\n\n");
+	const text = resultLines.length === 0
+		? "File is empty. Use replace to insert content."
+		: warningsBlock.trimStart();
 
 	const metrics = buildM({
 		classification: "applied",

package/src/replace.ts

@@ -86,6 +86,22 @@ 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[];
+  resultHashes?: 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 +138,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)
@@ -171,6 +174,7 @@ async function execPipeline(
     noopEdits: anchorResult.noopEdits,
     firstChangedLine: anchorResult.firstChangedLine,
     lastChangedLine: anchorResult.lastChangedLine,
+    resultHashes: anchorResult.resultHashes,
     originalHashes,
   };
 }
@@ -182,7 +186,7 @@ export async function compPreview(
 	try {
 		const normalized = normReq(request);
 		assertReq(normalized);
-		const { path, originalNormalized, result } = await execPipeline(
+		const { path, originalNormalized, result, resultHashes } = await execPipeline(
 			normalized,
 			cwd,
 			constants.R_OK,
@@ -194,7 +198,7 @@ export async function compPreview(
 			};
 		}
 
-		return { diff: genDiff(originalNormalized, result, 4, lineHashes(result)).diff };
+		return { diff: genDiff(originalNormalized, result, 4, resultHashes).diff };
 	} catch (error: unknown) {
 		return { error: error instanceof Error ? error.message : String(error) };
 	}
@@ -205,6 +209,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 +292,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 +308,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) {
@@ -352,8 +342,9 @@ const toolDef: ToolDef = {
 				noopEdits,
 				firstChangedLine,
 				lastChangedLine,
+				resultHashes,
 			} = await execPipeline(
-				normalized,
+				normalizedParams,
 				ctx.cwd,
 				constants.R_OK | constants.W_OK,
 				signal,
@@ -402,7 +393,7 @@ const toolDef: ToolDef = {
 				path,
 				originalNormalized,
 				result,
-				resultHashes: lineHashes(result),
+				resultHashes,
 				warnings,
 				snapshotId: updatedSnapshotId,
 				editMeta,