pi-hashline-edit-pro 4.3.5 → 4.3.7

package/README.md

@@ -176,7 +176,7 @@ All five tools return machine-readable metadata in `details` alongside the model
 | Tool | `details` |
 | --- | --- |
 | `read` | `truncation` (set when output was truncated), `snapshotId` (a `v2\|path\|ino\|mtime\|ctime\|size` fingerprint), `nextOffset` (use as the next `offset`), and `metrics` with `truncated` and `next_offset`. |
-| `replace`, `insert` | `diff` (post-edit diff, capped, with current anchors on `+HASH│` and ` HASH│` rows; a same-message batch reports the combined diff on its last call and an empty diff on earlier calls), `patch` (a standard unified patch for external tools, capped like the diff), `patchTruncated` (true when the patch was cut or skipped for a pair over 1MB and can no longer be applied as-is), `firstChangedLine`, `snapshotId`, `classification` (`"noop"` when nothing changed), `batch` (`{ id, size, last, total }` marking same-message batch membership), and `metrics`: `edits_attempted`, `edits_noop`, `warnings`, `classification` (`"applied"` or `"noop"`), `changed_lines` (`{ first, last }`), `added_lines`, `removed_lines`. |
+| `replace`, `insert` | `diff` (post-edit diff, capped, with current anchors on `+HASH│` and ` HASH│` rows; a same-message batch reports the combined diff on its last call and an empty diff on earlier calls), `patch` (a standard unified patch for external tools, capped like the diff), `patchTruncated` (true when the patch was cut or skipped for a pair over 1MB and can no longer be applied as-is), `firstChangedLine`, `snapshotId`, `classification` (`"noop"` when nothing changed), `batch` (`{ id, size, last, total }` marking same-message batch membership; earlier members also carry `aborted: true` and `abortMessage` after a batch abort), and `metrics`: `edits_attempted`, `edits_noop`, `warnings`, `classification` (`"applied"` or `"noop"`), `changed_lines` (`{ first, last }`), `added_lines`, `removed_lines`. |
 | `undo_last_change` | `diff` (the undo diff with restored anchors), `patch`, `patchTruncated`, and `metrics` in the same shape as `replace`. |
 | `anchor_grep` | `metrics` with `matches` (capped at `limit`), `files`, and `truncated`; `truncation` (the standard pi truncation report) when output was cut; and `linesTruncated` (true when long lines were shown as fragments). |
 
