@d3ara1n/pi-hashline-edit 0.5.7 → 0.6.1

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. It also filters explicitly named files; this requires a locally available ripgrep binary.
 
 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.1",
   "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

@@ -4,7 +4,7 @@
  */
 import { test } from "node:test";
 import assert from "node:assert/strict";
-import { access, constants, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { access, constants, mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { delimiter, join } from "node:path";
 import { makeGrepOverrideWithBackend } from "../pi/grep-tool.ts";
@@ -46,6 +46,73 @@ 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 applies globs to explicit files and mixed search paths", {
+  skip: rgPath === null,
+}, async () => {
+  const directory = await mkdtemp(join(tmpdir(), "hl-grep-explicit-globs-"));
+  try {
+    await mkdir(join(directory, "sub"));
+    await writeFile(join(directory, ".gitignore"), "ignored.ts\n");
+    for (const name of ["keep.ts", "drop.test.ts", "ignored.ts", "sub/child.ts"]) {
+      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 search = async (path: string | string[], glob: string | string[]) => {
+      const result: any = await tool.execute("0", { pattern: "needle", path, glob, outputMode: "files" }, undefined, undefined);
+      return result.content[0].text;
+    };
+    const globs = ["*.ts", "!**/*.test.ts"];
+    assert.deepEqual(
+      (await search(["drop.test.ts", "keep.ts", "ignored.ts"], globs)).split("\n").sort(),
+      ["ignored.ts", "keep.ts"],
+    );
+    assert.equal(await search("drop.test.ts", "*.ts"), "drop.test.ts");
+    assert.equal(await search("drop.test.ts", globs), "No matches found");
+    assert.equal(await search(["drop.test.ts", "keep.ts"], "!**/*.test.ts"), "keep.ts");
+    assert.equal(await search("sub/child.ts", "**/sub/*.ts"), "sub/child.ts");
+    assert.deepEqual(
+      (await search(["keep.ts", "sub/child.ts"], globs)).split("\n").sort(),
+      ["keep.ts", "sub/child.ts"],
+    );
+    assert.deepEqual(
+      (await search(["drop.test.ts", "sub", "keep.ts"], globs)).split("\n").sort(),
+      ["keep.ts", "sub/child.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

@@ -42,7 +42,7 @@ import { Text } from "@earendil-works/pi-tui";
 import { spawn } from "node:child_process";
 import { createInterface } from "node:readline";
 import { access, constants, readFile, stat } from "node:fs/promises";
-import { delimiter, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { delimiter, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { hashFileLines } from "../core/hash.ts";
 import { splitLines } from "../core/lines.ts";
 import { getState } from "./state.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 (including explicit file paths) by glob; pass an ordered 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." }),
@@ -176,6 +178,12 @@ interface RgRunResult {
 /** @internal — injectable process and fallback boundary for deterministic tests. */
 export interface GrepBackend {
   findRg(): Promise<string | null>;
+  listFiles(
+    rgPath: string,
+    directories: string[],
+    globs: string[],
+    signal: AbortSignal | undefined,
+  ): Promise<Set<string>>;
   runRg(
     rgPath: string,
     args: string[],
@@ -190,6 +198,43 @@ export interface GrepBackend {
   ): Promise<any>;
 }
 
+/** List direct children using rg's own ordered glob rules (including ignored files). */
+function listRgFiles(
+  rgPath: string,
+  directories: string[],
+  globs: string[],
+  signal: AbortSignal | undefined,
+): Promise<Set<string>> {
+  return new Promise((resolveFiles, reject) => {
+    if (signal?.aborted) return reject(new Error("Operation aborted"));
+    const args = ["--files", "--null", "--hidden", "--no-ignore", "--follow", "--max-depth=1"];
+    for (const glob of globs) args.push("--glob", glob);
+    args.push("--", ...directories);
+    const child = spawn(rgPath, args, { stdio: ["ignore", "pipe", "pipe"] });
+    const chunks: Buffer[] = [];
+    let stderr = "";
+    const onAbort = () => child.kill();
+    signal?.addEventListener("abort", onAbort, { once: true });
+    child.stdout.on("data", (chunk: Buffer) => chunks.push(chunk));
+    child.stderr.on("data", (chunk: Buffer) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", (error) => {
+      signal?.removeEventListener("abort", onAbort);
+      reject(new Error(`Failed to run ripgrep: ${error.message}`));
+    });
+    child.on("close", (code) => {
+      signal?.removeEventListener("abort", onAbort);
+      if (signal?.aborted) return reject(new Error("Operation aborted"));
+      if (code !== 0 && code !== 1) {
+        return reject(new Error(stderr.trim() || `ripgrep exited with code ${code}`));
+      }
+      const paths = Buffer.concat(chunks).toString("utf-8").split("\0").filter(Boolean);
+      resolveFiles(new Set(paths));
+    });
+  });
+}
+
 /** Run ripgrep and stream its JSON lines to the caller until it asks to stop. */
 function runRg(
   rgPath: string,
@@ -256,6 +301,10 @@ function countLeading(s: string): number {
 function toDisplayLines(raw: string, theme: any): string[] {
   const out: string[] = [];
   const lines = raw.split("\n");
+  const lineNoWidth = lines.reduce(
+    (width, line) => Math.max(width, parseHashline(line)?.lineNo.length ?? 0),
+    0,
+  );
   let i = 0;
   while (i < lines.length) {
     const line = lines[i];
@@ -276,7 +325,7 @@ function toDisplayLines(raw: string, theme: any): string[] {
       const marker = base > 0 ? theme.fg("dim", "›") + " " : "";
       for (const g of group) {
         const body = g.content.slice(base);
-        out.push(theme.fg("dim", `   ${g.lineNo}: `) + marker + theme.fg("toolOutput", body));
+        out.push(theme.fg("dim", `   ${g.lineNo.padStart(lineNoWidth)}: `) + marker + theme.fg("toolOutput", body));
       }
       i = j;
       continue;
@@ -298,6 +347,7 @@ export function makeGrepOverrideWithBackend(cwd: string, overrides: Partial<Grep
   let builtin: ReturnType<typeof createGrepTool> | undefined;
   const backend: GrepBackend = {
     findRg,
+    listFiles: listRgFiles,
     runRg,
     delegate(toolCallId, params, signal, onUpdate) {
       builtin ??= createGrepTool(cwd);
@@ -340,7 +390,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,12 +438,22 @@ 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 globs = toArray(params.glob);
       const rgPath = await backend.findRg();
-      // ripgrep unavailable → built-in (it can auto-download rg), but only for plain params
+      // The built-in grep also lets explicit files bypass globs.
       if (!rgPath) {
-        if (legacyShaped) return backend.delegate(toolCallId, delegatedParams, signal, onUpdate);
+        if (legacyShaped) {
+          if (params.glob !== undefined && params.path !== undefined) {
+            const path = canonicalPath(cwd, params.path);
+            let explicitFile = false;
+            try { explicitFile = (await stat(path)).isFile(); } catch {}
+            if (explicitFile) throw new Error("ripgrep (rg) not found; cannot apply glob to an explicit file");
+          }
+          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",
         );
@@ -402,22 +462,43 @@ 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 { ignoreCase, literal, wordMatch, limit } = params;
       const searchPaths = (() => {
         const raw = toArray(params.path);
         return (raw.length ? raw : ["."]).map((p) => canonicalPath(cwd, p));
       })();
       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).
+      // rg ignores globs for explicit files, so select those with its file walker first.
+      const pathInfo: { path: string; isFile: boolean }[] = [];
+      const parents = new Set<string>();
       for (const sp of searchPaths) {
+        let info;
         try {
-          await stat(sp);
+          info = await stat(sp);
         } catch {
           throw new Error(`Path not found: ${sp}`);
         }
+        const isFile = info.isFile();
+        pathInfo.push({ path: sp, isFile });
+        if (globs.length && isFile) parents.add(dirname(sp));
       }
+      const fileKey = (path: string) => {
+        const absolute = resolve(cwd, path);
+        return process.platform === "win32" ? absolute.toLowerCase() : absolute;
+      };
+      const listed = parents.size
+        ? await backend.listFiles(rgPath, [...parents], globs, signal)
+        : new Set<string>();
+      const allowed = new Set([...listed].map(fileKey));
+      const selectedPaths = pathInfo
+        .filter(({ path, isFile }) => !globs.length || !isFile || allowed.has(fileKey(path)))
+        .map(({ path }) => path);
+      if (signal?.aborted) throw new Error("Operation aborted");
+      if (selectedPaths.length === 0) return {
+        content: [{ type: "text", text: "No matches found" }],
+        details: undefined,
+      };
 
       // Client-side line filters — only AND / exclude need them; "any" is native rg (-e OR).
       const excludeMatchers = excludes.map((p) =>
@@ -446,9 +527,9 @@ 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);
+        args.push("--", ...selectedPaths);
 
         const effectiveLimit = Math.max(1, limit ?? DEFAULT_LIMIT);
         let matchCount = 0;

package/src/pi/grep.test.ts

@@ -14,6 +14,7 @@ import { getState } from "./state.ts";
 
 type FakeOptions = {
   lines?: string[];
+  files?: string[];
   code?: number | null;
   stderr?: string;
   error?: Error;
@@ -38,11 +39,16 @@ function rgMatch(filePath: string, lineNumber: number, text: string): string {
 
 function fakeBackend(options: FakeOptions = {}) {
   const calls: { path: string; args: string[] }[] = [];
+  const fileCalls: { directories: string[]; globs: string[] }[] = [];
   const delegates: any[][] = [];
   const backend: GrepBackend = {
     async findRg() {
       return "/fake/rg";
     },
+    async listFiles(_path, directories, globs) {
+      fileCalls.push({ directories, globs });
+      return new Set(options.files ?? []);
+    },
     async runRg(path, args, _signal, onLine) {
       calls.push({ path, args });
       options.onRun?.();
@@ -61,7 +67,7 @@ function fakeBackend(options: FakeOptions = {}) {
       return { content: [{ type: "text", text: "delegated" }], details: undefined };
     },
   };
-  return { backend, calls, delegates };
+  return { backend, calls, fileCalls, delegates };
 }
 
 const text = (result: any): string => result.content[0].text;
@@ -79,6 +85,27 @@ async function withEnabled<T>(enabled: boolean, fn: () => Promise<T>): Promise<T
   }
 }
 
+test("grep TUI aligns line-number colons across file groups", () => {
+  const raw = [
+    "a.ts · 2 matches",
+    "99#ABCD│  alpha",
+    "100#ABCD│    beta",
+    "b.ts · 1 match",
+    "7#ABCD│gamma",
+  ].join("\n");
+  const tool = makeGrepOverrideWithBackend(".", {});
+  const theme = { fg: (_color: string, value: string) => value };
+  const result = { content: [{ type: "text", text: raw }] };
+  const rendered = tool.renderResult(result, { isPartial: false, expanded: true }, theme, {}).render(80);
+  assert.deepEqual(rendered.map((line) => line.trimEnd()), [
+    "a.ts · 2 matches",
+    "    99: › alpha",
+    "   100: ›   beta",
+    "b.ts · 1 match",
+    "     7: gamma",
+  ]);
+});
+
 test("formats parsed rg matches with full-line hash anchors", async () => {
   await withDir(async (dir) =>
     withEnabled(true, async () => {
@@ -217,12 +244,15 @@ test("passes output flags and formats files and counts", async () => {
       const b = join(dir, "b.ts");
       await writeFile(a, "Foo a.b\n");
       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 fake = fakeBackend({ files: [a, b], 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 +269,8 @@ test("passes output flags and formats files and counts", async () => {
         "--word-regexp",
         "--glob",
         "*.ts",
+        "--glob",
+        "!**/*.test.ts",
         "-e",
         "Foo",
         "-e",
@@ -257,6 +289,30 @@ test("passes output flags and formats files and counts", async () => {
   );
 });
 
+test("glob filters explicit files and batches their parent directories", async () => {
+  await withDir(async (dir) => {
+    const kept = join(dir, "kept.ts");
+    const excluded = join(dir, "excluded.test.ts");
+    const nested = join(dir, "sub", "other.ts");
+    await mkdir(join(dir, "sub"));
+    await writeFile(nested, "needle\n");
+    await writeFile(kept, "needle\n");
+    await writeFile(excluded, "needle\n");
+    const fake = fakeBackend({
+      files: [kept, nested],
+      lines: [rgMatch(kept, 1, "needle\n"), rgMatch(nested, 1, "needle\n")],
+    });
+    const tool = makeGrepOverrideWithBackend(dir, fake.backend);
+    const query = { pattern: "needle", path: ["kept.ts", "excluded.test.ts", "sub/other.ts"], glob: ["*.ts", "!**/*.test.ts"] };
+    assert.match(text(await call(tool, query)), /│needle/);
+    assert.deepEqual(fake.fileCalls, [{ directories: [dir, join(dir, "sub")], globs: query.glob }]);
+    assert.deepEqual(fake.calls[0].args.slice(-3), ["--", kept, nested]);
+
+    assert.equal(text(await call(tool, { ...query, path: "excluded.test.ts" })), "No matches found");
+    assert.equal(fake.calls.length, 1);
+  });
+});
+
 test("counts only surviving matches toward the limit and stops the fake runner", async () => {
   await withDir(async (dir) =>
     withEnabled(true, async () => {
@@ -337,6 +393,22 @@ 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/,
+      );
+      const file = join(dir, "fixture.ts");
+      await writeFile(file, "x\n");
+      const delegatedBefore = absent.delegates.length;
+      await assert.rejects(
+        call(tool, { pattern: "x", path: file, glob: "*.ts" }),
+        /cannot apply glob to an explicit file/,
+      );
+      assert.equal(absent.delegates.length, delegatedBefore);
+      assert.equal(text(await call(tool, { pattern: "x", path: file })), "delegated");
+      assert.equal(text(await call(tool, { pattern: "x", path: dir, glob: "*.ts" })), "delegated");
     });
   });
 });