pi-hashline-edit-pro 1.0.5 → 1.0.6

package/README.md

@@ -62,6 +62,8 @@ Optional parameters:
 
 Paged output ends with a continuation hint, e.g. `[Showing lines 1-50 of 120. Use offset=51 to continue.]`.
 
+Lines up to 200KB are displayed in full; larger lines are replaced by a marker with a bash inspection hint (`sed -n 'Np' <path> | head -c 204800`) since hash anchors require full lines.
+
 Edge cases:
 
 - **Images** (JPEG, PNG, GIF, WebP) are passed through as visual attachments and don't participate in the hashline protocol.
@@ -93,7 +95,7 @@ Exactly one edit per call, with `hash_range_inclusive` and `content_lines` at th
 Behavior:
 
 - **Validation before any file I/O.** Unknown fields, missing fields, wrong types, and malformed anchors are rejected with `[E_BAD_SHAPE]` / `[E_BAD_REF]`. The edit applies against the pre-edit snapshot, so all hashes in the request come from one consistent file state.
-- **Rejected dialects.** The `changes` array dialect and the legacy `oldText`/`newText` dialect are rejected with `[E_BAD_SHAPE]` / `[E_LEGACY_SHAPE]`; the error tells you to send `{hash_range_inclusive: ["<START>", "<END>"], content_lines: [...]}`.
+- **Rejected dialects.** The `changes` array dialect and the legacy `oldText`/`newText` dialect are rejected with `[E_LEGACY_SHAPE]`; the error tells you to send `{hash_range_inclusive: ["<START>", "<END>"], content_lines: [...]}`.
 - **Autocorrections** (all accompanied by a warning unless noted):
   - A `HASH│` prefix accidentally left on a `content_lines` entry is stripped.
   - Diff-preview rows (`+HASH│…`, `-HASH│…`, `-   │…`) pasted into `content_lines` have their markers stripped. Numbered deletion rows (`-1    foo`) and unified-diff lines are written literally — never silently altered.
