pi-hashline-edit-pro 2.8.0 → 2.8.2

package/README.md

@@ -133,7 +133,7 @@ Notes:
 
 ## The grep tool
 
-`grep` replaces the built-in grep with an anchored search. Every matching line (and each requested context line) is returned as an `anchor│content` row, and those rows are recorded in the served state exactly like `read` output, so you can target them with `replace` or `insert` immediately without a separate `read`.
+`grep` replaces the built-in grep with an anchored search backed by ripgrep. Every matching line (and each requested context line) is returned as `lineNumber │ anchor│content` — the `anchor│content` part is served exactly like `read` output, so you can target it with `replace`/`insert` without a separate `read`, while the line-number gutter and `=== path ===` header give filename and line for navigation (press Return to jump).
 
 | Field | Description |
 | --- | --- |
@@ -146,9 +146,10 @@ Notes:
 | `limit` | Maximum number of matched lines to return (default: 100). |
 
 Notes:
-- Results are grouped per file under a `=== path ===` header; every shown row carries the anchor it would have in `read` output.
-- Directory searches skip `node_modules`, `.git`, `.tmp`, and `coverage`. Binary, image, and oversized files are skipped silently.
-- Output is capped at `limit` matched lines, 2000 rows, and 50KB of text (whichever comes first), with a hint naming the cap that cut results. A matched line longer than 500 bytes is shown as a fragment around the match with `...` marking the truncated sides, so the relevant part of the hit stays visible; a context line over 500 bytes is shown as its head with a trailing `...`. Fragments keep the line's anchor (long lines are hashed from their first 500 bytes) and are served like full rows, so a fragmented match is still editable with `replace` (which always replaces the whole line). Directory scans stop after 4000 files with a hint; results may be incomplete.
+- Results are grouped per file under a `=== path ===` header; every shown row is `lineNumber │ anchor│content` where `anchor│content` is the anchor it would have in `read` output.
+- Directory searches use ripgrep, respecting `.gitignore`; `node_modules`, `.git`, `.tmp`, and `coverage` are always skipped. Binary, image, and oversized files are skipped silently.
+- Regex patterns with backreferences, nested quantifiers, quantified alternation, or multiple variable quantifiers are rejected with `[E_UNSAFE_REGEX]` before any files are scanned; use `literal: true` when regex behavior is unnecessary.
+- Output is capped at `limit` matched lines, 2000 rows, and 50KB of text (whichever comes first), with a hint naming the cap that cut results. A matched line longer than 500 bytes is shown as a fragment around the match with `...` marking the truncated sides, so the relevant part of the hit stays visible; a context line over 500 bytes is shown as its head with a trailing `...`. Fragments keep the line's anchor (long lines are hashed from their first 500 bytes) and are served like full rows, so a fragmented match is still editable with `replace` (which always replaces the whole line).
 - `file_path` works as an alias for `path`.
 - Line endings and BOMs survive every edit. The file's line ending is detected from its first newline and restored on write; a file that mixes LF and CRLF (for example a WSL-edited file) is normalized to the first-seen ending.
 - Files with multiple hard links (`nlink > 1`) are rewritten in place rather than via a temp-file rename, so every link keeps seeing the same content; that write is direct rather than atomic.
@@ -206,6 +207,8 @@ Anchors are unique by construction. If a line's base hash collides with an alrea
 
 Hashes live in a persistent per-file store (`~/.config/pi-hashline-edit-pro/hash-store.sqlite`) that keeps the hashes of unchanged lines across edits. When a range is replaced, the runtime maps the old content onto the new content and copies hashes for lines that survived; only genuinely new lines get fresh hashes.
 
+On POSIX systems, the state directory is restricted to mode `0700` and the SQLite database plus its WAL/SHM sidecars to `0600`. The undo table contains the complete pre-edit and post-edit text for the latest edit to each file, so the store should still be treated as sensitive data.
+
 The store also keeps a per-file record of the hashes the model was last served (`read` rows, auto-read blocks, post-edit diff rows), pruned to the file's current hashes on every update so removed lines' hashes do not accumulate. `replace` verifies every line of the resolved range against that record before writing; a line whose hash is missing from the record means it either changed on disk after it was shown or was never shown, and the edit is refused with `[E_RANGE_STALE]`. A `write` clears the record, so edits after a write are verified against whatever the next `read` or auto-read block serves.
 
 Two guarantees make this safe even with duplicated content:
