@d3ara1n/pi-hashline-edit 0.5.6 → 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.6",
+  "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

@@ -52,6 +52,7 @@ import { parseHashline } from "./render.ts";
 const DEFAULT_LIMIT = 100;
 /** Max chars per result line for display (mirrors pi's truncate.ts; not exported there). */
 const GREP_MAX_LINE_LENGTH = 500;
+const GREP_CONTEXT_MAX = 20;
 
 /** Locate ripgrep: pi's bundled bin first, then PATH. Returns null if not found. */
 async function findRg(): Promise<string | null> {
@@ -107,6 +108,11 @@ function toArray(v: string | string[] | undefined): string[] {
   return Array.isArray(v) ? v : [v];
 }
 
+function clampContext(context: number | undefined): number {
+  if (!context || !Number.isFinite(context) || context < 0) return 0;
+  return Math.min(Math.floor(context), GREP_CONTEXT_MAX);
+}
+
 const grepOverrideSchema = Type.Object({
   pattern: Type.Union([Type.String(), Type.Array(Type.String())], {
     description:
@@ -134,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." }),
@@ -145,9 +153,10 @@ const grepOverrideSchema = Type.Object({
     }),
   ),
   context: Type.Optional(
-    Type.Number({
-      description:
-        "Number of lines to show before and after each match (default: 0); context lines are anchored too",
+    Type.Integer({
+      minimum: 0,
+      maximum: GREP_CONTEXT_MAX,
+      description: `Number of lines on each side of a match (0-${GREP_CONTEXT_MAX}; default: 0); context lines are anchored too`,
     }),
   ),
   limit: Type.Optional(
@@ -333,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}`);
@@ -365,8 +374,10 @@ export function makeGrepOverrideWithBackend(cwd: string, overrides: Partial<Grep
       onUpdate: any,
     ): Promise<any> {
       const state = getState();
+      const ctx = clampContext(params.context);
+      const delegatedParams = params.context === undefined ? params : { ...params, context: ctx };
       // aborted → built-in grep (it handles abort itself)
-      if (signal?.aborted) return backend.delegate(toolCallId, params, signal, onUpdate);
+      if (signal?.aborted) return backend.delegate(toolCallId, delegatedParams, signal, onUpdate);
 
       const patterns = toArray(params.pattern);
       if (patterns.length === 0) throw new Error("pattern is required (got an empty array)");
@@ -379,12 +390,13 @@ 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();
       // ripgrep unavailable → built-in (it can auto-download rg), but only for plain params
       if (!rgPath) {
-        if (legacyShaped) return backend.delegate(toolCallId, params, signal, onUpdate);
+        if (legacyShaped) return backend.delegate(toolCallId, delegatedParams, signal, onUpdate);
         throw new Error(
           "ripgrep (rg) not found; extended grep params cannot fall back to the built-in grep. Retry with a simple pattern first, or use bash",
         );
@@ -393,8 +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, context, limit } = params;
-      const ctx = context && context > 0 ? context : 0;
+      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));
@@ -438,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

@@ -163,11 +163,16 @@ test("applies all, exclude, context, and CRLF filtering after rg output", async
         ],
       });
 
-      const result = await call(makeGrepOverrideWithBackend(dir, fake.backend), {
+      const tool = makeGrepOverrideWithBackend(dir, fake.backend);
+      const contextSchema: any = tool.parameters.properties.context;
+      assert.equal(contextSchema.type, "integer");
+      assert.equal(contextSchema.minimum, 0);
+      assert.equal(contextSchema.maximum, 20);
+      const result = await call(tool, {
         pattern: ["alpha", "beta$"],
         matchMode: "all",
         excludePattern: "drop",
-        context: 1,
+        context: 1.9,
       });
       assert.equal(
         text(result),
@@ -182,6 +187,29 @@ test("applies all, exclude, context, and CRLF filtering after rg output", async
   );
 });
 
+test("context bounds apply to each side of a match, including direct runtime calls", async () => {
+  await withDir(async (dir) => {
+    const file = join(dir, "a.ts");
+    const lines = Array.from({ length: 45 }, (_, i) => i === 22 ? "needle" : `line ${i + 1}`);
+    await writeFile(file, lines.join("\n"));
+    const fake = fakeBackend({ lines: [rgMatch(file, 23, "needle\n")] });
+    const tool = makeGrepOverrideWithBackend(dir, fake.backend);
+
+    for (const context of [20, 1_000]) {
+      const output = text(await call(tool, { pattern: "needle", context })).split("\n");
+      assert.equal(output.length, 42);
+      assert.match(output[1], /^3#[0-9A-Z]+│line 3$/);
+      assert.match(output[21], /^23#[0-9A-Z]+│needle$/);
+      assert.match(output[41], /^43#[0-9A-Z]+│line 43$/);
+    }
+    for (const context of [-1, Number.NaN, Number.POSITIVE_INFINITY]) {
+      const output = text(await call(tool, { pattern: "needle", context })).split("\n");
+      assert.equal(output.length, 2);
+      assert.match(output[1], /^23#[0-9A-Z]+│needle$/);
+    }
+  });
+});
+
 test("passes output flags and formats files and counts", async () => {
   await withDir(async (dir) =>
     withEnabled(true, async () => {
@@ -191,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,
@@ -211,6 +242,8 @@ test("passes output flags and formats files and counts", async () => {
         "--word-regexp",
         "--glob",
         "*.ts",
+        "--glob",
+        "!**/*.test.ts",
         "-e",
         "Foo",
         "-e",
@@ -289,6 +322,19 @@ test("delegates only safe fallbacks and rejects extended missing-rg requests", a
         text(await call(makeGrepOverrideWithBackend(dir, absent.backend), { pattern: "x" })),
         "delegated",
       );
+      assert.deepEqual(absent.delegates.at(-1)?.[1], { pattern: "x" });
+      const tool = makeGrepOverrideWithBackend(dir, absent.backend);
+      for (const [context, expected] of [
+        [1_000, 20],
+        [1.9, 1],
+        [-1, 0],
+        [Number.POSITIVE_INFINITY, 0],
+      ]) {
+        const params = { pattern: "x", context };
+        await call(tool, params);
+        assert.equal(absent.delegates.at(-1)?.[1].context, expected);
+        assert.equal(params.context, context);
+      }
       await assert.rejects(
         call(makeGrepOverrideWithBackend(dir, absent.backend), {
           pattern: ["x", "y"],
@@ -296,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/,
+      );
     });
   });
 });