@d3ara1n/pi-hashline-edit 0.5.3 → 0.5.5

package/README.md

@@ -24,7 +24,7 @@ Routine local code editing in pi — the common case. If you spend turns fightin
 
 ## When to turn it off
 
-Set `hashlineEdit.enabled = false` (or uninstall) to fall back to the built-in `read`/`edit`/`grep` when you need **remote or custom-storage files** — the overrides read/write/search the local filesystem directly, so pi's custom `ReadOperations`/`GrepOperations` (SSH, etc.) aren't supported. The same switch lets you opt out per-project. All four tools — `read`, `grep`, `edit`, `replace` — are one set governed by this switch: when disabled, `read`/`edit` and plain `grep` calls delegate to the built-ins (`grep` calls using the extended params below still run locally, formatted without anchors) and `replace` refuses (it has no built-in counterpart).
+Set `hashlineEdit.enabled = false` (or uninstall) to fall back to the built-in `read`/`edit`/`grep` when you need **remote or custom-storage files** — the overrides read/write/search the local filesystem directly, so pi's custom `ReadOperations`/`GrepOperations` (SSH, etc.) aren't supported. The same switch lets you opt out per-project. All four tools — `read`, `grep`, `edit`, `replace` — are one set governed by this switch: when disabled the extension registers none of them and pi behaves as if it were not installed (reload pi after changing the setting).
 
 ## Model Compatibility
 