@@ -236,6 +239,8 @@ A no-op replace never changes the file, so anchors remain valid. On first run af
 | `[E_BOUNDARY_BYPASS]` | The boundary anti-duplication was turned off for one replace call (an identical replacement had previously been cut to a noop); the duplicate lines were applied literally. The dedup is restored for the next call. |
 | `[E_FILE_TOO_LARGE]` | The file exceeds the 238,328-line hashline limit or the 100MB size limit. |
 | `[E_WRITE_HASH_ECHO]` | A `write` `content` line begins with the exact `anchor│` served for this file at the same line. The write is refused, file byte-identical; retry with bare content (remove the copied anchors). |
+| `[E_PATH_CHANGED]` | A write target changed identity after it was read; the write was refused to avoid following a swapped symlink or overwriting a replacement file. |
+| `[E_UNSAFE_REGEX]` | A grep regex can trigger excessive backtracking; simplify it or search with `literal: true`. |
 
 ## Troubleshooting
 

package/index.ts

@@ -14,13 +14,14 @@ import {
   toggleAutoRead,
 } from "./src/config";
 import { loadHashStore, pruneMissing } from "./src/hash-store";
-import { recordServedSafe, clearServed } from "./src/served";
+import { recordServedSafe, clearServed, buildServedMap } from "./src/served";
 import { clearBoundaryBypass } from "./src/boundary-bypass";
 import { registerWriteHook } from "./src/write-hook";
 import { readNormFile } from "./src/file-reader";
 import { loadFileKindAndText } from "./src/file-kind";
 import { resolveInCwd } from "./src/fs-write";
 import { valAccess } from "./src/validation";
