pi-hashline-edit-pro 4.2.0 → 4.2.2

package/src/commit.ts

@@ -1,16 +1,17 @@
+import { readFile } from "fs/promises";
 import type { PipelineResult } from "./replace";
-import { abortIf } from "./utils";
+import { abortIf, errCode, splitLines } from "./utils";
 import { DEDUP_ANCHOR } from "./constants";
 import { HASH_SEP } from "./hashline";
 import { buildChanged, buildNoop, type RMeta, type TResult } from "./replace-response";
 import { saveUndo } from "./replace-undo";
+import { getDiffContextLines } from "./config";
 import { safeSnapId } from "./file-reader";
 import { writeAtomic } from "./fs-write";
 import { servedHashesFromDiff, buildServedMap } from "./served";
 import { lineHashes } from "./hashline";
 import { hashSpan } from "./replace";
-import { restoreEndings } from "./normalize";
-import { splitLines } from "./utils";
+import { restoreEndings, stripBOM, toLF } from "./normalize";
 import { markServed as markServedScoped } from "./anchor-registry";
 export interface CommitMeta {
   editAnchors?: [string, string];
@@ -70,6 +71,22 @@ export async function commitEdit(pipe: PipelineResult, meta: CommitMeta): Promis
   }
 
   abortIf(signal);
