@d3ara1n/pi-hashline-edit 0.5.6 → 0.5.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@d3ara1n/pi-hashline-edit",
-  "version": "0.5.6",
+  "version": "0.5.7",
   "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/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:
@@ -145,9 +151,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(
@@ -365,8 +372,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)");
@@ -384,7 +393,7 @@ export function makeGrepOverrideWithBackend(cwd: string, overrides: Partial<Grep
       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 +402,7 @@ 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 { glob, ignoreCase, literal, wordMatch, limit } = params;
       const searchPaths = (() => {
         const raw = toArray(params.path);
         return (raw.length ? raw : ["."]).map((p) => canonicalPath(cwd, p));

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 () => {
@@ -289,6 +317,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"],