+import { splitLines } from "./src/utils";
 
 export default function (pi: ExtensionAPI): void {
   regRead(pi);
@@ -37,12 +38,15 @@ export default function (pi: ExtensionAPI): void {
     const active = pi.getActiveTools();
     pi.setActiveTools(active.filter((t) => t !== "edit"));
     await initHasher();
-    try {
-      const store = await loadHashStore();
-      await pruneMissing(store);
-    } catch (err) {
-      console.error("Failed to load or prune hash store:", err);
-    }
+    loadHashStore()
+      .then(store =>
+        pruneMissing(store).catch(err => {
+          console.error("Failed to prune hash store:", err);
+        }),
+      )
+      .catch(err => {
+        console.error("Failed to load hash store:", err);
+      });
     const config = await readConfig();
     autoRead = config.autoRead;
     const debugValue = process.env.PI_HASHLINE_DEBUG;
@@ -95,7 +99,9 @@ export default function (pi: ExtensionAPI): void {
           DEFAULT_MAX_BYTES,
           DEFAULT_MAX_LINES,
         );
-        await recordServedSafe(absolutePath, preview.servedHashes, "auto-read", new Set(fileHashes));
+        const fileLines = splitLines(normalized);
+        const servedMap = buildServedMap(fileHashes, fileLines, preview.servedHashes);
+        await recordServedSafe(absolutePath, servedMap, "auto-read", new Set(fileHashes));
         return {
           content: [
             ...(event.content ?? []),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "2.8.0",
+  "version": "2.8.2",
   "type": "module",
   "description": "Hash-anchored read/replace/insert/grep tools for pi-coding-agent. Every line gets a unique 3-char hash (A-Za-z0-9) that stays stable across edits; stale or ambiguous anchors are rejected, never fuzzy-matched. Undo persists across restarts.",
   "main": "index.ts",
@@ -39,8 +39,8 @@
     ]
   },
   "dependencies": {
-    "diff": "^8.0.2",
-    "file-type": "^21.3.0",
+    "diff": "^9.0.0",
+    "file-type": "^22.0.2",
     "typebox": "^1.3.7",
     "xxhash-wasm": "^1.1.0"
   },
@@ -63,12 +63,12 @@
   "devDependencies": {
     "@earendil-works/pi-coding-agent": "^0.84.0",
     "@eslint/js": "^10.0.1",
-    "@types/node": "^24.0.0",
-    "@vitest/coverage-v8": "^4.1.10",
-    "eslint": "^10.7.0",
-    "typescript": "^5.8.0",
-    "typescript-eslint": "^8.65.0",
-    "vitest": "^4.1.8"
+    "@types/node": "^24",
+    "@vitest/coverage-v8": "^4.1.11",
+    "eslint": "^10.9.1",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.68.0",
+    "vitest": "^4.1.11"
   },
   "allowScripts": {
     "@google/genai@1.52.0": true,

package/prompts/grep-guidelines.md

@@ -1,3 +1,3 @@
-- `grep`: every hit and `context` line comes back as `anchor│content` — use that anchor directly for `replace`/`insert` without a new `read`.
-- `grep`: use `path` for file or folder (default cwd), `glob` like `*.ts` to filter, `literal:true` for literal text, `context:N` for surrounding lines.
-- `grep`: search skips `node_modules/.git/.tmp/coverage` and skips binary/image files.
+- `grep`: every hit and `context` line comes back as `lineNumber │ anchor│content` — the `anchor│content` part is usable directly for `replace`/`insert` without a new `read`, while `lineNumber` enables jump-to-line.
+- `grep`: uses ripgrep, respects `.gitignore`; use `path` for file or folder (default cwd), `glob` like `*.ts` to filter, `literal:true` for literal text, `context:N` for surrounding lines.
+- `grep`: search skips `node_modules/.git/.tmp/coverage` and skips binary/image files.

package/prompts/grep-snippet.md

@@ -1 +1 @@
-Search with `anchor│content` hits usable directly for `replace`/`insert`; use `literal`/`glob`/`context`
+Search with `lineNumber │ anchor│content` hits usable directly for `replace`/`insert`; use `literal`/`glob`/`context`

package/prompts/grep.md

@@ -1 +1 @@
-Search text files for a pattern. Every hit and each `context` line is returned as `anchor│content` so you can use that anchor directly for `replace`/`insert` without a new `read`. Directory search skips `node_modules/.git/.tmp/coverage` and skips binary/image files. Matching lines longer than 500 bytes are shown as a fragment around the match with `...`, but the anchor is still valid for the whole line. If output says truncated, refine `pattern` or raise `limit` as hinted.
+Search text files for a pattern using ripgrep. Every hit and each `context` line is returned as `lineNumber │ anchor│content` — the `anchor│content` part is usable directly for `replace`/`insert` without a new `read`, while `lineNumber` and the `=== path ===` header give file and line for navigation. Respects `.gitignore` via ripgrep; directory search skips `node_modules/.git/.tmp/coverage` and skips binary/image files. Matching lines longer than 500 bytes are shown as a fragment around the match with `...`, but the anchor is still valid for the whole line. If output says truncated, refine `pattern` or raise `limit` as hinted.

package/src/commit.ts

@@ -4,8 +4,9 @@ import { buildChanged, buildNoop, type RMeta, type TResult } from "./replace-res
 import { saveUndo } from "./replace-undo";
 import { safeSnapId } from "./file-reader";
 import { writeAtomic } from "./fs-write";
-import { recordServedDiffSafe } from "./served";
-import { restoreEndings } from "./replace-diff";
+import { recordServedSafe, buildServedMap, servedHashesFromDiff } from "./served";
+import { restoreEndings } from "./normalize";
+import { splitLines } from "./utils";
 
 export interface CommitMeta {
   path: string;
@@ -72,6 +73,7 @@ export async function commitEdit(pipe: PipelineResult, meta: CommitMeta): Promis
     await writeAtomic(
       absolutePath,
       pipe.bom + restoreEndings(pipe.result, pipe.originalEnding),
+      pipe.identity,
     );
   } catch (error) {
     await undo.restore();
@@ -101,7 +103,10 @@ export async function commitEdit(pipe: PipelineResult, meta: CommitMeta): Promis
   };
   const changed = buildChanged(successInput, meta.verb);
   if (changed.details.diff) {
-    await recordServedDiffSafe(mutationTargetPath, changed.details.diff, "post-edit diff", new Set(pipe.resultHashes));
+    const diffHashes = servedHashesFromDiff(changed.details.diff);
+    const resultLines = splitLines(pipe.result);
+    const servedMap = buildServedMap(pipe.resultHashes, resultLines, diffHashes);
+    await recordServedSafe(mutationTargetPath, servedMap, "post-edit diff", new Set(pipe.resultHashes));
   }
   return changed;
 }

package/src/constants.ts

@@ -7,6 +7,6 @@ export const MAX_HASH_SOURCE_BYTES = 500;
 export const MAX_GREP_LINE_BYTES = 500;
 
 export const HASH_STORE_BUSY_TIMEOUT = 1000;
-export const HASH_STORE_VERSION = 5;
+export const HASH_STORE_VERSION = 6;
 export const NEW_CONTENT_NOT_ARRAY_MSG =
   `[E_BAD_SHAPE] "replacement_lines" must be an array of strings, one per line (use [] to delete).`;

package/src/edit-common.ts

@@ -0,0 +1,45 @@
+import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
+import { resolveInCwd } from "./fs-write";
+import { abortIf, makePrepareArguments } from "./utils";
+import { makeRenderCall, renderEditResult, type RPreview, type FgT } from "./replace-render";
+import type { ReplaceDetails } from "./replace";
+
+export const editPrepare = makePrepareArguments();
+
+export function editRenderResultWrapper(
+  result: { content?: Array<{ type: string; text?: string }>; details?: ReplaceDetails },
+  opts: { isPartial: boolean; expanded?: boolean } | boolean,
+  theme: FgT,
+  context: any,
+) {
+  return renderEditResult(result, opts, theme, context);
+}
+
+export function editRenderCallWrapper(
+  preview: (args: unknown, cwd: string) => Promise<RPreview>,
+  getInput?: (args: unknown) => { path?: string } | null,
+  toolName?: string,
+) {
+  return makeRenderCall(preview, { getInput, toolName });
+}
+
+export const editToolBase = {
+  prepareArguments: editPrepare,
+  executionMode: "sequential" as const,
+  renderShell: "default" as const,
+};
+
+export async function queuedEdit<T>(
+  path: string,
+  cwd: string,
+  signal: AbortSignal | undefined,
+  work: (absolute: string, resolved: string) => Promise<T>,
+): Promise<T> {
+  abortIf(signal);
+  const { absolute, resolved } = await resolveInCwd(path, cwd);
+  return withFileMutationQueue(resolved, async () => {
+    abortIf(signal);
+    return work(absolute, resolved);
+  });
+}
+

package/src/file-kind.ts

@@ -2,6 +2,7 @@ import { open as fsOpen, stat as fsStat } from "fs/promises";
 import { fileTypeFromBuffer } from "file-type";
 import { SNIFF_BYTES, MAX_BYTES } from "./constants";
 import { assertLineLimit, lineLimitMoreThanMessage } from "./utils";
+import type { FileIdentity } from "./fs-write";
 
 const IMG_TYPES = new Set<string>([
   "image/bmp",
@@ -54,7 +55,7 @@ function looksLikeText(sample: Uint8Array): boolean {
 export type LFile =
   | { kind: "directory" }
   | { kind: "image"; mimeType: string }
-  | { kind: "text"; text: string; hadUtf8DecodeErrors?: true }
+  | { kind: "text"; text: string; identity?: FileIdentity; hadUtf8DecodeErrors?: true }
   | { kind: "binary"; description: string }
   | { kind: "too_large"; description: string };
 
@@ -87,6 +88,8 @@ export async function loadFileKindAndText(
 
   const fileHandle = await fsOpen(filePath, "r");
   try {
+    const openedStats = await fileHandle.stat();
+    const identity = { dev: openedStats.dev, ino: openedStats.ino };
     const buffer = Buffer.alloc(SNIFF_BYTES);
     const { bytesRead } = await fileHandle.read(
       buffer,
@@ -95,7 +98,7 @@ export async function loadFileKindAndText(
       0,
     );
     if (bytesRead === 0) {
-      return { kind: "text", text: "" };
+      return { kind: "text", text: "", identity };
     }
 
     const sample = buffer.subarray(0, bytesRead);
@@ -179,6 +182,7 @@ export async function loadFileKindAndText(
     return {
       kind: "text",
       text,
+      identity,
       ...(hadUtf8DecodeErrors ? { hadUtf8DecodeErrors: true as const } : {}),
     };
   } finally {

package/src/file-reader.ts

@@ -3,9 +3,9 @@ import { stat } from "fs/promises";
 import { relative } from "path";
 import { lineHashes } from "./hashline";
 import { loadFileKindAndText, type LFile } from "./file-kind";
-import { resolveTarget } from "./fs-write";
+import { resolveTarget, type FileIdentity } from "./fs-write";
 import { toCwd } from "./paths";
-import { detectEnding, toLF, stripBOM, type LineEnding } from "./replace-diff";
+import { detectEnding, toLF, stripBOM, type LineEnding } from "./normalize";
 import { abortIf, errCode, assertLineLimit } from "./utils";
 import { valKind, valAccess } from "./validation";
 import type { HashStore } from "./hash-store";
@@ -16,6 +16,7 @@ export interface NormFile {
   originalEnding: LineEnding;
   fileHashes: string[];
   hadUtf8DecodeErrors: boolean;
+  identity: FileIdentity;
 }
 
 export type SnapInfo = {
@@ -94,12 +95,18 @@ export async function readNormFile(
   if (options?.maxLines !== undefined) assertLineLimit(normalized, path, options.maxLines);
 
   const fileHashes = await lineHashes(normalized, resolvedPath, undefined, options?.store, options?.noPersist !== true);
+  let identity = file.identity;
+  if (!identity) {
+    const { dev, ino } = await stat(resolvedPath);
+    identity = { dev, ino };
+  }
   return {
     absolutePath: resolvedPath,
     normalized,
     bom,
     originalEnding,
     fileHashes,
+    identity,
     hadUtf8DecodeErrors: file.hadUtf8DecodeErrors === true,
   };
 }

package/src/fs-write.ts

@@ -1,6 +1,6 @@
 import { randomUUID } from "crypto";
+import { constants } from "fs";
 import {
-	chmod,
 	lstat,
 	mkdir,
 	open,
@@ -15,6 +15,22 @@ import { dirname, join, parse, resolve, sep } from "path";
 import { toCwd } from "./paths";
 import { errCode } from "./utils";
 
+export interface FileIdentity {
+  dev: number;
+  ino: number;
+}
+
+function sameIdentity(
+  actual: Pick<Awaited<ReturnType<typeof stat>>, "dev" | "ino">,
+  expected: FileIdentity,
+): boolean {
+  return actual.dev === expected.dev && actual.ino === expected.ino;
+}
+
+function pathChanged(path: string): Error {
+  return new Error(`[E_PATH_CHANGED] Refusing to write ${path}: the target changed after it was read.`);
+}
+
 export async function resolveTarget(path: string): Promise<string> {
   const absolutePath = resolve(path);
   const { root } = parse(absolutePath);
@@ -128,6 +144,7 @@ export async function resolveInCwd(path: string, cwd: string): Promise<{ absolut
 export async function writeAtomic(
   path: string,
   content: string,
+  expectedIdentity?: FileIdentity,
 ): Promise<void> {
   const targetPath = await resolveTarget(path);
 
@@ -140,19 +157,25 @@ export async function writeAtomic(
     }
   }
 
+  if (expectedIdentity && (!existingStats || !sameIdentity(existingStats, expectedIdentity))) {
+    throw pathChanged(path);
+  }
+
   if (existingStats && existingStats.nlink > 1) {
-    await writeFile(targetPath, content, "utf-8");
-    try {
-      await chmod(targetPath, existingStats.mode & 0o7777);
-    } catch {}
+    const noFollow = process.platform === "win32" ? 0 : constants.O_NOFOLLOW;
+    const handle = await open(targetPath, constants.O_WRONLY | noFollow);
     try {
-      const handle = await open(targetPath, "r");
+      const openedStats = await handle.stat();
+      if (!sameIdentity(openedStats, existingStats)) throw pathChanged(path);
+      await handle.writeFile(content, "utf-8");
+      await handle.truncate(Buffer.byteLength(content, "utf-8"));
       try {
-        await handle.sync();
-      } finally {
-        await handle.close();
-      }
-    } catch {}
+        await handle.chmod(existingStats.mode & 0o7777);
+      } catch {}
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
     return;
   }
 
@@ -174,6 +197,14 @@ export async function writeAtomic(
   }
   try {
     await tempHandle.close();
+    try {
+      const finalStats = await lstat(targetPath);
+      if (!existingStats || finalStats.isSymbolicLink() || !sameIdentity(finalStats, existingStats)) {
+        throw pathChanged(path);
+      }
+    } catch (error) {
+      if (errCode(error) !== "ENOENT" || existingStats) throw error;
+    }
     await rename(tempPath, targetPath);
     await syncDir(dir);
   } catch (error: unknown) {