+  let currentRaw: string | undefined;
+  try {
+    currentRaw = await readFile(mutationTargetPath, "utf-8");
+  } catch (error) {
+    const code = errCode(error);
+    if (code === "ENOENT") currentRaw = undefined;
+    else if (code === "EACCES" || code === "EPERM") throw new Error(`[E_ACCESS] File is not readable: ${path}`);
+    else if (code === "ELOOP") throw new Error(`[E_ACCESS] Too many symbolic links while resolving: ${path}`);
+    else throw error;
+  }
+  if (currentRaw === undefined) {
+    throw new Error(`[E_OP_ABORTED] Edit aborted: the file was deleted after the edit started.`);
+  }
+  if (toLF(stripBOM(currentRaw).text) !== pipe.originalNormalized) {
+    throw new Error(`[E_OP_ABORTED] Edit aborted: the file changed after the edit started. Call read for fresh anchors and retry.`);
+  }
   const undo = await saveUndo(mutationTargetPath, {
     content: pipe.originalNormalized,
     bom: pipe.bom,
@@ -79,7 +96,7 @@ export async function commitEdit(pipe: PipelineResult, meta: CommitMeta): Promis
   });
   if (!undo.persisted) {
     throw new Error(
-      `[E_UNDO_UNAVAILABLE] Could not persist undo history; the edit was not applied and ${path} is unchanged.`
+      `[E_UNDO_UNAVAILABLE] Could not persist undo history for ${path}.`
     );
   }
   try {
@@ -108,13 +125,19 @@ export async function commitEdit(pipe: PipelineResult, meta: CommitMeta): Promis
   const span = meta.editAnchors ? hashSpan(pipe.originalHashes, meta.editAnchors[0], meta.editAnchors[1]) : undefined;
   const resultCount = splitLines(pipe.result).length;
   const replacementCount = span ? resultCount - (pipe.originalHashes.length - (span[1] - span[0] + 1)) : 0;
-  const resultHashes = pipe.result === pipe.originalNormalized
-    ? pipe.originalHashes
-    : await lineHashes(pipe.result, mutationTargetPath, {
+  let resultHashes: string[];
+  try {
+    resultHashes = pipe.result === pipe.originalNormalized
+      ? pipe.originalHashes
+      : await lineHashes(pipe.result, mutationTargetPath, {
         content: pipe.originalNormalized,
         hashes: pipe.originalHashes,
         spans: span ? [{ start: span[0], end: span[1], replacementCount }] : undefined,
       });
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new Error(`${detail} File was written; anchor finalization failed. One undo reverts. Call read for fresh anchors.`);
+  }
   const successInput = {
     path,
     originalNormalized: pipe.originalNormalized,
@@ -127,7 +150,7 @@ export async function commitEdit(pipe: PipelineResult, meta: CommitMeta): Promis
     boundaryDedupAbove: pipe.boundaryDedupAbove,
     boundaryDedupBelow: pipe.boundaryDedupBelow,
   };
-  const changed = buildChanged(successInput, meta.verb);
+  const changed = buildChanged(successInput, meta.verb, await getDiffContextLines());
   if (changed.details.diff) {
     markServedScoped(
       mutationTargetPath,

package/src/config-ui.ts

@@ -2,7 +2,7 @@ import { Key, matchesKey, visibleWidth } from "@earendil-works/pi-tui";
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import { readConfig, type Config } from "./config";
 
-export type ConfigToggleKey = "autoRead" | "anchorGrepEnabled" | "requirePath" | "strictInput" | "boundaryDedupMode";
+export type ConfigToggleKey = "autoRead" | "anchorGrepEnabled" | "requirePath" | "strictInput" | "boundaryDedupMode" | "diffContextLines";
 
 export interface ConfigRow {
   key: ConfigToggleKey;
@@ -11,11 +11,14 @@ export interface ConfigRow {
   enabled: boolean;
   mode?: string;
   cycle?: string[];
+  value?: number;
+  disabled?: boolean;
 }
 
 export function configRows(config: Config): ConfigRow[] {
   return [
     { key: "autoRead", label: "Auto-read", hint: "Anchors after write + post-edit diffs", enabled: config.autoRead !== false },
+    { key: "diffContextLines", label: "Diff context", hint: "Surrounding lines in post-edit diffs (needs Auto-read)", enabled: config.autoRead !== false, value: config.diffContextLines ?? 1, disabled: config.autoRead === false },
     { key: "anchorGrepEnabled", label: "Anchor grep", hint: "anchor_grep tool (builtin grep off while on)", enabled: config.anchorGrepEnabled === true },
     { key: "requirePath", label: "Require path", hint: "replace + insert need path (RPC visibility)", enabled: config.requirePath === true },
     { key: "strictInput", label: "Strict input", hint: "Reject auto-fixable slips instead of warnings", enabled: config.strictInput === true },
@@ -34,11 +37,16 @@ function modeBox(theme: Theme, mode: string): string {
   return theme.fg("success", `[${mode}]`);
 }
 
+function numberBox(theme: Theme, value: number, disabled?: boolean): string {
+  if (disabled) return theme.fg("dim", `[${value}]`);
+  return theme.fg("accent", `[${value}]`);
+}
+
 export class HashlineConfigOverlay {
   private rows: ConfigRow[];
   private selected = 0;
 
-  constructor(private readonly opts: { tui: { requestRender(force?: boolean): void }; theme: Theme; done: () => void; onToggle: (key: ConfigToggleKey) => Promise<void> }) {
+  constructor(private readonly opts: { tui: { requestRender(force?: boolean): void }; theme: Theme; done: () => void; onToggle: (key: ConfigToggleKey, delta?: number) => Promise<void> }) {
     this.rows = [];
   }
 
@@ -46,9 +54,24 @@ export class HashlineConfigOverlay {
     this.rows = configRows(await readConfig());
   }
 
+  private runToggle(row: ConfigRow, delta?: number): void {
+    this.opts.tui.requestRender(true);
+    void this.opts.onToggle(row.key, delta).then(async () => {
+      this.rows = configRows(await readConfig());
+      this.opts.tui.requestRender(true);
+    }).catch((error: unknown) => {
+      console.error("Failed to toggle hashline setting:", error);
+    });
+  }
+
   private toggleSelected(): void {
     const row = this.rows[this.selected];
-    if (!row) return;
+    if (!row || row.disabled) return;
+    if (row.value !== undefined) {
+      row.value += 1;
+      this.runToggle(row, 1);
+      return;
+    }
     if (row.cycle && row.mode !== undefined) {
       const next = row.cycle[(row.cycle.indexOf(row.mode) + 1) % row.cycle.length] ?? row.cycle[0];
       if (next === undefined) return;
@@ -57,13 +80,14 @@ export class HashlineConfigOverlay {
     } else {
       row.enabled = !row.enabled;
     }
-    this.opts.tui.requestRender(true);
-    void this.opts.onToggle(row.key).then(async () => {
-      this.rows = configRows(await readConfig());
-      this.opts.tui.requestRender(true);
-    }).catch((error: unknown) => {
-      console.error("Failed to toggle hashline setting:", error);
-    });
+    this.runToggle(row);
+  }
+
+  private adjustSelected(delta: number): void {
+    const row = this.rows[this.selected];
+    if (!row || row.disabled || row.value === undefined) return;
+    row.value += delta;
+    this.runToggle(row, delta);
   }
 
   handleInput(data: string): void {
@@ -75,6 +99,14 @@ export class HashlineConfigOverlay {
       this.selected = (this.selected + 1) % this.rows.length;
       return;
     }
+    if (matchesKey(data, Key.right) || data === "+" || data === "=") {
+      this.adjustSelected(1);
+      return;
+    }
+    if (matchesKey(data, Key.left) || data === "-" || data === "_") {
+      this.adjustSelected(-1);
+      return;
+    }
     if (matchesKey(data, Key.space) || matchesKey(data, Key.enter) || data === " " || data === "\r" || data === "\n") {
       this.toggleSelected();
       return;
@@ -96,12 +128,12 @@ export class HashlineConfigOverlay {
     lines.push(theme.fg("border", `├${"─".repeat(innerWidth)}┤`));
     this.rows.forEach((row, index) => {
       const cursor = index === this.selected ? theme.fg("accent", "> ") : "  ";
-      const box = row.mode !== undefined ? modeBox(theme, row.mode) : row.enabled ? theme.fg("success", "[x]") : theme.fg("dim", "[ ]");
-      const label = index === this.selected ? theme.fg("accent", theme.bold(row.label)) : row.label;
+      const box = row.value !== undefined ? numberBox(theme, row.value, row.disabled) : row.mode !== undefined ? modeBox(theme, row.mode) : row.enabled ? theme.fg("success", "[x]") : theme.fg("dim", "[ ]");
+      const label = row.disabled ? theme.fg("dim", row.label) : index === this.selected ? theme.fg("accent", theme.bold(row.label)) : row.label;
       lines.push(padRow(theme, innerWidth, `${cursor}${box} ${label} ${theme.fg("dim", `— ${row.hint}`)}`));
     });
     lines.push(theme.fg("border", `├${"─".repeat(innerWidth)}┤`));
-    lines.push(padRow(theme, innerWidth, theme.fg("dim", " ↑↓ navigate · space toggle · q close")));
+    lines.push(padRow(theme, innerWidth, theme.fg("dim", " ↑↓ navigate · space toggle · ←/→ or -/+ adjust · q close")));
     lines.push(theme.fg("border", `╰${"─".repeat(innerWidth)}╯`));
     return lines;
   }

package/src/config.ts

@@ -1,16 +1,21 @@
-import { readFile } from "fs/promises";
+import { mkdir, readFile, rename, rm, stat } from "fs/promises";
+import { dirname } from "path";
 import { configPath } from "./paths";
 import { errCode, isRec } from "./utils";
 import { writeAtomic } from "./fs-write";
-
 export type BoundaryDedupMode = "on" | "off" | "strict";
 
+export const DEFAULT_DIFF_CONTEXT_LINES = 1;
+export const MIN_DIFF_CONTEXT_LINES = 0;
+export const MAX_DIFF_CONTEXT_LINES = 10;
+
 export interface Config {
   autoRead: boolean;
   anchorGrepEnabled: boolean;
   requirePath?: boolean;
   strictInput?: boolean;
   boundaryDedupMode?: BoundaryDedupMode;
+  diffContextLines?: number;
 }
 
 const DEFAULT_CONFIG: Config = {
@@ -18,7 +23,8 @@ const DEFAULT_CONFIG: Config = {
   anchorGrepEnabled: true,
   requirePath: false,
   strictInput: false,
-  boundaryDedupMode: "on"
+  boundaryDedupMode: "on",
+  diffContextLines: DEFAULT_DIFF_CONTEXT_LINES
 };
 
 const BOUNDARY_DEDUP_MODES: BoundaryDedupMode[] = ["on", "strict", "off"];
@@ -30,6 +36,14 @@ function parseBoundaryDedupMode(mode: unknown, legacy: unknown): BoundaryDedupMo
   return DEFAULT_CONFIG.boundaryDedupMode ?? "on";
 }
 
+export function normalizeDiffContextLines(value: unknown): number {
+  if (typeof value !== "number" || !Number.isFinite(value)) return DEFAULT_DIFF_CONTEXT_LINES;
+  const floored = Math.floor(value);
+  if (floored < MIN_DIFF_CONTEXT_LINES) return MIN_DIFF_CONTEXT_LINES;
+  if (floored > MAX_DIFF_CONTEXT_LINES) return MAX_DIFF_CONTEXT_LINES;
+  return floored;
+}
+
 function parseConfig(content: string): Config {
   const parsed = JSON.parse(content) as unknown;
   const autoRead = isRec(parsed) ? parsed.autoRead : undefined;
@@ -41,25 +55,90 @@ function parseConfig(content: string): Config {
   const strictInput = isRec(parsed) ? parsed.strictInput : undefined;
   const boundaryDedupMode = isRec(parsed) ? parsed.boundaryDedupMode : undefined;
   const legacyBoundaryDedup = isRec(parsed) ? parsed.boundaryDedupEnabled : undefined;
+  const diffContextLines = isRec(parsed) ? parsed.diffContextLines : undefined;
   return {
     autoRead,
     anchorGrepEnabled: typeof anchorGrepEnabled === "boolean" ? anchorGrepEnabled : DEFAULT_CONFIG.anchorGrepEnabled,
     requirePath: typeof requirePath === "boolean" ? requirePath : DEFAULT_CONFIG.requirePath,
     strictInput: typeof strictInput === "boolean" ? strictInput : DEFAULT_CONFIG.strictInput,
     boundaryDedupMode: parseBoundaryDedupMode(boundaryDedupMode, legacyBoundaryDedup),
+    diffContextLines: normalizeDiffContextLines(diffContextLines),
   };
 }
 
-
-export async function readConfig(): Promise<Config> {
+async function loadConfigFile(): Promise<{ config: Config; corrupted: boolean }> {
+  let content: string;
+  try {
+    content = await readFile(configPath(), "utf-8");
+  } catch (error: unknown) {
+    if (errCode(error) === "ENOENT") return { config: { ...DEFAULT_CONFIG }, corrupted: false };
+    console.error("Config file unreadable, using defaults:", error);
+    return { config: { ...DEFAULT_CONFIG }, corrupted: false };
+  }
   try {
-    const content = await readFile(configPath(), "utf-8");
-    return parseConfig(content);
+    return { config: parseConfig(content), corrupted: false };
   } catch (error: unknown) {
-    if (errCode(error) !== "ENOENT") {
-      console.error("Config file corrupted, using defaults:", error);
+    try {
+      const badPath = configPath();
+      await rename(badPath, `${badPath}.corrupt-${Date.now()}-${process.pid}-${Math.random().toString(36).slice(2)}`);
+    } catch { }
+    console.error("Config file corrupted, quarantined, using defaults:", error);
+    return { config: { ...DEFAULT_CONFIG }, corrupted: true };
+  }
+}
+export async function readConfig(): Promise<Config> {
+  return (await loadConfigFile()).config;
+}
+export async function readConfigWithStatus(): Promise<{ config: Config; corrupted: boolean }> {
+  return loadConfigFile();
+}
+const CONFIG_LOCK_RETRIES = 80;
+const CONFIG_LOCK_DELAY_MS = 25;
+const CONFIG_LOCK_STALE_MS = 5000;
+async function acquireConfigLock(lockPath: string): Promise<void> {
+  try {
+    await mkdir(dirname(lockPath), { recursive: true, mode: 0o700 });
+  } catch { }
+  for (let attempt = 0; attempt < CONFIG_LOCK_RETRIES; attempt++) {
+    try {
+      await mkdir(lockPath, { mode: 0o700 });
+      return;
+    } catch (error) {
+      if (errCode(error) === "ENOENT") {
+        try {
+          await mkdir(dirname(lockPath), { recursive: true, mode: 0o700 });
+        } catch { }
+        continue;
+      }
+      if (errCode(error) !== "EEXIST") throw error;
+      try {
+        const st = await stat(lockPath);
+        if (Date.now() - st.mtimeMs > CONFIG_LOCK_STALE_MS) {
+          await rm(lockPath, { recursive: true, force: true });
+          continue;
+        }
+      } catch { }
+      await new Promise<void>((r) => setTimeout(r, CONFIG_LOCK_DELAY_MS));
     }
-    return { ...DEFAULT_CONFIG };
+  }
+  throw new Error(`[E_ACCESS] Could not acquire config lock: ${lockPath}`);
+}
+async function releaseConfigLock(lockPath: string): Promise<void> {
+  try {
+    await rm(lockPath, { recursive: true, force: true });
+  } catch { }
+}
+export async function updateConfig(mut: (config: Config) => void): Promise<Config> {
+  const cfgPath = configPath();
+  const lockPath = `${cfgPath}.lock`;
+  await acquireConfigLock(lockPath);
+  try {
+    const config = await readConfig();
+    mut(config);
+    await writeConfig(config);
+    return config;
+  } finally {
+    await releaseConfigLock(lockPath);
   }
 }
 export async function writeConfig(config: Config): Promise<void> {
@@ -68,38 +147,38 @@ export async function writeConfig(config: Config): Promise<void> {
 
 
 export async function toggleAutoRead(): Promise<boolean> {
-  const config = await readConfig();
-  config.autoRead = !config.autoRead;
-  await writeConfig(config);
+  const config = await updateConfig((c) => { c.autoRead = !c.autoRead; });
   return config.autoRead;
 }
-
 export async function toggleAnchorGrep(): Promise<boolean> {
-  const config = await readConfig();
-  config.anchorGrepEnabled = !config.anchorGrepEnabled;
-  await writeConfig(config);
+  const config = await updateConfig((c) => { c.anchorGrepEnabled = !c.anchorGrepEnabled; });
   return config.anchorGrepEnabled;
 }
-
 export async function toggleRequirePath(): Promise<boolean> {
-  const config = await readConfig();
-  config.requirePath = !config.requirePath;
-  await writeConfig(config);
-  return config.requirePath;
+  const config = await updateConfig((c) => { c.requirePath = !c.requirePath; });
+  return config.requirePath === true;
 }
-
 export async function toggleStrictInput(): Promise<boolean> {
-  const config = await readConfig();
-  config.strictInput = !(config.strictInput === true);
-  await writeConfig(config);
+  const config = await updateConfig((c) => { c.strictInput = !(c.strictInput === true); });
   return config.strictInput === true;
 }
-
 export async function cycleBoundaryDedupMode(): Promise<BoundaryDedupMode> {
-  const config = await readConfig();
-  const current = config.boundaryDedupMode ?? "on";
-  const next = BOUNDARY_DEDUP_MODES[(BOUNDARY_DEDUP_MODES.indexOf(current) + 1) % BOUNDARY_DEDUP_MODES.length] ?? "on";
-  config.boundaryDedupMode = next;
-  await writeConfig(config);
+  let next: BoundaryDedupMode = "on";
+  await updateConfig((c) => {
+    const current = c.boundaryDedupMode ?? "on";
+    next = BOUNDARY_DEDUP_MODES[(BOUNDARY_DEDUP_MODES.indexOf(current) + 1) % BOUNDARY_DEDUP_MODES.length] ?? "on";
+    c.boundaryDedupMode = next;
+  });
+  return next;
+}
+export async function getDiffContextLines(): Promise<number> {
+  return normalizeDiffContextLines((await readConfig()).diffContextLines);
+}
+export async function adjustDiffContextLines(delta: number): Promise<number> {
+  let next = DEFAULT_DIFF_CONTEXT_LINES;
+  await updateConfig((c) => {
+    next = normalizeDiffContextLines(normalizeDiffContextLines(c.diffContextLines) + delta);
+    c.diffContextLines = next;
+  });
   return next;
 }

package/src/grep.ts

@@ -326,6 +326,12 @@ async function collectRgMatches(
   signal?: AbortSignal,
 ): Promise<Map<string, number[]>> {
   const args = ["--json", "--line-number", "--color=never", "--hidden", "--glob", "!.git"];
+  const wanted = req.limit ?? 100;
+  args.push("--max-count", String(wanted + 1));
+  if (typeof req.glob === "string" && req.glob.length > 0) {
+    const stripped = req.glob.startsWith("/") ? req.glob.slice(1) : req.glob;
+    if (!stripped.includes("/")) args.push("--glob", stripped);
+  }
   if (req.ignoreCase) args.push("--ignore-case");
   if (req.literal) args.push("--fixed-strings");
   args.push("--", pattern, searchPath);
@@ -451,7 +457,7 @@ const grepToolSchema = Type.Object(
       }),
     ),
   },
-  { additionalProperties: false },
+  { additionalProperties: true },
 );
 
 
@@ -579,15 +585,17 @@ export function regGrep(pi: ExtensionAPI): void {
       let linesReplaced = 0;
       let countOnly = false;
       let poolSkipped = 0;
-      const readGrepFile = async (absPath: string) => {
+      const makeGrepReader = (allocation: "real" | "shadow") => async (absPath: string) => {
         try {
-          return await tryReadNormFile(absPath, ctx.cwd, { maxLines: MAX_HASH_LINES, noPersist: true, allocation: "real", signal });
+          return await tryReadNormFile(absPath, ctx.cwd, { maxLines: MAX_HASH_LINES, noPersist: true, allocation, signal });
         } catch (error) {
           if (!isPoolExhaustedError(error)) throw error;
           poolSkipped += 1;
           return undefined;
         }
       };
+      const readGrepFile = makeGrepReader("real");
+      const readGrepFileShadow = makeGrepReader("shadow");
       const rgMatches = await collectRgMatches(rgPath, req.pattern, base, req, signal);
       const sortedFiles = [...rgMatches.keys()].sort(cmp);
       for (let f = 0; f < sortedFiles.length; f++) {
@@ -603,7 +611,7 @@ export function regGrep(pi: ExtensionAPI): void {
             const globPath = relative(globRoot, absPath).replace(/\\/g, "/");
             if (!globRegex.test(globPath) && !globRegex.test(displayPath)) continue;
           }
-          const norm = await readGrepFile(absPath);
+          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 display = displayRowsForHit(hit);

package/src/hashline/alphabet.ts

@@ -1,11 +1,11 @@
 import anchorData from "./anchor-table.json";
-
-const TABLE: string = anchorData.anchors;
-
+const rawAnchors: unknown = (anchorData as { anchors?: unknown }).anchors;
+if (typeof rawAnchors !== "string" || rawAnchors.length === 0 || rawAnchors.length % 4 !== 0) {
+  throw new Error("[E_REGISTRY] Anchor table is missing or corrupt; reinstall pi-hashline-edit-pro.");
+}
+const TABLE: string = rawAnchors;
 export const HASH_LEN = 4;
-
 export const ANCHOR_COUNT = TABLE.length / HASH_LEN;
-
 const ALNUM = "A-Za-z0-9";
 
 export const ALPH_RE = new RegExp(`^[${ALNUM}]+$`);