@@ -120,6 +122,7 @@ Enabled by default. After a successful `write`, `replace`, or `undo_last_replace
 
 - After `replace` / `undo_last_replace`, the block covers the changed span plus 2 lines of context above and below — the rest of the file keeps its anchors from the persistent store.
 - After `write`, the block dumps from the top of the file. For files over 2000 lines, the dump is truncated with a pagination hint — use `read` with `offset` to continue.
+- Auto-read keeps a 50KB display budget: lines over 50KB are skipped with a marker instead of their content (use `read` for lines up to 200KB).
 - Toggle at runtime with `/toggle-auto-read`; the setting persists across sessions.
 - If the auto-read itself fails (e.g. the file was deleted between the operation and the read), a short `--- Auto-read failed: ... ---` notice is appended instead of the anchor block, so the model knows the anchors are missing.
 
@@ -157,7 +160,7 @@ Settings live in `~/.config/pi-hashline-edit-pro/config.json`, created automatic
 | `[E_AMBIGUOUS_ANCHOR]` | An anchor matches multiple lines; call `read` for fresh anchors. |
 | `[E_INVALID_PATCH]` | A `content_lines` entry is a diff-preview row (`+HASH│`, `-HASH│`, `-   │`) — the marker is stripped automatically with a warning. |
 | `[E_BARE_HASH_PREFIX]` | A `content_lines` entry starts with a hash-like `HASH│` prefix — the prefix is stripped automatically with a warning. |
-| `[E_LEGACY_SHAPE]` | The request uses the unsupported `oldText`/`newText` dialect. |
+| `[E_LEGACY_SHAPE]` | The request uses an unsupported dialect: `oldText`/`newText` fields or a `changes` array. |
 | `[E_BAD_OP]` | Range start line is after range end line — the pair is swapped automatically with a warning. |
 | `[E_WOULD_EMPTY]` | An edit would empty a non-empty file; use `write` instead. |
 | `[E_NOT_FOUND]` | The path does not exist. |

package/index.ts

@@ -1,4 +1,5 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { DEFAULT_MAX_BYTES } from "@earendil-works/pi-coding-agent";
 import { initHasher } from "./src/hashline";
 import { regReplace } from "./src/replace";
 import { regReplaceUndo, clearUndo } from "./src/replace-undo";
@@ -98,6 +99,7 @@ export default function (pi: ExtensionAPI): void {
         { offset, limit },
         fileHashes,
         absolutePath,
+        DEFAULT_MAX_BYTES,
       );
 
       return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "type": "module",
   "description": "Strict hashline read/replace tool for pi-coding-agent with hash-anchored edits (3-char, 62-symbol, perfect hashing)",
   "main": "index.ts",
@@ -47,7 +47,7 @@
   "scripts": {
     "test": "vitest run",
     "test:watch": "vitest",
-    "test:coverage": "vitest run --coverage",
+    "test:coverage": "vitest run --coverage --coverage.thresholds.lines=90 --coverage.thresholds.statements=90 --coverage.thresholds.functions=85 --coverage.thresholds.branches=80",
     "lint": "eslint \"src/**/*.ts\" \"index.ts\" \"test/**/*.ts\"",
     "typecheck": "tsc --noEmit"
   },

package/src/constants.ts

@@ -1,6 +1,7 @@
 export const AUTO_READ_MAX = 2000;
 export const SNIFF_BYTES = 8192;
 export const MAX_BYTES = 100 * 1024 * 1024;
+export const MAX_READ_LINE_BYTES = 200 * 1024;
 
 export const HASH_STORE_BUSY_TIMEOUT = 1000;
 export const HASH_STORE_VERSION = 4;

package/src/hashline/hash.ts

@@ -143,6 +143,7 @@ export async function lineHashes(
   store?: HashStore,
   persist?: boolean,
 ): Promise<string[]> {
+  await initHasher();
   if (!path) {
     return _lineHashesPure(content);
   }

package/src/hashline/hasher.ts

@@ -9,7 +9,7 @@ let hasher: Hasher | null = null;
 
 export function getH(): Hasher {
 	if (hasher) return hasher;
-	throw new Error("xxhash-wasm not initialized yet. This should not happen.");
+	throw new Error("xxhash-wasm hasher not initialized; await initHasher() before calling hashline APIs.");
 }
 
 const hasherP: Promise<Hasher> = xxhash().then((h) => {

package/src/read.ts

@@ -6,6 +6,7 @@ import {
 	type TruncationResult,
 } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
+import { MAX_READ_LINE_BYTES } from "./constants";
 import { loadFileKindAndText } from "./file-kind";
 import { readNormFile } from "./file-reader";
 import { lineHashes, fmtRegion, HASH_SEP, MAX_HASH_LINES } from "./hashline";
@@ -58,6 +59,7 @@ export async function fmtReadPreview(
 	options: { offset?: number; limit?: number },
 	precomputedHashes?: string[],
 	path?: string,
+	maxLineBytes = MAX_READ_LINE_BYTES,
 ): Promise<{ text: string; truncation?: TruncationResult; nextOffset?: number }> {
 	const allLines = visLines(text);
 	const totalLines = allLines.length;
@@ -88,15 +90,42 @@ export async function fmtReadPreview(
 	const allHashes = precomputedHashes ?? await (path ? lineHashes(text, path) : lineHashes(text));
 	const selectedHashes = allHashes.slice(startLine - 1, endIdx);
 	const formatted = fmtRegion(selectedHashes, selected);
-
-	const truncation = truncateHead(formatted);
-	if (truncation.firstLineExceedsLimit) {
+	const maxBytes = maxLineBytes;
+	const rowSizes = selected.map((line, index) => ({
+		lineNumber: startLine + index,
+		bytes: Buffer.byteLength(`${selectedHashes[index]}${HASH_SEP}${line}`, "utf-8"),
+	}));
+	if (rowSizes.some((row) => row.bytes > maxBytes)) {
+		const oversized = rowSizes.filter((row) => row.bytes > maxBytes);
+		const rows = rowSizes.map((row, index) =>
+			row.bytes > maxBytes
+				? `[Line ${row.lineNumber} is ${formatSize(row.bytes)}, exceeds ${formatSize(maxBytes)}; content not shown. Use bash: sed -n '${row.lineNumber}p' <path> | head -c ${maxBytes}]`
+				: fmtRegion([selectedHashes[index]!], [selected[index]!]),
+		);
+		const skippedTruncation = truncateHead(rows.join("\n"), { maxBytes });
+		const shownRows = rowSizes.filter((row) => row.bytes <= maxBytes);
+		const lastShownLine = shownRows.at(-1)?.lineNumber ?? startLine - 1;
+		const lineLabel = oversized.length === 1 ? `Line ${oversized[0]!.lineNumber}` : `Lines ${oversized.map((row) => row.lineNumber).join(", ")}`;
+		const verb = oversized.length === 1 ? "exceeds" : "exceed";
+		const addresses = oversized.map((row) => `${row.lineNumber}p`).join(";");
+		const warning = `[${lineLabel} ${verb} ${formatSize(maxBytes)}; content not shown because hashline anchors require full lines. Inspect with bash: sed -n '${addresses}' <path> | head -c ${maxBytes}]`;
+		let preview = skippedTruncation.content;
+		let nextOffset: number | undefined;
+		if (shownRows.length > 0 && (skippedTruncation.truncated || lastShownLine < totalLines)) {
+			nextOffset = lastShownLine + 1;
+			preview += `\n\n${warning}\n${formatPaginationHint(startLine, lastShownLine, totalLines, nextOffset, skippedTruncation.truncated ? skippedTruncation.maxBytes : undefined)}`;
+		} else {
+			preview += `\n\n${warning}`;
+		}
 		return {
-			text: `[Line ${startLine} exceeds ${formatSize(truncation.maxBytes)}. Hashline output requires full lines; cannot compute hashes for a truncated preview.]`,
-			truncation,
+			text: preview,
+			truncation: skippedTruncation.truncated ? skippedTruncation : undefined,
+			...(nextOffset !== undefined ? { nextOffset } : {}),
 		};
 	}
 
+	const truncation = truncateHead(formatted, { maxBytes });
+
 	let preview = truncation.content;
 	let nextOffset: number | undefined;
 	if (truncation.truncated) {

package/src/replace-undo.ts

@@ -101,16 +101,14 @@ export function regReplaceUndo(pi: ExtensionAPI): void {
       }
 
       return withFileMutationQueue(mutationTargetPath, async () => {
-        let currentNormalized: string | undefined;
+        let currentRaw: string | undefined;
         try {
-          const currentRaw = await readFile(mutationTargetPath, "utf-8");
-          const { text: currentStripped } = stripBOM(currentRaw);
-          currentNormalized = toLF(currentStripped);
+          currentRaw = await readFile(mutationTargetPath, "utf-8");
         } catch (error) {
           if (errCode(error) !== "ENOENT") throw error;
         }
 
-        if (currentNormalized === undefined) {
+        if (currentRaw === undefined) {
           return {
             content: [
               {
@@ -122,7 +120,7 @@ export function regReplaceUndo(pi: ExtensionAPI): void {
             details: {},
           };
         }
-        if (currentNormalized !== undo.resultContent) {
+        if (currentRaw !== undo.bom + restoreEndings(undo.resultContent, undo.originalEnding)) {
           return {
             content: [
               {
@@ -135,6 +133,8 @@ export function regReplaceUndo(pi: ExtensionAPI): void {
           };
         }
 
+        const { text: currentStripped } = stripBOM(currentRaw);
+        const currentNormalized = toLF(currentStripped);
         const diffResult = genDiff(undo.content, currentNormalized, 0);
         const linesAddedByReplace = cntDiff(diffResult.diff, "+");
         const linesRemovedByReplace = cntDiff(diffResult.diff, "-");

package/src/replace.ts

@@ -101,7 +101,7 @@ interface PipelineResult {
 
 const ROOT_KS = new Set(["path", "content_lines", "hash_range_inclusive"]);
 
-const LEGACY_KS = ["oldText", "newText", "old_text", "new_text", "old_range", "start", "end", "lines"];
+const LEGACY_KS = ["oldText", "newText", "old_text", "new_text", "old_range", "start", "end", "lines", "changes"];
 
 export function assertNoLegacyKeys(request: unknown): void {
   if (!isRec(request)) return;
@@ -251,11 +251,6 @@ export async function compPreview(
 ): Promise<RPreview> {
   try {
     const normalized = normReq(request);
-    if (isRec(request) && Array.isArray(request.changes)) {
-      return {
-        error: `[E_BAD_SHAPE] The replace tool does not accept a "changes" array. Send hash_range_inclusive and content_lines at the top level (one edit per call).`
-      };
-    }
     assertReq(normalized);
     const { path, originalNormalized, result, resultHashes } = await execPipeline(
       normalized,
@@ -410,8 +405,9 @@ export function buildToolDef(): ToolDef {
 
     async execute(_toolCallId, params, signal, _onUpdate, ctx) {
       const canonical = normReq(params);
+      assertReq(canonical);
 
-      const normalizedParams = canonical as ReqParams;
+      const normalizedParams = canonical;
       const path = normalizedParams.path;
       const absolutePath = toCwd(path, ctx.cwd);
       const mutationTargetPath = await resolveTarget(absolutePath);