@@ -261,6 +261,7 @@ Codes starting with `E_` are errors: nothing was written — except `File was wr
 - Stale anchors. `[E_STALE_ANCHOR]` means an anchor is not owned in this session: it was never shown to you, or its line was edited or the file was rewritten since. Call `read` for fresh anchors and retry.
 - Range changed on disk. `[E_RANGE_STALE]` means a line inside the replaced range changed after it was last shown to you (or was never shown). Nothing was modified; the error carries the current range with fresh anchors, so retry with those without a `read`.
 - Multi-conversation hosts. Anchors, served records, and ownership logs are resolved per calling session, so a tool call in one conversation is never answered by another conversation's registry; a foreign anchor fails with `[E_STALE_ANCHOR]`. Interactive previews are the one exception: pi does not pass the session into render callbacks, so when one process serves several conversations at once a preview can fall back to the most recently active session and show a stale or wrong-file diff. Previews never write files or claim anchors; run the call for the authoritative result.
+- Undo scope. `undo_last_change` records are keyed by file path, not by session, so in a multi-conversation host any conversation that names the file can revert its most recent `replace` or `insert`, even one made by another conversation. Anchor ownership remains session-scoped; only undo is shared.
 - Reset the anchor state. Anchors live in `~/.config/pi-hashline-edit-pro/hash-store.sqlite` (with `-wal`/`-shm` sidecars) and in per-session ownership logs under `~/.config/pi-hashline-edit-pro/sessions/`. Quit pi, delete those files, and everything is rebuilt on the next session. Anchor history is lost, but no project files are touched.
 - Corrupt store. If the store fails its health check it is renamed to `hash-store.sqlite.corrupt-<timestamp>` and rebuilt automatically.
 - Config directory moved. If `XDG_CONFIG_HOME` is set on a non-Windows platform, the config directory (and the anchor state inside it) lives at `$XDG_CONFIG_HOME/pi-hashline-edit-pro` instead of `~/.config/pi-hashline-edit-pro`. An existing store is not migrated automatically. To keep anchor and undo history, move the old `hash-store.sqlite` files (plus `-wal`/`-shm` sidecars) into the new directory before the first run.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "4.3.5",
+  "version": "4.3.7",
   "type": "module",
   "description": "Hash-anchored read/replace/insert/grep tools for pi-coding-agent. Every line gets a unique 4-char tokenizer-friendly anchor that stays stable across edits; stale or ambiguous anchors are rejected, never fuzzy-matched. Undo persists across restarts.",
   "main": "index.ts",
@@ -57,11 +57,10 @@
     "test:watch": "vitest",
     "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",
-    "prepublishOnly": "npm run typecheck && npm run lint && npm test"
+    "typecheck": "tsc --noEmit"
   },
   "devDependencies": {
-    "@earendil-works/pi-coding-agent": "^0.84.0",
+    "@earendil-works/pi-coding-agent": "^0.87.0",
     "@eslint/js": "^10.0.1",
     "@types/node": "^24",
     "@vitest/coverage-v8": "^4.1.11",

package/src/auto-read-all.ts

@@ -388,6 +388,16 @@ export function chunkAutoReadAllSections(sections: string[], maxBytes: number =
   if (current.length > 0) chunks.push(current.join("\n\n"));
   return chunks;
 }
+
+async function candidateFileBytes(cwd: string, file: string): Promise<number | undefined> {
+  try {
+    const stats = await lstat(resolve(cwd, file));
+    return stats.isFile() ? stats.size : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
 async function renderFile(file: string, cwd: string): Promise<AutoReadAllSection | undefined> {
   try {
     const { normalized, fileHashes, absolutePath } = await readNormFile(file, cwd, { maxLines: MAX_HASH_LINES });
@@ -427,6 +437,13 @@ export async function buildAutoReadAllInjection(cwd: string, budgetBytes: number
   let bytes = 0;
   let completeFiles = 0;
   for (const file of discovery.files) {
+    if (sections.length > 0) {
+      const size = await candidateFileBytes(cwd, file);
+      if (size !== undefined && bytes + size > budgetBytes) {
+        omitted.push(file);
+        continue;
+      }
+    }
     const section = await renderFile(file, cwd);
     if (section === undefined) {
       omitted.push(file);

package/src/batch.ts

@@ -23,11 +23,11 @@ import { assertInsertReq, assertReq, normReq } from "./payload-contract";
 import { saveUndo } from "./replace-undo";
 import { buildChanged, buildNoop, type RMetrics, type TResult } from "./replace-response";
 import { serveRows, servedHashesFromDiff } from "./served";
-import { abortIf, assertLineLimit, errCode, isRec, splitLines } from "./utils";
-import { MAX_BYTES } from "./constants";
+import { abortIf, assertByteLimit, assertLineLimit, errCode, isRec, splitLines } from "./utils";
 
 export interface PlannedMember {
   batchKey: number;
+  id: string;
   display: number;
   total: number;
   target: string;
@@ -126,12 +126,18 @@ const batches = new Map<number, BatchState>();
 let nextBatchKey = 1;
 const abortedMembers = new Map<string, { display: number; message: string }>();
 const ABORTED_MEMBERS_LIMIT = 1024;
+const placeholderResults = new Map<string, TResult>();
 
 function markBatchMembersAborted(runtime: BatchState): void {
   const message = abortedBatchMessage(runtime);
   for (const id of runtime.memberIds) {
     abortedMembers.delete(id);
     abortedMembers.set(id, { display: runtime.display, message });
+    const result = placeholderResults.get(id);
+    if (result?.details.batch) {
+      result.details.batch.aborted = true;
+      result.details.batch.abortMessage = message;
+    }
   }
   while (abortedMembers.size > ABORTED_MEMBERS_LIMIT) {
     const oldest = abortedMembers.keys().next().value;
@@ -157,6 +163,7 @@ export function resetBatchStateForTests(): void {
   plan.clear();
   batches.clear();
   abortedMembers.clear();
+  placeholderResults.clear();
   nextBatchKey = 1;
 }
 
@@ -203,7 +210,12 @@ function enforceCap(): void {
     if (oldest === undefined) return;
     const state = batches.get(oldest);
     batches.delete(oldest);
-    if (state) for (const id of state.memberIds) plan.delete(id);
+    if (state) {
+      for (const id of state.memberIds) {
+        plan.delete(id);
+        placeholderResults.delete(id);
+      }
+    }
   }
 }
 
@@ -274,6 +286,7 @@ export async function planAssistantMessage(message: unknown, cwd: string): Promi
     group.forEach((item, index) => {
       plan.set(item.id, {
         batchKey: key,
+        id: item.id,
         display,
         total: finalGroups.length,
         target: item.target,
@@ -521,7 +534,11 @@ export async function executeBatchMember(input: BatchMemberInput): Promise<TResu
   if (noop) runtime.noops += 1;
   else runtime.applied += 1;
   runtime.warnings.push(...piece.warnings);
-  if (!input.member.last) return batchPlaceholder(input.member, piece, base.snapshotId);
+  if (!input.member.last) {
+    const placeholder = batchPlaceholder(input.member, piece, base.snapshotId);
+    placeholderResults.set(input.member.id, placeholder);
+    return placeholder;
+  }
   return finishBatch(input.member, input.signal);
 }
 
@@ -633,9 +650,7 @@ async function finishBatch(member: PlannedMember, signal?: AbortSignal): Promise
     assertNotEmpty(base.content, composed);
     assertLineLimit(composed, paths.displayPath, MAX_HASH_LINES);
     const finalBytes = base.bom + restoreEndings(composed, base.ending);
-    if (Buffer.byteLength(finalBytes, "utf-8") > MAX_BYTES) {
-      throw new Error(`[E_FILE_TOO_LARGE] File is too large: ${paths.displayPath} (exceeds the ${MAX_BYTES / (1024 * 1024)}MB size limit). For very large files, use write.`);
-    }
+    assertByteLimit(finalBytes, paths.displayPath);
   } catch (error) {
     discardBatchState(runtime);
     if (error instanceof Error) error.message = withAbortSuffix(error.message, runtime.display);
@@ -739,7 +754,7 @@ async function finishBatch(member: PlannedMember, signal?: AbortSignal): Promise
     await getDiffContextLines(),
   );
   changed.details.diff = `${header}\n${changed.details.diff}`;
-  changed.details.diffLineNumbers?.unshift(undefined);
+  changed.details.diffLineNumbers?.unshift(null);
   try {
     serveRows(runtime.target, resultHashes, splitLines(composed), servedHashesFromDiff(changed.details.diff));
   } catch (error) {
@@ -786,7 +801,10 @@ export async function finalizeTurn(toolCallIds: string[]): Promise<void> {
   for (const key of keys) {
     const runtime = batches.get(key);
     if (!runtime) continue;
-    for (const id of runtime.memberIds) plan.delete(id);
+    for (const id of runtime.memberIds) {
+      plan.delete(id);
+      placeholderResults.delete(id);
+    }
     batches.delete(key);
   }
 }

package/src/commit.ts

@@ -1,6 +1,6 @@
 import { readFile } from "node:fs/promises";
 import type { PipelineResult } from "./replace";
-import { abortIf, errCode, splitLines } from "./utils";
+import { abortIf, assertByteLimit, errCode, splitLines } from "./utils";
 import { DEDUP_ANCHOR } from "./constants";
 import { HASH_SEP } from "./hashline";
 import { buildChanged, buildNoop, type RMeta, type TResult } from "./replace-response";
@@ -70,6 +70,9 @@ export async function commitEdit(pipe: PipelineResult, meta: CommitMeta): Promis
     );
   }
 
+  const finalFileBytes = pipe.bom + restoreEndings(pipe.result, pipe.originalEnding);
+  assertByteLimit(finalFileBytes, path);
+
   if (pipe.hadUtf8DecodeErrors) {
     warnings.push(
       "Non-UTF-8 bytes were shown as U+FFFD; this edit rewrote the file as UTF-8.",
@@ -112,7 +115,7 @@ export async function commitEdit(pipe: PipelineResult, meta: CommitMeta): Promis
     abortIf(signal);
     await writeAtomic(
       absolutePath,
-      pipe.bom + restoreEndings(pipe.result, pipe.originalEnding),
+      finalFileBytes,
       pipe.identity,
     );
   } catch (error) {

package/src/hashline/alphabet.ts

@@ -16,22 +16,6 @@ export const HASH_RUN = `[${LETTERS}]{${HASH_LEN},${HASH_LEN + 1}}`;
 
 export const HASH_RE = new RegExp(`^${HASH_CLASS}$`);
 
-let indexByAnchor: Map<string, number> | undefined;
-
-function reverseIndex(): Map<string, number> {
-  if (!indexByAnchor) {
-    indexByAnchor = new Map();
-    for (let i = 0; i < ANCHOR_COUNT; i++) {
-      indexByAnchor.set(TABLE.slice(i * HASH_LEN, i * HASH_LEN + HASH_LEN), i);
-    }
-  }
-  return indexByAnchor;
-}
-
 export function anchorAt(idx: number): string {
   return TABLE.slice(idx * HASH_LEN, idx * HASH_LEN + HASH_LEN);
 }
-
-export function anchorIndex(hash: string): number {
-  return reverseIndex().get(hash) ?? -1;
-}

package/src/hashline/apply.ts

@@ -1,5 +1,4 @@
 import { abortIf, clipLine, splitLines } from "../utils";
-import { _lineHashesPure } from "./hash";
 import {
 	valEdit,
 	stripBarePrefixes,

package/src/replace-render.ts

@@ -42,7 +42,7 @@ export function colorLines(lines: string[], theme: FgT): string[] {
 		return theme.fg("dim", line);
 	});
 }
-export function toNumberedDiff(diff: string, lineNumbers: (number|undefined)[]): string {
+export function toNumberedDiff(diff: string, lineNumbers: (number | null | undefined)[]): string {
 	return withLineNumbers(diff, lineNumbers);
 }
 
@@ -162,7 +162,7 @@ function extractSummary(text: string | undefined): string | undefined {
 
 const BATCH_HEADER_RE = /^batch \d+:\n/;
 
-function splitBatchHeader(diff: string, lineNumbers: (number | undefined)[] | undefined): { header: string | undefined; body: string; lineNumbers: (number | undefined)[] | undefined } {
+function splitBatchHeader(diff: string, lineNumbers: (number | null | undefined)[] | undefined): { header: string | undefined; body: string; lineNumbers: (number | null | undefined)[] | undefined } {
 	const match = diff.match(BATCH_HEADER_RE);
 	if (!match) return { header: undefined, body: diff, lineNumbers };
 	return { header: match[0]!.slice(0, -1), body: diff.slice(match[0].length), lineNumbers: lineNumbers?.slice(1) };

package/src/replace-response.ts

@@ -240,7 +240,7 @@ export function buildChanged(input: SuccessInput, verb = "replaced", diffContext
         editMeta.firstChangedLine ?? baseDiff.firstChangedLine,
       snapshotId,
       metrics,
-      diffLineNumbers: diffResult.lineNumbers,
+      diffLineNumbers: diffResult.lineNumbers.map((line) => line ?? null),
       ...(warnings?.length ? { warnings: [...warnings] } : {}),
     },
   };

package/src/replace-undo.ts

@@ -248,7 +248,7 @@ export function regUndo(pi: ExtensionAPI, flags: EditToolFlags = DEFAULT_EDIT_FL
             ],
             details: {
               diff: undoDiff,
-              diffLineNumbers: undoDiffResult.lineNumbers,
+              diffLineNumbers: undoDiffResult.lineNumbers.map((line) => line ?? null),
               patch: patchResult.patch,
               ...(patchResult.truncated ? { patchTruncated: true as const } : {}),
               metrics: buildMetrics({

package/src/replace.ts

@@ -45,9 +45,9 @@ export type ReplaceDetails = {
   snapshotId?: string;
   classification?: "noop";
   metrics?: RMetrics;
-  diffLineNumbers?: (number|undefined)[];
+  diffLineNumbers?: (number | null)[];
   warnings?: string[];
-  batch?: { id: number; size: number; last: boolean; total: number };
+  batch?: { id: number; size: number; last: boolean; total: number; aborted?: boolean; abortMessage?: string };
 };
 
 export interface PipelineResult {

package/src/utils.ts

@@ -1,4 +1,4 @@
-import { NUL_CONTENT_MSG } from "./constants";
+import { NUL_CONTENT_MSG, MAX_BYTES } from "./constants";
 import { HASH_CLASS } from "./hashline/alphabet";
 
 export function isRec(value: unknown): value is Record<string, unknown> {
@@ -173,14 +173,14 @@ export function numberedRead(text: string, offset: number): string {
 	}).join("\n");
 }
 
-export function withLineNumbers(text: string, numbers: (number|undefined)[]): string {
+export function withLineNumbers(text: string, numbers: (number | null | undefined)[]): string {
 	const lines = text.split("\n");
 	const nums = numbers ?? [];
-	const max = nums.reduce<number>((m, n) => n !== undefined && n > m ? n : m, 0);
+	const max = nums.reduce<number>((m, n) => n !== undefined && n !== null && n > m ? n : m, 0);
 	const width = gutterWidth(max, lines.length);
 	return lines.map((line, i) => {
 		const n = nums[i];
-		const prefix = n !== undefined ? formatGutter(n, width) : blankGutter(width);
+		const prefix = n !== undefined && n !== null ? formatGutter(n, width) : blankGutter(width);
 		return prefix + line;
 	}).join("\n");
 }
@@ -192,6 +192,11 @@ export function assertLineLimit(content: string, displayPath: string, limit: num
 	const count = splitLines(content).length;
 	if (count > limit) throw new Error(formatLineLimit(displayPath, limit, count));
 }
+export function assertByteLimit(content: string, displayPath: string, limit = MAX_BYTES): void {
+	if (Buffer.byteLength(content, "utf-8") > limit) {
+		throw new Error(`[E_FILE_TOO_LARGE] File is too large: ${displayPath} (exceeds the ${limit / (1024 * 1024)}MB size limit). For very large files, use write.`);
+	}
+}
 export function lineLimitMoreThanMessage(displayPath: string, limit: number): string {
 	return formatLineLimit(displayPath, limit, undefined);
 }