pi-hashline-edit-pro 4.3.2 → 4.3.3

package/src/config.ts

@@ -15,6 +15,7 @@ export interface Config {
   autoRead: boolean;
   anchorGrepEnabled: boolean;
   autoReadAll?: AutoReadAllMode;
+  autoReadAllIgnore?: string[];
   requirePath?: boolean;
   strictInput?: boolean;
   boundaryDedupMode?: BoundaryDedupMode;
@@ -25,6 +26,7 @@ const DEFAULT_CONFIG: Config = {
   autoRead: true,
   anchorGrepEnabled: true,
   autoReadAll: "off",
+  autoReadAllIgnore: [],
   requirePath: false,
   strictInput: false,
   boundaryDedupMode: "on",
@@ -47,6 +49,26 @@ function parseAutoReadAllMode(value: unknown): AutoReadAllMode {
   return DEFAULT_CONFIG.autoReadAll ?? "off";
 }
 
+export function normalizeAutoReadAllIgnoreEntry(entry: string): string {
+  return entry.trim().replace(/\\/g, "/").replace(/^\/+|\/+$/g, "").replace(/\/{2,}/g, "/");
+}
+
+export function parseAutoReadAllIgnore(value: unknown): string[] {
+  const raw = typeof value === "string" ? value.split(",") : Array.isArray(value) ? value : [];
+  const seen = new Set<string>();
+  const out: string[] = [];
+  for (const item of raw) {
+    if (typeof item !== "string") continue;
+    const cleaned = normalizeAutoReadAllIgnoreEntry(item);
+    if (cleaned.length === 0) continue;
+    const lower = cleaned.toLowerCase();
+    if (seen.has(lower)) continue;
+    seen.add(lower);
+    out.push(cleaned);
+  }
+  return out;
+}
+
 export function normalizeDiffContextLines(value: unknown): number {
   if (typeof value !== "number" || !Number.isFinite(value)) return DEFAULT_DIFF_CONTEXT_LINES;
   const floored = Math.floor(value);
@@ -68,6 +90,7 @@ function parseConfig(content: string): Config {
   const boundaryDedupMode = parsed.boundaryDedupMode;
   const legacyBoundaryDedup = parsed.boundaryDedupEnabled;
   const diffContextLines = parsed.diffContextLines;
+  const autoReadAllIgnore = parsed.autoReadAllIgnore;
   return {
     autoRead: typeof autoRead === "boolean" ? autoRead : DEFAULT_CONFIG.autoRead,
     anchorGrepEnabled: typeof anchorGrepEnabled === "boolean" ? anchorGrepEnabled : DEFAULT_CONFIG.anchorGrepEnabled,
@@ -76,6 +99,7 @@ function parseConfig(content: string): Config {
     strictInput: typeof strictInput === "boolean" ? strictInput : DEFAULT_CONFIG.strictInput,
     boundaryDedupMode: parseBoundaryDedupMode(boundaryDedupMode, legacyBoundaryDedup),
     diffContextLines: normalizeDiffContextLines(diffContextLines),
+    autoReadAllIgnore: parseAutoReadAllIgnore(autoReadAllIgnore),
   };
 }
 
@@ -222,3 +246,14 @@ export async function adjustDiffContextLines(delta: number): Promise<number> {
   });
   return next;
 }
+export async function setAutoReadAllIgnore(dirs: string[]): Promise<string[]> {
+  let next: string[] = [];
+  await updateConfig((c) => {
+    next = parseAutoReadAllIgnore(dirs);
+    c.autoReadAllIgnore = next;
+  });
+  return next;
+}
+export async function setAutoReadAllIgnoreFromText(text: string): Promise<string[]> {
+  return setAutoReadAllIgnore(text.split(","));
+}

package/src/edit-common.ts

@@ -13,13 +13,15 @@ export interface EditToolFlags {
   strictInput: boolean;
   boundaryDedupMode: BoundaryDedupMode;
   autoRead: boolean;
+  autoReadAllActive: boolean;
 }
 
 export const DEFAULT_EDIT_FLAGS: EditToolFlags = {
   requirePath: false,
   strictInput: false,
   boundaryDedupMode: "on",
-  autoRead: true
+  autoRead: true,
+  autoReadAllActive: false
 };
 
 export async function currentEditFlags(): Promise<EditToolFlags> {
@@ -28,7 +30,8 @@ export async function currentEditFlags(): Promise<EditToolFlags> {
     requirePath: config.requirePath === true,
     strictInput: config.strictInput === true,
     boundaryDedupMode: config.boundaryDedupMode ?? "on",
-    autoRead: config.autoRead !== false
+    autoRead: config.autoRead !== false,
+    autoReadAllActive: (config.autoReadAll ?? "off") !== "off"
   };
 }
 
@@ -38,7 +41,8 @@ export function withReplacePrompts(base: { description: string; snippet: string;
   let guidelines = [...base.guidelines];
   if (!flags.autoRead) {
     description = description.replace(" Anchor follow-up edits on the `+anchor│` and ` anchor│` rows of the post-edit diff instead of re-reading.", "");
-    guidelines = guidelines.map((guideline) => guideline.includes("post-edit diff") ? "`replace`: one batch per file per turn; verify each result before the next edit on that file." : guideline);
+    guidelines = guidelines.filter((guideline) => !guideline.includes("post-edit diff"));
+    description = description.replace("and the last call shows the combined diff,", "and the last call shows the combined result,");
   }
   const descriptionParts = [description];
   if (flags.requirePath) {
@@ -64,13 +68,21 @@ export function withReplacePrompts(base: { description: string; snippet: string;
 }
 
 export function withReadPrompts(base: { description: string; snippet: string; guidelines: string[] }, flags: EditToolFlags): { description: string; snippet: string; guidelines: string[] } {
-  if (flags.autoRead) return { description: base.description, snippet: base.snippet, guidelines: [...base.guidelines] };
-  const guidelines = base.guidelines.map((guideline) => guideline.startsWith("`read`: call again after an edit") ? "`read`: call again after an edit when you need anchors you lack." : guideline);
-  return { description: base.description, snippet: base.snippet, guidelines };
+  if (flags.autoReadAllActive) {
+    const rewritten = base.guidelines
+      .filter((guideline) => !guideline.includes("call again after an edit"))
+    return { description: base.description, snippet: base.snippet, guidelines: [...rewritten] };
+  }
+  const withoutAutoReadAll = base.guidelines.filter((guideline) => !guideline.includes("E_AUTO_READ_ALL"))
+  if (flags.autoRead) return { description: base.description, snippet: base.snippet, guidelines: [...withoutAutoReadAll] };
+  const guidelines = [...withoutAutoReadAll];
+  const mapped = guidelines.map((guideline) => guideline.startsWith("`read`: call again after an edit") ? "`read`: call again after an edit when you need anchors you lack." : guideline);
+  return { description: base.description, snippet: base.snippet, guidelines: mapped };
 }
 
 export function withInsertPrompts(base: { description: string; snippet: string; guidelines: string[] }, flags: EditToolFlags): { description: string; snippet: string; guidelines: string[] } {
-  const descriptionParts = [base.description];
+  const baseDescription = flags.autoRead ? base.description : base.description.replace("and the last call shows the combined diff,", "and the last call shows the combined result,");
+  const descriptionParts = [baseDescription];
   const snippetParts = [base.snippet];
   const guidelines = [...base.guidelines];
   if (flags.requirePath) {
@@ -87,6 +99,12 @@ export function withInsertPrompts(base: { description: string; snippet: string;
   }
   return { description: descriptionParts.join(" "), snippet: snippetParts.join(""), guidelines };
 }
+
+export function withUndoPrompts(base: { description: string; snippet: string; guidelines: string[] }, flags: EditToolFlags): { description: string; snippet: string; guidelines: string[] } {
+  if (flags.autoRead) return { description: base.description, snippet: base.snippet, guidelines: [...base.guidelines] };
+  const guidelines = base.guidelines.map((guideline) => guideline.includes("bad diff") ? "`undo_last_change`: only the last `replace`/`insert` per file is undoable; a `write` clears it, so undo right after a bad edit — review what you're restoring." : guideline);
+  return { description: base.description, snippet: base.snippet, guidelines };
+}
 export function resolveEditTarget(removeFrom: string, removeTo?: string): string {
   const refs = [removeFrom, removeTo].filter((value): value is string => typeof value === "string");
   const owners = refs.map((ref) => ownerOf(parseHashRef(stripAnchorRow(ref.trim(), "anchor entry")).hash));

package/src/file-reader.ts

@@ -1,10 +1,9 @@
 import { constants } from "node:fs";
 import { stat } from "node:fs/promises";
-import { relative } from "node:path";
 import { lineHashes } from "./hashline";
 import { loadFileKindAndText, type LFile } from "./file-kind";
 import { resolveTarget, type FileIdentity } from "./fs-write";
-import { toCwd } from "./paths";
+import { toCwd, toDisplayPath } from "./paths";
 import { detectEnding, toLF, stripBOM, type LineEnding } from "./normalize";
 import { abortIf, errCode, assertLineLimit } from "./utils";
 import { ANCHOR_POOL_EXHAUSTED_PREFIX } from "./constants";
@@ -119,7 +118,7 @@ export async function tryReadNormFile(
   options?: ReadNormOptions,
 ): Promise<NormFile | undefined> {
   try {
-    const displayPath = relative(cwd, absPath).replace(/\\/g, "/") || absPath;
+    const displayPath = toDisplayPath(cwd, absPath);
     const file = await loadFileKindAndText(absPath, { maxLines: options?.maxLines, displayPath });
     if (file.kind !== "text") return undefined;
     return await readNormFile(absPath, cwd, { ...options, preloadedFile: file });

package/src/grep.ts

@@ -2,16 +2,16 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { formatSize, DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, type TruncationResult } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { stat } from "node:fs/promises";
-import { dirname, isAbsolute, join, relative, win32 } from "node:path";
+import { dirname, isAbsolute, join, win32 } from "node:path";
 import { spawn, spawnSync } from "node:child_process";
 import { createInterface } from "node:readline";
 import { tryReadNormFile } from "./file-reader";
 import { MAX_HASH_LINES, fmtRow, HASH_LEN, HASH_SEP } from "./hashline";
 import { ANCHOR_POOL_EXHAUSTED_PREFIX, MAX_GREP_LINE_BYTES } from "./constants";
-import { toCwd } from "./paths";
+import { toCwd, toDisplayPath } from "./paths";
 import { loadP, loadGuide } from "./prompts";
 import { normReq } from "./payload-contract";
-import { abortIf, errCode, isRec, makePrepareArguments, rejectUnknownFields, truncateToBytes, visLines } from "./utils";
+import { abortIf, errCode, gutterWidth, isRec, makePrepareArguments, rejectUnknownFields, truncateToBytes, visLines } from "./utils";
 import { withAnchorSession } from "./anchor-registry";
 import { serveRows } from "./served";
 import { Text } from "@earendil-works/pi-tui";
@@ -152,12 +152,39 @@ function assertSafeRegex(pattern: string): void {
   }
 }
 
-function globToRegex(glob: string): RegExp {
-  if (glob.startsWith("/")) glob = glob.slice(1);
+function bracketEnd(source: string, start: number): number {
+  let j = start + 1;
+  if (j < source.length && (source[j] === "!" || source[j] === "^")) j++;
+  if (j < source.length && source[j] === "]") j++;
+  let esc = false;
+  while (j < source.length) {
+    const c = source[j]!;
+    if (esc) {
+      esc = false;
+      j++;
+      continue;
+    }
+    if (c === "\\") {
+      esc = true;
+      j++;
+      continue;
+    }
+    if (c === "]") return j;
+    j++;
+  }
+  return -1;
+}
+function globPartToSource(glob: string): string {
   let source = "";
   let i = 0;
   while (i < glob.length) {
     const ch = glob[i]!;
+    if (ch === "\\" && i + 1 < glob.length) {
+      const next = glob[i + 1]!;
+      source += next.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      i += 2;
+      continue;
+    }
     if (ch === "*") {
       if (glob[i + 1] === "*") {
         i += 2;
@@ -170,14 +197,146 @@ function globToRegex(glob: string): RegExp {
         continue;
       }
       source += ".*";
-    } else if (ch === "?") {
+      i += 1;
+      continue;
+    }
+    if (ch === "?") {
       source += "[^/]";
-    } else {
-      source += ch.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+      i += 1;
+      continue;
     }
-    i += 1;
+    if (ch === "{") {
+      let depth = 1;
+      let j = i + 1;
+      let esc = false;
+      while (j < glob.length && depth > 0) {
+        const c = glob[j]!;
+        if (esc) {
+          esc = false;
+          j++;
+          continue;
+        }
+        if (c === "\\") {
+          esc = true;
+          j++;
+          continue;
+        }
+        if (c === "[") {
+          const e = bracketEnd(glob, j);
+          if (e >= 0) {
+            j = e + 1;
+            continue;
+          }
+          j++;
+          continue;
+        }
+        if (c === "{") depth++;
+        else if (c === "}") depth--;
+        if (depth === 0) break;
+        j++;
+      }
+      if (depth !== 0) {
+        source += "\\{";
+        i++;
+        continue;
+      }
+      const inner = glob.slice(i + 1, j);
+      const parts: string[] = [];
+      let cur = "";
+      let d2 = 0;
+      let esc2 = false;
+      for (let k = 0; k < inner.length; k++) {
+        const c = inner[k]!;
+        if (esc2) {
+          cur += c;
+          esc2 = false;
+          continue;
+        }
+        if (c === "\\") {
+          esc2 = true;
+          cur += c;
+          continue;
+        }
+        if (c === "[") {
+          const e = bracketEnd(inner, k);
+          if (e >= 0) {
+            cur += inner.slice(k, e + 1);
+            k = e;
+            continue;
+          }
+          cur += c;
+          continue;
+        }
+        if (c === "{") {
+          d2++;
+          cur += c;
+          continue;
+        }
+        if (c === "}") {
+          d2--;
+          cur += c;
+          continue;
+        }
+        if (c === "," && d2 === 0) {
+          parts.push(cur);
+          cur = "";
+          continue;
+        }
+        cur += c;
+      }
+      parts.push(cur);
+      if (parts.length <= 1) {
+        source += "\\{" + globPartToSource(inner) + "\\}";
+      } else {
+        source += "(?:" + parts.map((p) => globPartToSource(p)).join("|") + ")";
+      }
+      i = j + 1;
+      continue;
+    }
+    if (ch === "[") {
+      let j = i + 1;
+      if (j < glob.length && (glob[j] === "!" || glob[j] === "^")) j++;
+      if (j < glob.length && glob[j] === "]") j++;
+      let esc3 = false;
+      while (j < glob.length) {
+        const c = glob[j]!;
+        if (esc3) {
+          esc3 = false;
+          j++;
+          continue;
+        }
+        if (c === "\\") {
+          esc3 = true;
+          j++;
+          continue;
+        }
+        if (c === "]") break;
+        j++;
+      }
+      if (j >= glob.length) {
+        source += "\\[";
+        i++;
+        continue;
+      }
+      let content = glob.slice(i + 1, j);
+      if (content.startsWith("!")) content = "^" + content.slice(1);
+      if (content.startsWith("]") || content.startsWith("^]")) {
+        if (content.startsWith("^]")) content = "^\\]" + content.slice(2);
+        else content = "\\]" + content.slice(1);
+      }
+      if (content.startsWith("^") && !content.includes("/")) content = "^/" + content.slice(1);
+      source += "[" + content + "]";
+      i = j + 1;
+      continue;
+    }
+    source += ch.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+    i++;
   }
-  return new RegExp(`^${source}$`);
+  return source;
+}
+function globToRegex(glob: string): RegExp {
+  if (glob.startsWith("/")) glob = glob.slice(1);
+  return new RegExp(`^${globPartToSource(glob)}$`);
 }
 
 interface FileHit {
@@ -401,14 +560,11 @@ async function collectRgMatches(
   });
 }
 
-function gutterWidthFor(numbers: number[]): number {
-  let max = 0;
-  for (const n of numbers) if (n > max) max = n;
-  return String(max || 1).length;
-}
 
 function displayRowsForHit(hit: FileHit): string[] {
-  const width = gutterWidthFor(hit.lineNumbers);
+  let max = 0;
+  for (const n of hit.lineNumbers) if (n > max) max = n;
+  const width = gutterWidth(max, 1);
   return hit.rows.map((row, i) => {
     const n = hit.lineNumbers[i]!;
     const padded = String(n).padStart(width, " ");
@@ -571,8 +727,8 @@ export function regGrep(pi: ExtensionAPI): void {
         const globRegex = req.glob === undefined ? undefined : globToRegex(req.glob);
         const matchesGlob = (absPath: string): boolean => {
           if (globRegex === undefined) return true;
-          const displayPath = relative(ctx.cwd, absPath).replace(/\\/g, "/");
-          const globPath = relative(globRoot, absPath).replace(/\\/g, "/");
+          const displayPath = toDisplayPath(ctx.cwd, absPath);
+          const globPath = toDisplayPath(globRoot, absPath);
           return globRegex.test(globPath) || globRegex.test(displayPath);
         };
         const validatedRegex = buildRegex(req.pattern, req.literal === true, req.ignoreCase === true);
@@ -613,7 +769,7 @@ export function regGrep(pi: ExtensionAPI): void {
             if (!matchesGlob(absPath)) continue;
             const norm = await readGrepFileShadow(absPath);
             if (!norm) continue;
-            const hit = makeHitFromIndices(norm, relative(ctx.cwd, absPath).replace(/\\/g, "/"), indices, context, validatedRegex, totalForFile, indices.length);
+            const hit = makeHitFromIndices(norm, toDisplayPath(ctx.cwd, absPath), indices, context, validatedRegex, totalForFile, indices.length);
             const display = displayRowsForHit(hit);
             totalRows += display.length;
             for (const r of display) totalBytes += Buffer.byteLength(r, "utf-8") + 1;
@@ -635,7 +791,7 @@ export function regGrep(pi: ExtensionAPI): void {
           if (!matchesGlob(absPath)) continue;
           const norm = await readGrepFile(absPath);
           if (!norm) continue;
-          const hit = makeHitFromIndices(norm, relative(ctx.cwd, absPath).replace(/\\/g, "/"), indices, context, validatedRegex, totalForFile, Math.min(totalForFile, remaining));
+          const hit = makeHitFromIndices(norm, toDisplayPath(ctx.cwd, absPath), indices, context, validatedRegex, totalForFile, Math.min(totalForFile, remaining));
           const display = displayRowsForHit(hit);
           const keptRows: string[] = [];
           const keptHashes: string[] = [];

package/src/hash-store.ts

@@ -3,7 +3,7 @@ import { existsSync } from "node:fs";
 import { chmod, readFile, rename, mkdir, stat } from "node:fs/promises";
 import { hashStorePath, hashStoreDir, legacyHashStorePath } from "./paths";
 import { errCode, isRec, splitLines } from "./utils";
-import { initHasher, contentChecksum } from "./hashline/hasher";
+import { initHasher, contentChecksum, lineChecksum } from "./hashline/hasher";
 import { HASH_STORE_VERSION, HASH_STORE_BUSY_TIMEOUT } from "./constants";
 import {
   isValidHashList,
@@ -22,6 +22,7 @@ import { snapshotCache, cacheSnapshot, SNAPSHOT_CACHE_LIMIT } from "./hash-store
 export { isValidHashList, parseHashList, parseStoredHashes, isCorruptionError };
 export { SNAPSHOT_CACHE_LIMIT };
 export const STORE_NOT_OPEN_MESSAGE = "Hash store is not open; transactional update aborted";
+export const STORE_SHUT_DOWN_MESSAGE = "Hash store was shut down while it was opening; call loadHashStore again.";
 
 type SqlParams = (string | number | null)[];
 
@@ -143,15 +144,16 @@ export interface UndoRecord {
 let cachedDb: { path: string; db: RawDb; stmts: Prepared } | null = null;
 let opening: { path: string; promise: Promise<HashStore> } | null = null;
 let exitHandlerRegistered = false;
+let storeEpoch = 0;
+const liveDbs = new Set<RawDb>();
 
 function openDb(storePath: string): { db: RawDb; stmts: Prepared } {
   const db = openDbFn(storePath);
+  liveDbs.add(db);
   try {
     return buildStore(db);
   } catch (error) {
-    try {
-      db.close();
-    } catch {}
+    shutdownDb(db);
     throw error;
   }
 }
@@ -259,11 +261,15 @@ async function quarantineStore(storePath: string): Promise<void> {
 }
 
 function shutdownDb(db: RawDb): void {
+  if (!liveDbs.delete(db)) return;
   try {
     db.exec("PRAGMA wal_checkpoint(TRUNCATE)");
   } catch {
   }
-  db.close();
+  try {
+    db.close();
+  } catch {
+  }
 }
 
 async function openStore(storePath: string): Promise<HashStore> {
@@ -271,6 +277,7 @@ async function openStore(storePath: string): Promise<HashStore> {
     return { stmts: cachedDb.stmts, engine: sqliteEngine };
   }
   if (cachedDb) shutdownHashStore();
+  const epoch = storeEpoch;
   await initHasher();
   await mkdir(hashStoreDir(), { recursive: true, mode: 0o700 });
   if (process.platform !== "win32") {
@@ -327,6 +334,10 @@ async function openStore(storePath: string): Promise<HashStore> {
       console.error("Hash store migration failed; continuing without legacy import:", error);
     }
   }
+  if (storeEpoch !== epoch) {
+    shutdownDb(db);
+    throw new Error(STORE_SHUT_DOWN_MESSAGE);
+  }
   cachedDb = { path: storePath, db, stmts };
 
   if (!exitHandlerRegistered) {
@@ -352,17 +363,20 @@ export function loadHashStore(): Promise<HashStore> {
     return opening.promise;
   }
   const promise = openStore(storePath).finally(() => {
-    if (opening?.path === storePath) opening = null;
+    if (opening?.promise === promise) opening = null;
   });
   opening = { path: storePath, promise };
   return promise;
 }
 
 export function shutdownHashStore(): void {
+  storeEpoch += 1;
   if (cachedDb) {
     shutdownDb(cachedDb.db);
     cachedDb = null;
   }
+  for (const db of [...liveDbs]) shutdownDb(db);
+  opening = null;
   snapshotCache.clear();
 }
 
@@ -426,7 +440,7 @@ async function migrateLegacy(db: RawDb): Promise<void> {
       contentChecksum(value.content),
       splitLines(value.content).length,
       JSON.stringify(value.hashes),
-      "",
+      JSON.stringify(splitLines(value.content).map(lineChecksum)),
       Date.now(),
     ]);
   }

package/src/hashline/apply.ts

@@ -179,7 +179,7 @@ export function planEdit(
 ): PlannedEdit {
   const signal = options?.signal;
   abortIf(signal);
-  const fileLines = options?.baseFileLines ?? buildIdx(content).fileLines;
+  const fileLines = options?.baseFileLines ?? splitLines(content);
   const lineIndex = { fileLines };
   const fileHashes = precomputedHashes;
   const warnings: string[] = [];

package/src/hashline/hash.ts

@@ -1,8 +1,8 @@
-import { splitLines, truncateToBytes, getCached } from "../utils";
-import { MAX_HASH_SOURCE_BYTES } from "../constants";
+import { splitLines, getCached } from "../utils";
 import { loadHashStore, type HashStore } from "../hash-store";
 import { allocateFileAnchors } from "../anchor-registry";
-import { xxh32, initHasher, contentChecksum } from "./hasher";
+import { xxh32, initHasher, canon, hashSource, lineChecksum } from "./hasher";
+export { canon, hashSource, lineChecksum };
 import { HASH_LEN, ANCHOR_COUNT, anchorAt, HASH_CLASS, HASH_RUN } from "./alphabet";
 export { initHasher, HASH_LEN, HASH_CLASS, HASH_RUN };
 
@@ -48,18 +48,6 @@ export function stripRowPrefix(line: string): StrippedRow {
 	return { text: line, kind: null, hash: undefined };
 }
 
-export function canon(line: string): string {
-	return line.replace(/\r/g, "").trimEnd();
-}
-
-export function hashSource(line: string): string {
-	return truncateToBytes(canon(line), MAX_HASH_SOURCE_BYTES);
-}
-
-export function lineChecksum(line: string): string {
-	return contentChecksum(hashSource(line));
-}
-
 const BITSET_WORDS = Math.ceil(HASH_SPACE / 32);
 
 function getBit(bits: Uint32Array, idx: number): boolean {

package/src/hashline/hasher.ts

@@ -1,4 +1,6 @@
 import xxhash from "xxhash-wasm";
+import { truncateToBytes } from "../utils";
+import { MAX_HASH_SOURCE_BYTES } from "../constants";
 
 export type Hasher = {
 	h32(input: string, seed?: number): number;
@@ -30,4 +32,16 @@ export function xxh32(input: string, seed = 0): number {
 
 export function contentChecksum(content: string): string {
 	return getH().h64ToString(content);
-}
+}
+
+export function canon(line: string): string {
+  return line.replace(/\r/g, "").trimEnd();
+}
+
+export function hashSource(line: string): string {
+  return truncateToBytes(canon(line), MAX_HASH_SOURCE_BYTES);
+}
+
+export function lineChecksum(line: string): string {
+  return contentChecksum(hashSource(line));
+}

package/src/insert.ts

@@ -17,7 +17,7 @@ export { assertInsertReq, type InsertReq };
 
 const insertAnchorSchema = Type.String({
   description:
-    'Bare 4-char anchor from a read row (the text before the `│` separator), never the row content. A pasted diff row or `anchor│` prefix is stripped with a warning. The anchor line is preserved; lines go after or before it.',
+    'Bare 4-char anchor from a served anchor│content row (the text before the `│` separator), never the row content. A pasted diff row or `anchor│` prefix is stripped with a warning. The anchor line is preserved; lines go after or before it.',
 });
 
 const insertDirectionSchema = Type.Union(

package/src/paths.ts

@@ -1,5 +1,5 @@
 import { homedir } from "node:os";
-import { isAbsolute, resolve as resolvePath, join, dirname } from "node:path";
+import { isAbsolute, relative, resolve as resolvePath, join, dirname } from "node:path";
 
 
 function homeBase(): string {
@@ -50,3 +50,7 @@ export function toCwd(filePath: string, cwd: string): string {
   const expanded = expand(filePath);
   return isAbsolute(expanded) ? expanded : resolvePath(cwd, expanded);
 }
+
+export function toDisplayPath(cwd: string, absolutePath: string, fallback?: string): string {
+  return relative(cwd, absolutePath).replace(/\\/g, "/") || (fallback ?? absolutePath);
+}

package/src/payload-contract.ts

@@ -14,12 +14,12 @@ const replacementLinesSchema = Type.Array(
 
 const removeFromSchema = Type.String({
   description:
-    "Bare 4-char anchor from a read row (the text before the `│` separator), never the row content. Marks the FIRST line to remove (inclusive)",
+    "Bare 4-char anchor from a served anchor│content row (the text before the `│` separator), never the row content. Marks the FIRST line to remove (inclusive)",
 });
 
 const removeToSchema = Type.String({
   description:
-    "Bare 4-char anchor from a read row (the text before the `│` separator), never the row content. Marks the LAST line to remove (inclusive)",
+    "Bare 4-char anchor from a served anchor│content row (the text before the `│` separator), never the row content. Marks the LAST line to remove (inclusive)",
 });
 const pathRequiredSchema = Type.String({
   description:

package/src/read.ts

@@ -17,8 +17,11 @@ import { abortIf, makePrepareArguments, numberedRead, visLines, splitLines } fro
 import { loadP, loadGuide } from "./prompts";
 import { withReadPrompts, DEFAULT_EDIT_FLAGS, type EditToolFlags } from "./edit-common";
 import { valAccess } from "./validation";
-import { withAnchorSession } from "./anchor-registry";
+import { readConfig } from "./config";
+import { resolveTarget } from "./fs-write";
+import { withAnchorSession, servedForPath } from "./anchor-registry";
 import { serveRows } from "./served";
+import { getAutoReadAllSnapshot } from "./auto-read-all-state";
 import { Text } from "@earendil-works/pi-tui";
 const R_DESC = loadP("../prompts/read.md");
 const R_SNIPPET = loadP("../prompts/read-snippet.md");
@@ -210,6 +213,22 @@ export function regRead(pi: ExtensionAPI, flags: EditToolFlags = DEFAULT_EDIT_FL
 
 				abortIf(signal);
 				await valAccess(absolutePath, rawPath);
+                const autoReadAllMode = (await readConfig()).autoReadAll ?? "off";
+                if (autoReadAllMode !== "off") {
+                  const canonical = await resolveTarget(absolutePath).catch(() => undefined);
+                  if (canonical !== undefined) {
+                    const stored = getAutoReadAllSnapshot(canonical);
+                    if (stored !== undefined) {
+                      const current = await safeSnapId(canonical, "auto-read-all guard");
+                      if (current !== undefined && current === stored) {
+                        const served = servedForPath(canonical);
+                        if (served !== undefined && served.size > 0) {
+                          throw new Error(`[E_AUTO_READ_ALL] ${rawPath} is unchanged since this session's start-of-session auto-read, so the attached content is still exact. Read succeeds on files that have changed since the full auto read.`);
+                        }
+                      }
+                    }
+                  }
+                }
 
 				abortIf(signal);
 				const file = await loadFileKindAndText(absolutePath, { maxLines: MAX_HASH_LINES, displayPath: rawPath });