@@ -212,7 +212,7 @@ Add a `hashlineEdit` field to `~/.pi/agent/settings.json` (global) or `.pi/setti
 ```jsonc
 {
   "hashlineEdit": {
-    "enabled": true,     // set false to fall back to the built-in read/edit
+    "enabled": true,     // set false to disable the extension entirely (built-ins remain; reload pi)
     "hashLen": 4,        // hash length, 2–8 (default 4)
     "shiftRadius": 15    // ±lines scanned to rescue a stale anchor (default 15; 0 disables)
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@d3ara1n/pi-hashline-edit",
-  "version": "0.5.3",
+  "version": "0.5.5",
   "type": "module",
   "description": "Hashline-style file editing for pi — line-anchored edits verified by content hash, replacing oldText/newText matching",
   "homepage": "https://github.com/d3ara1n/pi-extensions/tree/main/packages/pi-hashline-edit#readme",

package/src/core/apply.test.ts

@@ -171,6 +171,32 @@ test("CRLF line endings preserved", () => {
 	if (r.ok) assert.equal(r.text, "A\r\nb\r\n");
 });
 
+test("editing a mixed-ending file preserves untouched separators", () => {
+	const before = "first\r\nsecond\nthird\r\n";
+	const result = applyEdits(before, [{ op: "replace", start: at(before, 2), body: ["SECOND"] }]);
+	assert.equal(result.ok, true);
+	if (result.ok) assert.equal(result.text, "first\r\nSECOND\nthird\r\n");
+});
+
+test("inserting and deleting in mixed-ending files preserves surviving separators", () => {
+	const before = "a\r\nb\nc\r\nlast";
+	const inserted = applyEdits(before, [{ op: "insert_after", anchor: at(before, 2), body: ["x"] }]);
+	assert.equal(inserted.ok, true);
+	if (inserted.ok) assert.equal(inserted.text, "a\r\nb\nx\r\nc\r\nlast");
+	const deleted = applyEdits(before, [{ op: "delete", start: at(before, 2) }]);
+	assert.equal(deleted.ok, true);
+	if (deleted.ok) assert.equal(deleted.text, "a\r\nc\r\nlast");
+});
+
+test("replacing one line with several keeps the block's trailing gap", () => {
+	const before = "a\r\nb\nc\r\nd";
+	const result = applyEdits(before, [{ op: "replace", start: at(before, 2), body: ["X", "Y", "Z"] }]);
+	assert.equal(result.ok, true);
+	// b's gap (\n) moves to the last new line, so the boundary to c is unchanged;
+	// the two new interior gaps borrow positionally, then fall back to crlf.
+	if (result.ok) assert.equal(result.text, "a\r\nX\nY\r\nZ\nc\r\nd");
+});
+
 test("a file without a final newline keeps not having one", () => {
 	const text = "a\nb";
 	const r = applyEdits(text, [{ op: "replace", start: at(text, 2), body: ["B"] }]);
@@ -193,9 +219,6 @@ test("appending to a file without a final newline keeps it absent", () => {
 });
 
 test("noop is still detected when the file lacks a final newline", () => {
-	// Before the final-newline fix, joinLines appended a terminator, so a
-	// byte-identical body looked like a change and the edit silently rewrote the
-	// file — the noop guard never fired.
 	const text = "a\nb";
 	const r = applyEdits(text, [{ op: "replace", start: at(text, 1), body: ["a"] }]);
 	assert.equal(r.ok, false);

package/src/core/apply.ts

@@ -30,7 +30,7 @@
  */
 
 import { computeLineHash } from "./hash.ts";
-import { detectLineEnding, hasFinalNewline, joinLines, splitLines } from "./lines.ts";
+import { detectLineEnding, hasFinalNewline, splitLines } from "./lines.ts";
 import type { Anchor, AnchorFailure, AnchorRecovery, ApplyResult, Edit } from "./types.ts";
 
 /** Line-level operation: replace the raw lines in the `[lo, hi)` range (0-based, hi exclusive) with newLines. */
@@ -212,13 +212,29 @@ export function applyEdits(text: string, edits: Edit[], hashLen = 4, shiftRadius
 		}
 	}
 
-	// Apply back-to-front (lo descending) so original lo/hi stay valid
-	let result = [...lines];
+	// Mixed line endings: each line carries the separator that FOLLOWED it in
+	// the original (its gap), so surviving lines keep theirs byte for byte. New
+	// gaps borrow the removed block's separators positionally — the last new
+	// line inherits the block's trailing gap, leaving the boundary to the next
+	// surviving line unchanged; gaps past the removed block's length (or in a
+	// pure insertion) fall back to the file's customary ending.
+	const separators = text.match(/\r?\n/g) ?? [];
+	const separator = ending === "crlf" ? "\r\n" : "\n";
+	let result = lines.map((content, i) => ({ content, separator: separators[i] ?? "" }));
 	for (const op of [...sorted].sort((a, b) => b.lo - a.lo)) {
-		result = [...result.slice(0, op.lo), ...op.newLines, ...result.slice(op.hi)];
+		const removed = result.slice(op.lo, op.hi);
+		const inserted = op.newLines.map((content, i) => ({
+			content,
+			separator: i === op.newLines.length - 1 && removed.length > 0
+				? removed[removed.length - 1].separator
+				: removed[i]?.separator || separator,
+		}));
+		result.splice(op.lo, op.hi - op.lo, ...inserted);
 	}
-
-	const newText = joinLines(result, ending, hasFinalNewline(text));
+	const finalNewline = hasFinalNewline(text);
+	const newText = result.map(({ content, separator: current }, i) =>
+		content + (i < result.length - 1 || finalNewline ? current || separator : ""),
+	).join("");
 	if (newText === text) {
 		return {
 			ok: false,

package/src/core/index.ts

@@ -9,5 +9,5 @@
 
 export * from "./types.ts";
 export { computeLineHash, hashFileLines } from "./hash.ts";
-export { splitLines, joinLines, detectLineEnding, hasFinalNewline } from "./lines.ts";
+export { splitLines, detectLineEnding, hasFinalNewline } from "./lines.ts";
 export { applyEdits } from "./apply.ts";

package/src/core/lines.test.ts

@@ -1,6 +1,6 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
-import { splitLines, joinLines, detectLineEnding, hasFinalNewline } from "./lines.ts";
+import { splitLines, detectLineEnding, hasFinalNewline } from "./lines.ts";
 
 test("splitLines edge cases", () => {
 	assert.deepEqual(splitLines(""), []);
@@ -16,20 +16,6 @@ test("splitLines strips CRLF \\r", () => {
 	assert.deepEqual(splitLines("a\r\nb"), ["a", "b"]);
 });
 
-test("joinLines restores line endings", () => {
-	assert.equal(joinLines(["a", "b"]), "a\nb\n");
-	assert.equal(joinLines([]), "");
-	assert.equal(joinLines(["a", "b"], "crlf"), "a\r\nb\r\n");
-	assert.equal(joinLines(["a", "b"], "lf"), "a\nb\n");
-});
-
-test("joinLines preserves the final-newline state when told to", () => {
-	assert.equal(joinLines(["a", "b"], "lf", false), "a\nb");
-	assert.equal(joinLines(["a", "b"], "crlf", false), "a\r\nb");
-	assert.equal(joinLines(["a"], "lf", false), "a");
-	assert.equal(joinLines([], "lf", false), "");
-});
-
 test("hasFinalNewline", () => {
 	assert.equal(hasFinalNewline("a\nb"), false);
 	assert.equal(hasFinalNewline("a\nb\n"), true);
@@ -40,12 +26,6 @@ test("hasFinalNewline", () => {
 	assert.equal(hasFinalNewline(""), true);
 });
 
-test("split/join round-trips a document byte for byte", () => {
-	for (const text of ["a", "a\n", "a\nb", "a\nb\n", "a\n\n", "\n", "a\r\nb", "a\r\nb\r\n", ""]) {
-		assert.equal(joinLines(splitLines(text), detectLineEnding(text), hasFinalNewline(text)), text);
-	}
-});
-
 test("detectLineEnding", () => {
 	assert.equal(detectLineEnding("a\nb\n"), "lf");
 	assert.equal(detectLineEnding("a\r\nb\r\n"), "crlf");

package/src/core/lines.ts

@@ -4,13 +4,15 @@
  *
  * CRLF: splitLines strips the trailing `\r` from each line (hashes are based on
  * clean lines, matching the `\r`-free content the model copies from the
- * display); detectLineEnding records the original ending so joinLines can
- * restore it — guaranteeing a CRLF file keeps its endings after edit.
+ * display); detectLineEnding records whether the file uses CRLF at all (any
+ * `\r\n` counts) so new boundaries added by an edit can use the file's
+ * customary ending.
  *
  * Final newline: splitLines discards whether the input ended with a terminator
  * (a trailing newline terminates the last line, it does not create one).
- * joinLines therefore takes that state as an argument rather than assuming it —
- * a file that lacked a final newline must not silently gain one.
+ * hasFinalNewline recovers that state so a file that lacked a final newline
+ * does not silently gain one — editing reassembles per-line separators and
+ * must suppress the last line's terminator accordingly.
  *
  * @module pi-hashline-edit/core
  */
@@ -34,14 +36,14 @@ export function splitLines(text: string): string[] {
 	return normalized.split("\n").map((l) => (l.endsWith("\r") ? l.slice(0, -1) : l));
 }
 
-/** Detect the dominant line ending of the text (any `\r\n` counts as CRLF). */
+/** Whether the text uses CRLF at all (any `\r\n` counts; mixed files report "crlf"). */
 export function detectLineEnding(text: string): LineEnding {
 	return text.includes("\r\n") ? "crlf" : "lf";
 }
 
 /**
  * Whether the text ends with a line terminator — the state splitLines discards
- * and joinLines needs in order to reproduce a document byte for byte.
+ * and edit application needs in order to reproduce a document byte for byte.
  *
  * The empty string has no lines and no terminator; it reports `true` so that
  * rejoining its (also empty) line array — which yields `""` either way —
@@ -50,18 +52,3 @@ export function detectLineEnding(text: string): LineEnding {
 export function hasFinalNewline(text: string): boolean {
 	return text === "" || text.endsWith("\n");
 }
-
-/**
- * Join a line array back into text, restoring the given line ending (default LF)
- * and final-newline state (default: terminates with a newline, the convention
- * for freshly created content).
- *
- * Reconstructing an *existing* file must pass `hasFinalNewline(originalText)` so
- * a missing terminator stays missing.
- */
-export function joinLines(lines: readonly string[], ending: LineEnding = "lf", finalNewline = true): string {
-	if (lines.length === 0) return "";
-	const sep = ending === "crlf" ? "\r\n" : "\n";
-	const body = lines.join(sep);
-	return finalNewline ? body + sep : body;
-}

package/src/index.ts

@@ -23,14 +23,15 @@ import { makeReplaceTool } from "./pi/replace-tool.ts";
 export default function (pi: ExtensionAPI) {
 	const cwd = process.cwd();
 
-	// refresh config on session start / reload
-	pi.on("session_start", async () => {
-		const state = getState();
-		state.config = loadConfig(cwd);
-	});
+	const state = getState();
+	state.config = loadConfig(cwd);
 
-	pi.registerTool(makeReadOverride(cwd));
-	pi.registerTool(makeEditOverride(cwd));
-	pi.registerTool(makeGrepOverride(cwd));
-	pi.registerTool(makeReplaceTool(cwd));
+	// `enabled: false` leaves the extension fully inert — pi's built-in
+	// read/edit/grep stay in place, as if this package were not installed.
+	if (state.config.enabled) {
+		pi.registerTool(makeReadOverride(cwd));
+		pi.registerTool(makeEditOverride(cwd));
+		pi.registerTool(makeGrepOverride(cwd));
+		pi.registerTool(makeReplaceTool(cwd));
+	}
 }

package/src/integration/grep-rg.test.ts

@@ -45,3 +45,108 @@ test("real rg emits anchored matches from a temporary directory", {
     await rm(directory, { recursive: true, force: true });
   }
 });
+
+test("real rg and line filters honor explicit case settings and Unicode folding", {
+  skip: rgPath === null,
+}, async () => {
+  const directory = await mkdtemp(join(tmpdir(), "hl-grep-case-"));
+  try {
+    await writeFile(join(directory, "fixture.ts"), "FOO abc\nfoo BAR\nfoo bar\nK zip\nk zip\n");
+    const tool = makeGrepOverrideWithBackend(directory, {
+      findRg: async () => rgPath,
+      delegate: async () => {
+        throw new Error("integration test must not invoke the built-in grep delegate");
+      },
+    });
+    for (const ignoreCase of [undefined, false, true]) {
+      const expectedCount = ignoreCase === true ? 3 : 2;
+      for (const query of [
+        { pattern: "foo\\S*" },
+        { pattern: ["foo\\S*", "\\S+"], matchMode: "all" },
+      ]) {
+        const result: any = await tool.execute("0", { ...query, ignoreCase }, undefined, undefined);
+        assert.match(result.content[0].text, new RegExp(`fixture\\.ts · ${expectedCount} matches`));
+        assert.equal(result.content[0].text.includes("FOO abc"), ignoreCase === true);
+      }
+      const excluded: any = await tool.execute("0", {
+        pattern: "foo\\S*", excludePattern: "bar", ignoreCase,
+      }, undefined, undefined);
+      assert.match(excluded.content[0].text, /fixture\.ts · 1 match/);
+      assert.ok(excluded.content[0].text.includes(ignoreCase === true ? "FOO abc" : "foo BAR"));
+    }
+    const unicodeAll: any = await tool.execute("0", {
+      pattern: ["k", "zip"], matchMode: "all", ignoreCase: true,
+    }, undefined, undefined);
+    assert.match(unicodeAll.content[0].text, /fixture\.ts · 2 matches/);
+    assert.ok(unicodeAll.content[0].text.includes("K zip"));
+
+    const unicodeExcluded: any = await tool.execute("0", {
+      pattern: "zip", excludePattern: "k", ignoreCase: true,
+    }, undefined, undefined);
+    assert.equal(unicodeExcluded.content[0].text, "No matches found");
+    const caseSensitive: any = await tool.execute("0", {
+      pattern: "zip", excludePattern: "k",
+    }, undefined, undefined);
+    assert.match(caseSensitive.content[0].text, /│K zip/);
+    assert.doesNotMatch(caseSensitive.content[0].text, /│k zip/);
+  } finally {
+    await rm(directory, { recursive: true, force: true });
+  }
+});
+
+test("real rg searches regex by default and rejects invalid patterns", {
+  skip: rgPath === null,
+}, async () => {
+  const directory = await mkdtemp(join(tmpdir(), "hl-grep-regex-"));
+  try {
+    await writeFile(join(directory, "fixture.ts"), "FOO\nfoo\nqueueTool(\nfoo(?=bar)\n");
+    const tool = makeGrepOverrideWithBackend(directory, {
+      findRg: async () => rgPath,
+      delegate: async () => {
+        throw new Error("integration test must not invoke the built-in grep delegate");
+      },
+    });
+    for (const pattern of ["(?i)^foo$", "(?P<name>foo)$"]) {
+      const result: any = await tool.execute("0", { pattern }, undefined, undefined);
+      assert.match(result.content[0].text, /│foo/);
+    }
+    for (const pattern of ["queueTool(", "foo(?=bar)"]) {
+      await assert.rejects(
+        tool.execute("0", { pattern }, undefined, undefined),
+        /regex parse error/,
+      );
+    }
+    const explicit: any = await tool.execute("0", { pattern: "queueTool(", literal: true }, undefined, undefined);
+    assert.match(explicit.content[0].text, /│queueTool\(/);
+  } finally {
+    await rm(directory, { recursive: true, force: true });
+  }
+});
+
+test("fallback forwards search settings unchanged to an rg-backed delegate", {
+  skip: rgPath === null,
+}, async () => {
+  const directory = await mkdtemp(join(tmpdir(), "hl-grep-fallback-"));
+  try {
+    await writeFile(join(directory, "fixture.ts"), "FOO\nfoo\nqueueTool(\n");
+    const delegate = makeGrepOverrideWithBackend(directory, {
+      findRg: async () => rgPath,
+      delegate: async () => { throw new Error("must not invoke the built-in download path"); },
+    });
+    const fallback = makeGrepOverrideWithBackend(directory, {
+      findRg: async () => null,
+      delegate: (...args) => delegate.execute(...args),
+    });
+    for (const pattern of ["foo", "(?i)^foo$", "(?P<name>foo)$"]) {
+      const result: any = await fallback.execute("0", { pattern }, undefined, undefined);
+      const output = result.content[0].text;
+      assert.match(output, /│foo/);
+      assert.equal(output.includes("│FOO"), pattern.includes("?i"));
+    }
+    await assert.rejects(fallback.execute("0", { pattern: "queueTool(" }, undefined, undefined), /regex parse error/);
+    const literal: any = await fallback.execute("0", { pattern: "queueTool(", literal: true }, undefined, undefined);
+    assert.match(literal.content[0].text, /│queueTool\(/);
+  } finally {
+    await rm(directory, { recursive: true, force: true });
+  }
+});

package/src/pi/config.ts

@@ -11,7 +11,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 
 export interface HashlineEditConfig {
-	/** Whether hashline is enabled (when false, delegate to the built-in read/edit). */
+	/** Master switch: when false the extension registers no tools — pi's built-ins remain. */
 	enabled: boolean;
 	/** Line hash length (default 4). */
 	hashLen: number;

package/src/pi/edit-tool.ts

@@ -19,7 +19,7 @@
  * @module pi-hashline-edit/pi
  */
 
-import { createEditTool, generateDiffString, generateUnifiedPatch, withFileMutationQueue, type EditToolDetails } from "@earendil-works/pi-coding-agent";
+import { generateDiffString, generateUnifiedPatch, withFileMutationQueue, type EditToolDetails } from "@earendil-works/pi-coding-agent";
 import { Type, type Static } from "typebox";
 import { Text } from "@earendil-works/pi-tui";
 import { readFile, writeFile } from "node:fs/promises";
@@ -201,7 +201,6 @@ function editHeader(args: Static<typeof editSchema>, theme: any, counts?: DiffCo
 }
 
 export function makeEditOverride(cwd: string) {
-	const builtin = createEditTool(cwd);
 
 	return {
 		name: "edit" as const,
@@ -255,10 +254,6 @@ export function makeEditOverride(cwd: string) {
 		},
 
 		async execute(toolCallId: string, params: Static<typeof editSchema>, signal: AbortSignal | undefined, onUpdate: any) {
-			const state = getState();
-			// hashline disabled by the user (config.enabled=false) → delegate to the built-in
-			if (!state.config.enabled) return builtin.execute(toolCallId, params as any, signal, onUpdate);
-
 			const path = params.path;
 			const absPath = canonicalPath(cwd, path);
 

package/src/pi/execute.test.ts

@@ -5,12 +5,15 @@
  */
 import { test } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtemp, rm, readFile, writeFile } from "node:fs/promises";
+import { mkdir, mkdtemp, rm, readFile, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { initTheme } from "@earendil-works/pi-coding-agent";
+import { createEditTool, initTheme } from "@earendil-works/pi-coding-agent";
+import { validateToolArguments } from "@earendil-works/pi-ai";
+import registerHashline from "../index.ts";
 import { makeEditOverride } from "./edit-tool.ts";
 import { makeReadOverride } from "./read-tool.ts";
+import { getState } from "./state.ts";
 import { computeLineHash } from "../core/hash.ts";
 import { splitLines } from "../core/lines.ts";
 
@@ -242,6 +245,32 @@ test("edit execute: delete op", async () => {
 	});
 });
 
+test("disabled config registers no tools — built-ins remain", async () => {
+	await withDir(async (dir) => {
+		const oldCwd = process.cwd();
+		const state = getState();
+		const previous = state.config;
+		try {
+			await mkdir(join(dir, ".pi"));
+			await writeFile(join(dir, ".pi", "settings.json"), JSON.stringify({ hashlineEdit: { enabled: false } }));
+			await writeFile(join(dir, "f.txt"), "old value\n");
+			process.chdir(dir);
+			const registered: string[] = [];
+			registerHashline({ on() {}, registerTool(tool: { name: string }) { registered.push(tool.name); } } as any);
+			assert.deepEqual(registered, []);
+			const builtin = createEditTool(dir);
+			const params = validateToolArguments(builtin, {
+				name: "edit", arguments: { path: "f.txt", edits: [{ oldText: "old value", newText: "new value" }] },
+			} as any);
+			await call(builtin, params);
+			assert.equal(await readFile(join(dir, "f.txt"), "utf-8"), "new value\n");
+		} finally {
+			process.chdir(oldCwd);
+			state.config = previous;
+		}
+	});
+});
+
 // --- renderer regression guards (details.diff must be a string, renderResult must not throw) ---
 
 const stubTheme = { fg: (_k: string, s: string) => s, bold: (s: string) => s };

package/src/pi/grep-tool.ts

@@ -22,9 +22,9 @@
  * pre-filter candidates. Context windows are likewise rebuilt client-side from
  * the surviving matches — context lines of a filtered-out match never leak.
  *
- * Falls back to the built-in grep when: hashline disabled with plain params,
- * aborted, or ripgrep cannot be located (the built-in can auto-download rg).
- * Extended params never delegate — the built-in would misread them.
+ * Falls back to the built-in grep when aborted or when ripgrep cannot be
+ * located (the built-in can auto-download rg). Extended params never
+ * delegate — the built-in would misread them.
  *
  * @module pi-hashline-edit/pi
  */
@@ -91,7 +91,7 @@ function compileLineMatcher(
 ): RegExp {
   let source = opts.literal ? escapeRegex(pattern) : pattern;
   if (opts.word) source = `\\b(?:${source})\\b`;
-  const flags = opts.ignoreCase ? "i" : "";
+  const flags = opts.ignoreCase ? "iu" : "u";
   try {
     return new RegExp(source, flags);
   } catch (err) {
@@ -110,24 +110,22 @@ function toArray(v: string | string[] | undefined): string[] {
 const grepOverrideSchema = Type.Object({
   pattern: Type.Union([Type.String(), Type.Array(Type.String())], {
     description:
-      "Search pattern (regex, or literal with literal:true). String or array; an array combines patterns per matchMode (any = OR, all = AND on the same line)",
+      "Regex pattern, or literal text with literal:true. String or array; arrays combine per matchMode.",
   }),
   matchMode: Type.Optional(
     Type.Union([Type.Literal("any"), Type.Literal("all")], {
       description:
-        'How multiple patterns combine (default "any"). "any": line matches at least one pattern. "all": line must match every pattern — equivalent to `grep A | grep B`',
+        '"any" (default): OR. "all": AND on the same line.',
     }),
   ),
   excludePattern: Type.Optional(
     Type.Union([Type.String(), Type.Array(Type.String())], {
-      description:
-        "Drop lines matching this pattern, like grep -v (string or array; same regex/literal/ignoreCase settings as pattern). Applied after pattern matching",
+      description: "Drop lines matching any exclusion after pattern matching; uses the same literal and ignoreCase settings.",
     }),
   ),
   outputMode: Type.Optional(
     Type.Union([Type.Literal("content"), Type.Literal("files"), Type.Literal("count")], {
-      description:
-        'Output shape (default "content"). "content": anchored matching lines. "files": only file paths with matches (rg -l). "count": per-file match counts + total (grep -c)',
+      description: '"content" (default): anchored lines. "files": paths. "count": matching lines per file and total.',
     }),
   ),
   wordMatch: Type.Optional(Type.Boolean({ description: "Match whole words only (rg -w)" })),
@@ -139,11 +137,11 @@ const grepOverrideSchema = Type.Object({
     Type.String({ description: "Filter files by glob pattern, e.g. '*.ts' or '**/*.spec.ts'" }),
   ),
   ignoreCase: Type.Optional(
-    Type.Boolean({ description: "Case-insensitive search (default: false)" }),
+    Type.Boolean({ description: "Case-insensitive search (default: false); applies to pattern and excludePattern." }),
   ),
   literal: Type.Optional(
     Type.Boolean({
-      description: "Treat pattern as literal string instead of regex (default: false)",
+      description: "Treat pattern and excludePattern as literal text (default: false; regex). Invalid regexes return an error.",
     }),
   ),
   context: Type.Optional(
@@ -305,14 +303,12 @@ export function makeGrepOverrideWithBackend(cwd: string, overrides: Partial<Grep
     name: "grep" as const,
     label: "grep",
     description:
-      "Search file contents for a pattern. Results are grouped by file with LINE#HASH anchors usable directly in edit. Supports multi-pattern AND (matchMode:all), line exclusion (excludePattern, grep -v), whole-word matching (wordMatch), multiple search paths, and files-only / count output modes — the common `grep A | grep -v B` / `rg -l` / `grep -c` pipelines without bash. Respects .gitignore.",
-    promptSnippet:
-      "Search file contents; results show LINE#HASH anchors usable directly in edit; multi-pattern AND, exclude, files-only and count modes replace bash grep pipelines",
+      "Search file contents, respecting .gitignore. Content results are grouped by file and include LINE#HASH anchors usable in edit; built-in grep fallback results have no anchors.",
+    promptSnippet: "Search file contents with edit-ready line anchors",
     promptGuidelines: [
-      "Results are grouped by file under a `path · N matches` header; each line shows `LINE#HASH│content` (same format as read).",
-      "Copy `LINE#HASH` straight into an edit `anchor`/`end` — no re-read needed. Context lines (from `context`) are anchored and editable too.",
-      'Prefer this over bash pipes: `matchMode:"all"` + `excludePattern` express `grep A | grep -v B`; `outputMode:"files"`/`"count"` replace `rg -l`/`grep -c` when you only need locations or counts. `files` output pastes back as a `path` array.',
-      "Pass `pattern` (string or array); optionally `path` (string or array), `glob`, `ignoreCase`, `literal`, `wordMatch`, `context` (lines before+after each match), `limit` (max matches, default 100).",
+      "Prefer the grep tool for file-content searches.",
+      "Use returned LINE#HASH anchors directly in edit when present; no re-read is needed.",
+      'Use outputMode:"files"/"count" when only paths or counts are needed; use matchMode:"all" and excludePattern for line-level filters instead of shell pipelines.',
     ],
     parameters: grepOverrideSchema,
 
@@ -372,6 +368,9 @@ export function makeGrepOverrideWithBackend(cwd: string, overrides: Partial<Grep
       // aborted → built-in grep (it handles abort itself)
       if (signal?.aborted) return backend.delegate(toolCallId, params, signal, onUpdate);
 
+      const patterns = toArray(params.pattern);
+      if (patterns.length === 0) throw new Error("pattern is required (got an empty array)");
+
       // Plain built-in-shaped params (single string pattern/path, no new fields)
       // can delegate safely; anything else must run the local pipeline below.
       const legacyShaped =
@@ -382,10 +381,6 @@ export function makeGrepOverrideWithBackend(cwd: string, overrides: Partial<Grep
         params.wordMatch === undefined &&
         !Array.isArray(params.path);
 
-      // disabled + plain params → built-in grep, exactly as before
-      if (!state.config.enabled && legacyShaped)
-        return backend.delegate(toolCallId, params, signal, onUpdate);
-
       const rgPath = await backend.findRg();
       // ripgrep unavailable → built-in (it can auto-download rg), but only for plain params
       if (!rgPath) {
@@ -395,12 +390,7 @@ export function makeGrepOverrideWithBackend(cwd: string, overrides: Partial<Grep
         );
       }
 
-      // disabled + extended params still run locally, formatted without anchors
-      const anchored = state.config.enabled;
-
-      const patterns = toArray(params.pattern);
       const excludes = toArray(params.excludePattern);
-      if (patterns.length === 0) throw new Error("pattern is required (got an empty array)");
       const matchMode: "any" | "all" = params.matchMode ?? "any";
       const outputMode: "content" | "files" | "count" = params.outputMode ?? "content";
       const { glob, ignoreCase, literal, wordMatch, context, limit } = params;
@@ -411,6 +401,8 @@ export function makeGrepOverrideWithBackend(cwd: string, overrides: Partial<Grep
       })();
       const hashLen = state.config.hashLen;
 
+      // Verify search paths upfront so a typo fails fast with a clear error
+      // (rg's own diagnostics are less actionable).
       for (const sp of searchPaths) {
         try {
           await stat(sp);
@@ -537,7 +529,6 @@ export function makeGrepOverrideWithBackend(cwd: string, overrides: Partial<Grep
             if (outputMode === "content") {
               for (const [fp, matchLines] of byFile) {
                 const { lines, hashes } = await getFile(fp);
-                const matchSet = new Set(matchLines);
                 // Context windows are rebuilt from surviving matches so context
                 // lines of a filtered-out match never leak.
                 const windowSet = new Set<number>();
@@ -545,18 +536,14 @@ export function makeGrepOverrideWithBackend(cwd: string, overrides: Partial<Grep
                   for (let n = Math.max(1, ln - ctx); n <= Math.min(lines.length, ln + ctx); n++)
                     windowSet.add(n);
                 }
-                const header = anchored
-                  ? `${formatPath(fp)} · ${matchLines.length} match${matchLines.length !== 1 ? "es" : ""}\n`
-                  : "";
+                const header = `${formatPath(fp)} · ${matchLines.length} match${matchLines.length !== 1 ? "es" : ""}\n`;
                 const rows: string[] = [];
                 for (const n of [...windowSet].sort((a, b) => a - b)) {
                   const content = lines[n - 1] ?? "";
                   const hash = hashes[n - 1] ?? "";
                   const { text: disp, wasTruncated } = truncateLine(content.replace(/\r/g, ""));
                   if (wasTruncated) linesTruncated = true;
-                  if (anchored) rows.push(`${n}#${hash}│${disp}`);
-                  else if (matchSet.has(n)) rows.push(`${formatPath(fp)}:${n}: ${disp}`);
-                  else rows.push(`${formatPath(fp)}-${n}- ${disp}`);
+                  rows.push(`${n}#${hash}│${disp}`);
                 }
                 blocks.push(`${header}${rows.join("\n")}`);
               }

package/src/pi/grep.test.ts

@@ -131,11 +131,13 @@ test("grep in a subdirectory returns a path that edits the matching file", async
       const edit: any = makeEditOverride(dir);
       await call(edit, {
         path: displayPath,
-        edits: [{
-          op: "replace",
-          anchor: { line: 1, hash: computeLineHash(1, original.trimEnd()) },
-          body: ["export const status = 2;"],
-        }],
+        edits: [
+          {
+            op: "replace",
+            anchor: { line: 1, hash: computeLineHash(1, original.trimEnd()) },
+            body: ["export const status = 2;"],
+          },
+        ],
       });
       assert.equal(await readFile(matchedFile, "utf-8"), "export const status = 2;\n");
       assert.equal(await readFile(rootFile, "utf-8"), original);
@@ -293,24 +295,6 @@ test("delegates only safe fallbacks and rejects extended missing-rg requests", a
         /ripgrep \(rg\) not found/,
       );
     });
-
-    const file = join(dir, "a.ts");
-    await writeFile(file, "x y\n");
-    const disabled = fakeBackend({ lines: [rgMatch(file, 1, "x y\n")] });
-    await withEnabled(false, async () => {
-      assert.equal(
-        text(await call(makeGrepOverrideWithBackend(dir, disabled.backend), { pattern: "x" })),
-        "delegated",
-      );
-      assert.equal(disabled.calls.length, 0);
-      const extended = await call(makeGrepOverrideWithBackend(dir, disabled.backend), {
-        pattern: ["x", "y"],
-        matchMode: "all",
-      });
-      assert.match(text(extended), /a\.ts:1: x y/);
-      assert.doesNotMatch(text(extended), /#[0-9A-Z]+│/);
-      assert.equal(disabled.calls.length, 1);
-    });
   });
 });
 
@@ -342,3 +326,60 @@ test("delegates an already-aborted call and rejects an abort during rg execution
     );
   });
 });
+
+test("keeps regex and case-sensitive defaults across rg and line filters", async () => {
+  await withDir(async (dir) => {
+    const target = join(dir, "case.ts");
+    await writeFile(target, "FOO alpha\n");
+    const fake = fakeBackend({ lines: [rgMatch(target, 1, "FOO alpha\n")] });
+    const tool = makeGrepOverrideWithBackend(dir, fake.backend);
+    const query = { pattern: ["foo", "alpha"], matchMode: "all", excludePattern: "BETA" };
+
+    assert.equal(text(await call(tool, query)), "No matches found");
+    assert.match(text(await call(tool, { ...query, ignoreCase: true })), /FOO alpha/);
+    assert.match(text(await call(tool, { pattern: "FOO", literal: true })), /FOO alpha/);
+    assert.deepEqual(fake.calls.map(({ args }) => ({
+      ignoreCase: args.includes("--ignore-case"),
+      literal: args.includes("--fixed-strings"),
+    })), [
+      { ignoreCase: false, literal: false },
+      { ignoreCase: true, literal: false },
+      { ignoreCase: false, literal: true },
+    ]);
+
+    const invalid = fakeBackend({ code: 2, stderr: "regex parse error:\nerror: unclosed group" });
+    await assert.rejects(
+      call(makeGrepOverrideWithBackend(dir, invalid.backend), { pattern: "queueTool(" }),
+      /regex parse error/,
+    );
+    assert.equal(invalid.calls.length, 1);
+    assert.ok(!invalid.calls[0].args.includes("--fixed-strings"));
+  });
+});
+
+test("native fallback forwards parameters unchanged and propagates regex errors", async () => {
+  await withDir(async (dir) => {
+    const fake = fakeBackend();
+    fake.backend.findRg = async () => null;
+    const tool = makeGrepOverrideWithBackend(dir, fake.backend);
+    const cases = [
+      { pattern: "foo" },
+      { pattern: "(?i)foo" },
+      { pattern: "queueTool(", literal: true, ignoreCase: true },
+    ];
+    for (const params of cases) {
+      const input = { ...params, path: "fixture.ts", glob: "*.ts", context: 2, limit: 3 };
+      assert.equal(text(await call(tool, input)), "delegated");
+      assert.deepEqual(fake.delegates.at(-1)![1], input);
+    }
+    assert.equal(fake.delegates.length, cases.length);
+    assert.equal(fake.calls.length, 0);
+    fake.backend.delegate = async (...args) => {
+      fake.delegates.push(args);
+      throw new Error("regex parse error: unclosed group");
+    };
+    const failingTool = makeGrepOverrideWithBackend(dir, fake.backend);
+    await assert.rejects(call(failingTool, { pattern: "queueTool(" }), /regex parse error/);
+    assert.equal(fake.delegates.length, cases.length + 1);
+  });
+});

package/src/pi/read-tool.ts

@@ -144,8 +144,8 @@ export function makeReadOverride(cwd: string) {
 		},
 
 		async execute(toolCallId: string, params: any, signal: AbortSignal | undefined, onUpdate: any) {
-			// Not enabled OR user cancelled → delegate to the built-in (builtin handles abort itself)
-			if (!getState().config.enabled || signal?.aborted) return builtin.execute(toolCallId, params, signal, onUpdate);
+			// User cancelled → delegate to the built-in (builtin handles abort itself)
+			if (signal?.aborted) return builtin.execute(toolCallId, params, signal, onUpdate);
 
 			const absPath = canonicalPath(cwd, params.path as string);
 			let buf: Buffer;

package/src/pi/replace-tool.ts

@@ -210,12 +210,6 @@ export function makeReplaceTool(cwd: string) {
 
 		async execute(toolCallId: string, params: ReplaceParams, signal: AbortSignal | undefined, onUpdate: any) {
 			const state = getState();
-			// Gated by the same `enabled` switch as read/grep/edit — they delegate to the
-			// built-ins when disabled; replace has no built-in counterpart, so it refuses.
-			if (!state.config.enabled)
-				throw new Error(
-					"Replace is unavailable: hashlineEdit is disabled. Set hashlineEdit.enabled = true to use it.",
-				);
 			const path = params.path;
 			const absPath = canonicalPath(cwd, path);
 

package/src/pi/replace.test.ts

@@ -14,7 +14,6 @@ import { join } from "node:path";
 import { initTheme } from "@earendil-works/pi-coding-agent";
 import { makeReplaceTool } from "./replace-tool.ts";
 import { makeEditOverride } from "./edit-tool.ts";
-import { getState } from "./state.ts";
 
 async function withDir<T>(fn: (dir: string) => Promise<T>): Promise<T> {
 	const dir = await mkdtemp(join(tmpdir(), "hl-replace-"));
@@ -286,22 +285,3 @@ test("replace header: renderResult refreshes the call header in place — no inv
 		assert.ok(!invalidated, "renderResult must not call invalidate");
 	});
 });
-
-test("replace: refuses and leaves the file untouched when hashlineEdit is disabled", async () => {
-	await withDir(async (dir) => {
-		const f = join(dir, "f.txt");
-		await writeFile(f, "a\nb\na\n");
-		const state = getState();
-		const saved = state.config;
-		state.config = { ...saved, enabled: false };
-		try {
-			await assert.rejects(
-				call(makeReplaceTool(dir), { path: "f.txt", find: "a", replace: "b" }),
-				/disabled/,
-			);
-			assert.equal(await readFile(f, "utf-8"), "a\nb\na\n", "file untouched when disabled");
-		} finally {
-			state.config = saved;
-		}
-	});
-});

package/src/pi/state.ts

@@ -2,7 +2,8 @@
  * Session-level config holder.
  *
  * globalThis singleton (consistent with the repo's module-identity guidance).
- * Config is loaded on session_start and read by the read/edit overrides.
+ * Config is loaded when the extension registers and read by the tool
+ * overrides.
  *
  * @module pi-hashline-edit/pi
  */