@d3ara1n/pi-hashline-edit 0.5.4 → 0.5.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@d3ara1n/pi-hashline-edit",
-  "version": "0.5.4",
+  "version": "0.5.6",
   "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/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/grep-tool.ts

@@ -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,40 +110,38 @@ 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)" })),
-  path: Type.Union([Type.String(), Type.Array(Type.String())], {
+  path: Type.Optional(Type.Union([Type.String(), Type.Array(Type.String())], {
     description:
       "Directory or file to search (string or array of paths; default: current directory)",
-  }),
+  })),
   glob: Type.Optional(
     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 =
@@ -391,9 +390,7 @@ export function makeGrepOverrideWithBackend(cwd: string, overrides: Partial<Grep
         );
       }
 
-      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;

package/src/pi/grep.test.ts

@@ -96,7 +96,9 @@ test("formats parsed rg matches with full-line hash anchors", async () => {
         ],
       });
 
-      const result = await call(makeGrepOverrideWithBackend(dir, fake.backend), {
+      const tool = makeGrepOverrideWithBackend(dir, fake.backend);
+      assert.deepEqual(tool.parameters.required, ["pattern"]);
+      const result = await call(tool, {
         pattern: "alpha",
       });
       const output = text(result);
@@ -326,3 +328,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);
+  });
+});