@d3ara1n/pi-hashline-edit 0.5.7 → 0.6.0

package/README.md

@@ -165,6 +165,7 @@ The `grep` override also covers the compound queries that otherwise push models
 - `wordMatch` — whole words only (`rg -w`)
 - `outputMode: "files"` / `"count"` — just the file paths (`rg -l`) or per-file counts + total (`grep -c`); `"files"` output pastes straight back as a `path` array
 - `pattern` and `path` accept arrays — several patterns combined per `matchMode`, several search roots in one call
+- `glob` accepts one pattern or an ordered array of ripgrep globs, e.g. `["*.ts", "*.md", "!**/*.test.ts"]` to include TypeScript and Markdown files but exclude tests
 
 Filters run before the match limit counts, and context windows are rebuilt from surviving matches, so `limit` and `context` compose cleanly with `matchMode`/`excludePattern`.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@d3ara1n/pi-hashline-edit",
-  "version": "0.5.7",
+  "version": "0.6.0",
   "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

@@ -46,6 +46,31 @@ test("real rg emits anchored matches from a temporary directory", {
   }
 });
 
+test("real rg combines include and exclude globs in order", {
+  skip: rgPath === null,
+}, async () => {
+  const directory = await mkdtemp(join(tmpdir(), "hl-grep-globs-"));
+  try {
+    for (const name of ["first.ts", "second.ts", "first.test.ts", "notes.md", "notes.txt"]) {
+      await writeFile(join(directory, name), "needle\n");
+    }
+    const tool = makeGrepOverrideWithBackend(directory, {
+      findRg: async () => rgPath,
+      delegate: async () => {
+        throw new Error("integration test must not invoke the built-in grep delegate");
+      },
+    });
+    const result: any = await tool.execute("0", {
+      pattern: "needle",
+      glob: ["*.ts", "*.md", "!**/*.test.ts"],
+      outputMode: "files",
+    }, undefined, undefined);
+    assert.deepEqual(result.content[0].text.split("\n").sort(), ["first.ts", "notes.md", "second.ts"]);
+  } finally {
+    await rm(directory, { recursive: true, force: true });
+  }
+});
+
 test("real rg and line filters honor explicit case settings and Unicode folding", {
   skip: rgPath === null,
 }, async () => {

package/src/pi/grep-tool.ts

@@ -140,7 +140,9 @@ const grepOverrideSchema = Type.Object({
       "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'" }),
+    Type.Union([Type.String(), Type.Array(Type.String())], {
+      description: "Filter files by glob pattern; pass an array for multiple filters and prefix exclusions with `!`, e.g. ['*.ts', '!**/*.test.ts']",
+    }),
   ),
   ignoreCase: Type.Optional(
     Type.Boolean({ description: "Case-insensitive search (default: false); applies to pattern and excludePattern." }),
@@ -340,7 +342,7 @@ export function makeGrepOverrideWithBackend(cwd: string, overrides: Partial<Grep
         text += theme.fg("toolOutput", ` -v:${ex}`);
       }
       if (args?.wordMatch) text += theme.fg("toolOutput", " -w");
-      if (args?.glob) text += theme.fg("toolOutput", ` (${args.glob})`);
+      if (args?.glob) text += theme.fg("toolOutput", ` (${toArray(args.glob).join(", ")})`);
       if (args?.outputMode && args.outputMode !== "content")
         text += theme.fg("success", ` → ${args.outputMode}`);
       if (args?.limit !== undefined) text += theme.fg("toolOutput", ` limit ${args.limit}`);
@@ -388,6 +390,7 @@ export function makeGrepOverrideWithBackend(cwd: string, overrides: Partial<Grep
         params.excludePattern === undefined &&
         params.outputMode === undefined &&
         params.wordMatch === undefined &&
+        !Array.isArray(params.glob) &&
         !Array.isArray(params.path);
 
       const rgPath = await backend.findRg();
@@ -402,7 +405,8 @@ export function makeGrepOverrideWithBackend(cwd: string, overrides: Partial<Grep
       const excludes = toArray(params.excludePattern);
       const matchMode: "any" | "all" = params.matchMode ?? "any";
       const outputMode: "content" | "files" | "count" = params.outputMode ?? "content";
-      const { glob, ignoreCase, literal, wordMatch, limit } = params;
+      const globs = toArray(params.glob);
+      const { ignoreCase, literal, wordMatch, limit } = params;
       const searchPaths = (() => {
         const raw = toArray(params.path);
         return (raw.length ? raw : ["."]).map((p) => canonicalPath(cwd, p));
@@ -446,7 +450,7 @@ export function makeGrepOverrideWithBackend(cwd: string, overrides: Partial<Grep
         if (ignoreCase) args.push("--ignore-case");
         if (literal) args.push("--fixed-strings");
         if (wordMatch) args.push("--word-regexp");
-        if (glob) args.push("--glob", glob);
+        for (const glob of globs) args.push("--glob", glob);
         for (const p of patterns) args.push("-e", p);
         args.push("--", ...searchPaths);
 

package/src/pi/grep.test.ts

@@ -219,10 +219,13 @@ test("passes output flags and formats files and counts", async () => {
       await writeFile(b, "foo a.b\n");
       const fake = fakeBackend({ lines: [rgMatch(a, 1, "Foo a.b\n"), rgMatch(b, 1, "foo a.b\n")] });
 
-      const files = await call(makeGrepOverrideWithBackend(dir, fake.backend), {
+      const tool = makeGrepOverrideWithBackend(dir, fake.backend);
+      const globSchema: any = tool.parameters.properties.glob;
+      assert.deepEqual(globSchema.anyOf.map((option: any) => option.type), ["string", "array"]);
+      const files = await call(tool, {
         pattern: ["Foo", "a.b"],
         path: ["a.ts", "b.ts"],
-        glob: "*.ts",
+        glob: ["*.ts", "!**/*.test.ts"],
         ignoreCase: true,
         literal: true,
         wordMatch: true,
@@ -239,6 +242,8 @@ test("passes output flags and formats files and counts", async () => {
         "--word-regexp",
         "--glob",
         "*.ts",
+        "--glob",
+        "!**/*.test.ts",
         "-e",
         "Foo",
         "-e",
@@ -337,6 +342,12 @@ test("delegates only safe fallbacks and rejects extended missing-rg requests", a
         }),
         /ripgrep \(rg\) not found/,
       );
+      await call(tool, { pattern: "x", glob: "*.ts" });
+      assert.deepEqual(absent.delegates.at(-1)?.[1], { pattern: "x", glob: "*.ts" });
+      await assert.rejects(
+        call(tool, { pattern: "x", glob: ["*.ts", "!**/*.test.ts"] }),
+        /ripgrep \(rg\) not found/,
+      );
     });
   });
 });