@d3ara1n/pi-hashline-edit 0.5.1 → 0.5.3

package/package.json

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

@@ -12,7 +12,7 @@ import { makeGrepOverrideWithBackend } from "../pi/grep-tool.ts";
 async function findPathRg(): Promise<string | null> {
   for (const directory of process.env.PATH?.split(delimiter) ?? []) {
     if (!directory) continue;
-    const candidate = join(directory, "rg");
+    const candidate = join(directory, process.platform === "win32" ? "rg.exe" : "rg");
     try {
       await access(candidate, constants.X_OK);
       return candidate;
@@ -31,15 +31,16 @@ test("real rg emits anchored matches from a temporary directory", {
     const file = join(directory, "fixture.ts");
     await writeFile(file, "needle\nother\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" }, undefined, undefined);
-    assert.match(result.content[0].text, /fixture\.ts · 1 match/);
-    assert.match(result.content[0].text, /1#[0-9A-Z]+│needle/);
+    for (const pattern of ["needle", ["needle"]]) {
+      const result: any = await tool.execute("0", { pattern }, undefined, undefined);
+      assert.match(result.content[0].text, /fixture\.ts · 1 match/);
+      assert.match(result.content[0].text, /1#[0-9A-Z]+│needle/);
+    }
   } finally {
     await rm(directory, { recursive: true, force: true });
   }

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 { basename, delimiter, join, relative } from "node:path";
+import { delimiter, 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";
@@ -55,15 +55,16 @@ const GREP_MAX_LINE_LENGTH = 500;
 
 /** Locate ripgrep: pi's bundled bin first, then PATH. Returns null if not found. */
 async function findRg(): Promise<string | null> {
+  const executable = process.platform === "win32" ? "rg.exe" : "rg";
   const agentDir = getAgentDir();
-  const piRg = join(agentDir, "bin", "rg");
+  const piRg = join(agentDir, "bin", executable);
   try {
     await access(piRg, constants.X_OK);
     return piRg;
   } catch {}
   for (const dir of process.env.PATH?.split(delimiter) ?? []) {
     if (!dir) continue;
-    const p = join(dir, "rg");
+    const p = join(dir, executable);
     try {
       await access(p, constants.X_OK);
       return p;
@@ -410,11 +411,9 @@ export function makeGrepOverrideWithBackend(cwd: string, overrides: Partial<Grep
       })();
       const hashLen = state.config.hashLen;
 
-      // Verify search paths upfront; remember dir-ness for relative display.
-      const roots: { path: string; isDir: boolean }[] = [];
       for (const sp of searchPaths) {
         try {
-          roots.push({ path: sp, isDir: (await stat(sp)).isDirectory() });
+          await stat(sp);
         } catch {
           throw new Error(`Path not found: ${sp}`);
         }
@@ -527,12 +526,11 @@ export function makeGrepOverrideWithBackend(cwd: string, overrides: Partial<Grep
             };
 
             const formatPath = (fp: string): string => {
-              for (const root of roots) {
-                if (!root.isDir) continue;
-                const rel = relative(root.path, fp).replace(/\\/g, "/");
-                if (rel && !rel.startsWith("..")) return rel;
-              }
-              return basename(fp);
+              const abs = resolve(cwd, fp);
+              const rel = relative(cwd, abs);
+              return rel && rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel)
+                ? rel.replace(/\\/g, "/")
+                : abs;
             };
 
             const blocks: string[] = [];

package/src/pi/grep.test.ts

@@ -4,11 +4,12 @@
  */
 import { test } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { computeLineHash } from "../core/hash.ts";
 import { makeGrepOverrideWithBackend, type GrepBackend } from "./grep-tool.ts";
+import { makeEditOverride } from "./edit-tool.ts";
 import { getState } from "./state.ts";
 
 type FakeOptions = {
@@ -111,6 +112,37 @@ test("formats parsed rg matches with full-line hash anchors", async () => {
   );
 });
 
+test("grep in a subdirectory returns a path that edits the matching file", async () => {
+  await withDir(async (dir) =>
+    withEnabled(true, async () => {
+      await mkdir(join(dir, "src"));
+      const original = "export const status = 1;\n";
+      const rootFile = join(dir, "status.ts");
+      const matchedFile = join(dir, "src", "status.ts");
+      await writeFile(rootFile, original);
+      await writeFile(matchedFile, original);
+      const fake = fakeBackend({ lines: [rgMatch(matchedFile, 1, original)] });
+      const result = await call(makeGrepOverrideWithBackend(dir, fake.backend), {
+        pattern: "status",
+        path: "src",
+      });
+      const output = text(result);
+      const displayPath = output.split(" · ")[0];
+      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;"],
+        }],
+      });
+      assert.equal(await readFile(matchedFile, "utf-8"), "export const status = 2;\n");
+      assert.equal(await readFile(rootFile, "utf-8"), original);
+    }),
+  );
+});
+
 test("applies all, exclude, context, and CRLF filtering after rg output", async () => {
   await withDir(async (dir) =>
     withEnabled(true, async () => {

package/src/pi/pi.test.ts

@@ -2,15 +2,18 @@ import { test } from "node:test";
 import assert from "node:assert/strict";
 import { canonicalPath } from "./read-tool.ts";
 import { homedir } from "node:os";
+import { join, resolve } from "node:path";
 
 test("canonicalPath resolves relative and absolute", () => {
-	assert.equal(canonicalPath("/cwd", "foo.ts"), "/cwd/foo.ts");
-	assert.equal(canonicalPath("/cwd", "./foo.ts"), "/cwd/foo.ts");
-	assert.equal(canonicalPath("/cwd", "/abs/x.ts"), "/abs/x.ts");
+	const cwd = resolve("/cwd");
+	const absolute = resolve("/abs/x.ts");
+	assert.equal(canonicalPath(cwd, "foo.ts"), join(cwd, "foo.ts"));
+	assert.equal(canonicalPath(cwd, "./foo.ts"), join(cwd, "foo.ts"));
+	assert.equal(canonicalPath(cwd, absolute), absolute);
 });
 
 test("canonicalPath expands ~ to home directory", () => {
 	const home = homedir();
 	assert.equal(canonicalPath("/cwd", "~"), home);
-	assert.equal(canonicalPath("/cwd", "~/foo.ts"), `${home}/foo.ts`);
+	assert.equal(canonicalPath("/cwd", "~/foo.ts"), join(home, "foo.ts"));
 });