agent-sh 0.5.0 → 0.6.0

package/dist/agent/tools/edit-file.js

@@ -1,10 +1,43 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { computeDiff } from "../../utils/diff.js";
+/**
+ * Find the closest matching region in the file content to help diagnose
+ * why an exact match failed. Returns a hint string.
+ */
+function findClosestMatch(content, needle) {
+    const hints = [];
+    // Check if trimming whitespace would match
+    const trimmedNeedle = needle.replace(/[ \t]+$/gm, "").replace(/^[ \t]+/gm, "");
+    const trimmedContent = content.replace(/[ \t]+$/gm, "").replace(/^[ \t]+/gm, "");
+    if (trimmedContent.includes(trimmedNeedle)) {
+        hints.push(" Whitespace (indentation or trailing spaces) differs — check leading/trailing spaces on each line.");
+        return hints.join("");
+    }
+    // Check if the first line exists to narrow down the region
+    const needleLines = needle.split("\n");
+    const firstLine = needleLines[0].trim();
+    if (firstLine.length > 10) {
+        const contentLines = content.split("\n");
+        const matches = contentLines
+            .map((l, i) => ({ line: i + 1, text: l }))
+            .filter((l) => l.text.includes(firstLine));
+        if (matches.length > 0 && needleLines.length > 1) {
+            const loc = matches.map((m) => `line ${m.line}`).join(", ");
+            hints.push(` First line found at ${loc}, but subsequent lines differ. The file may have changed — use read_file to see current content around that region.`);
+            return hints.join("");
+        }
+    }
+    hints.push(" Use read_file to verify the current file contents before retrying.");
+    return hints.join("");
+}
 export function createEditFileTool(getCwd) {
     return {
         name: "edit_file",
-        description: "Edit a file by replacing an exact text match with new text. The old_text must appear exactly once in the file. Include enough context to make the match unique.",
+        description: "Edit a file by replacing an exact text match with new text. " +
+            "The old_text must appear exactly once unless replace_all=true. " +
+            "Include enough context to make the match unique. " +
+            "Use replace_all for variable renames or bulk string replacements.",
         input_schema: {
             type: "object",
             properties: {
@@ -20,6 +53,10 @@ export function createEditFileTool(getCwd) {
                     type: "string",
                     description: "Replacement text",
                 },
+                replace_all: {
+                    type: "boolean",
+                    description: "Replace ALL occurrences instead of requiring a unique match. Useful for variable renames.",
+                },
             },
             required: ["path", "old_text", "new_text"],
         },
@@ -28,12 +65,20 @@ export function createEditFileTool(getCwd) {
         requiresPermission: true,
         getDisplayInfo: (args) => ({
             kind: "write",
+            icon: "✎",
             locations: [{ path: args.path }],
         }),
+        formatResult: (_args, result) => {
+            if (result.isError)
+                return {};
+            const m = result.content.match(/\((\+\d+(?:\s-\d+)?)\)/);
+            return m ? { summary: m[1] } : {};
+        },
         async execute(args, onChunk) {
             const filePath = args.path;
             const oldText = args.old_text;
             const newText = args.new_text;
+            const replaceAll = args.replace_all ?? false;
             const absPath = path.resolve(getCwd(), filePath);
             try {
                 const content = await fs.readFile(absPath, "utf-8");
@@ -42,23 +87,31 @@ export function createEditFileTool(getCwd) {
                 const normalizedOld = oldText.replace(/\r\n/g, "\n");
                 const occurrences = normalized.split(normalizedOld).length - 1;
                 if (occurrences === 0) {
+                    // Try to find the closest match to help the agent self-correct
+                    const hint = findClosestMatch(normalized, normalizedOld);
                     return {
-                        content: `Error: old_text not found in ${filePath}`,
+                        content: `Error: old_text not found in ${filePath}.${hint}`,
                         exitCode: 1,
                         isError: true,
                     };
                 }
-                if (occurrences > 1) {
+                if (occurrences > 1 && !replaceAll) {
                     return {
-                        content: `Error: old_text found ${occurrences} times, must be unique. Add more surrounding context.`,
+                        content: `Error: old_text found ${occurrences} times, must be unique. Add more surrounding context or use replace_all=true.`,
                         exitCode: 1,
                         isError: true,
                     };
                 }
                 const normalizedNew = newText.replace(/\r\n/g, "\n");
-                const newContent = normalized.replace(normalizedOld, normalizedNew);
-                // Restore original line endings
-                const useCRLF = content.includes("\r\n");
+                const newContent = replaceAll
+                    ? normalized.split(normalizedOld).join(normalizedNew)
+                    : normalized.replace(normalizedOld, normalizedNew);
+                // Restore original line endings — only convert if the file was
+                // predominantly CRLF (>50% of line endings), to avoid corrupting
+                // mixed-ending files.
+                const crlfCount = (content.match(/\r\n/g) || []).length;
+                const lfCount = (content.match(/(?<!\r)\n/g) || []).length;
+                const useCRLF = crlfCount > 0 && crlfCount >= lfCount;
                 const finalContent = useCRLF
                     ? newContent.replace(/\n/g, "\r\n")
                     : newContent;

package/dist/agent/tools/glob.js

@@ -1,8 +1,12 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
 import { executeCommand } from "../../executor.js";
 export function createGlobTool(getCwd) {
     return {
         name: "glob",
-        description: "Find files matching a glob pattern. Returns file paths sorted by modification time.",
+        description: "Find files by name pattern. Returns paths sorted by modification time (newest first). " +
+            "ALWAYS use this instead of find/ls via bash. " +
+            "Use glob to locate files, then read_file or grep to inspect contents.",
         input_schema: {
             type: "object",
             properties: {
@@ -18,8 +22,15 @@ export function createGlobTool(getCwd) {
             required: ["pattern"],
         },
         showOutput: false,
+        formatResult: (_args, result) => {
+            if (result.isError || result.content === "No files matched.")
+                return { summary: "0 files" };
+            const lines = result.content.split("\n").filter(l => l && !l.startsWith("["));
+            return { summary: `${lines.length} files` };
+        },
         getDisplayInfo: (args) => ({
             kind: "search",
+            icon: "⌕",
             locations: args.path
                 ? [{ path: args.path }]
                 : [],
@@ -27,9 +38,15 @@ export function createGlobTool(getCwd) {
         async execute(args) {
             const pattern = args.pattern;
             const searchPath = args.path ?? ".";
-            // Use find + shell glob via bash, or rg --files --glob
+            // Use ripgrep for correct glob matching + .gitignore awareness
+            const shellEsc = (s) => "'" + s.replace(/'/g, "'\\''") + "'";
+            const parts = [
+                "rg", "--files",
+                "--glob", shellEsc(pattern),
+                shellEsc(searchPath),
+            ];
             const { session, done } = executeCommand({
-                command: `find ${JSON.stringify(searchPath)} -path ${JSON.stringify(pattern)} -type f 2>/dev/null | head -200`,
+                command: parts.join(" "),
                 cwd: getCwd(),
                 timeout: 10_000,
             });
@@ -41,12 +58,27 @@ export function createGlobTool(getCwd) {
                     isError: false,
                 };
             }
-            const lines = session.output.trim().split("\n");
-            const suffix = lines.length >= 200
-                ? `\n[Results capped at 200 files]`
+            const cwd = getCwd();
+            const files = session.output.trim().split("\n");
+            // Sort by modification time (newest first)
+            const withMtime = await Promise.all(files.map(async (f) => {
+                try {
+                    const abs = path.resolve(cwd, f);
+                    const stat = await fs.stat(abs);
+                    return { file: f, mtime: stat.mtimeMs };
+                }
+                catch {
+                    return { file: f, mtime: 0 };
+                }
+            }));
+            withMtime.sort((a, b) => b.mtime - a.mtime);
+            const sorted = withMtime.slice(0, 200).map((e) => e.file);
+            const truncated = files.length > 200;
+            const suffix = truncated
+                ? `\n[Results capped at 200 files, ${files.length - 200} more matched]`
                 : "";
             return {
-                content: session.output.trim() + suffix,
+                content: sorted.join("\n") + suffix,
                 exitCode: 0,
                 isError: false,
             };

package/dist/agent/tools/grep.js

@@ -2,7 +2,12 @@ import { executeCommand } from "../../executor.js";
 export function createGrepTool(getCwd) {
     return {
         name: "grep",
-        description: "Search file contents using ripgrep (rg). Returns matching lines with file paths and line numbers.",
+        description: "Search file contents using ripgrep. ALWAYS use this instead of running grep/rg via bash. " +
+            "Supports three output modes: " +
+            "'files_with_matches' (default, returns file paths only — use this to find which files contain a pattern), " +
+            "'content' (matching lines with optional context_before/context_after), and " +
+            "'count' (match counts per file). " +
+            "Use head_limit and offset for pagination.",
         input_schema: {
             type: "object",
             properties: {
@@ -18,12 +23,55 @@ export function createGrepTool(getCwd) {
                     type: "string",
                     description: "Glob pattern for files to include (e.g., '*.ts')",
                 },
+                output_mode: {
+                    type: "string",
+                    enum: ["files_with_matches", "content", "count"],
+                    description: "Output mode: 'files_with_matches' (default, file paths only), " +
+                        "'content' (matching lines), 'count' (match counts per file)",
+                },
+                case_insensitive: {
+                    type: "boolean",
+                    description: "Case insensitive search (default: false)",
+                },
+                context_before: {
+                    type: "number",
+                    description: "Lines to show before each match (content mode only)",
+                },
+                context_after: {
+                    type: "number",
+                    description: "Lines to show after each match (content mode only)",
+                },
+                head_limit: {
+                    type: "number",
+                    description: "Max lines/entries to return (default: 200 for files_with_matches, 150 for content/count). Pass 0 for unlimited.",
+                },
+                offset: {
+                    type: "number",
+                    description: "Skip first N lines/entries before applying head_limit. Use with head_limit for pagination.",
+                },
             },
             required: ["pattern"],
         },
         showOutput: false,
+        formatResult: (args, result) => {
+            if (result.isError || result.content === "No matches found.")
+                return { summary: "0 matches" };
+            const lines = result.content.split("\n").filter(Boolean);
+            // Strip pagination info line from count
+            const resultLines = lines.filter(l => !l.startsWith("[Showing "));
+            const mode = args.output_mode ?? "files_with_matches";
+            if (mode === "files_with_matches") {
+                return { summary: `${resultLines.length} files` };
+            }
+            if (mode === "count") {
+                const total = resultLines.reduce((sum, l) => sum + (parseInt(l.split(":").pop() ?? "0", 10) || 0), 0);
+                return { summary: `${total} matches` };
+            }
+            return { summary: `${resultLines.length} lines` };
+        },
         getDisplayInfo: (args) => ({
             kind: "search",
+            icon: "⌕",
             locations: args.path
                 ? [{ path: args.path }]
                 : [],
@@ -32,17 +80,42 @@ export function createGrepTool(getCwd) {
             const pattern = args.pattern;
             const searchPath = args.path ?? ".";
             const include = args.include;
-            const parts = [
-                "rg",
-                "--line-number",
-                "--no-heading",
-                "--color=never",
-                "--max-count=200",
-            ];
+            const mode = args.output_mode ?? "files_with_matches";
+            const caseInsensitive = args.case_insensitive;
+            const contextBefore = args.context_before;
+            const contextAfter = args.context_after;
+            const headLimit = args.head_limit;
+            const offset = args.offset ?? 0;
+            const shellEsc = (s) => "'" + s.replace(/'/g, "'\\''") + "'";
+            const parts = ["rg", "--color=never"];
+            // Mode-specific flags
+            if (mode === "files_with_matches") {
+                parts.push("--files-with-matches");
+            }
+            else if (mode === "count") {
+                parts.push("--count");
+            }
+            else {
+                // content mode
+                parts.push("--line-number", "--no-heading");
+                if (contextBefore != null && contextBefore > 0) {
+                    parts.push(`-B${contextBefore}`);
+                }
+                if (contextAfter != null && contextAfter > 0) {
+                    parts.push(`-A${contextAfter}`);
+                }
+                // If neither -A nor -B specified, use --max-count to limit per-file
+                if (contextBefore == null && contextAfter == null) {
+                    parts.push("--max-count=50");
+                }
+            }
+            if (caseInsensitive) {
+                parts.push("-i");
+            }
             if (include) {
-                parts.push("--glob", JSON.stringify(include));
+                parts.push("--glob", shellEsc(include));
             }
-            parts.push(JSON.stringify(pattern), JSON.stringify(searchPath));
+            parts.push("-e", shellEsc(pattern), shellEsc(searchPath));
             const { session, done } = executeCommand({
                 command: parts.join(" "),
                 cwd: getCwd(),
@@ -57,18 +130,36 @@ export function createGrepTool(getCwd) {
                     isError: false,
                 };
             }
-            // Truncate to ~100 lines
-            const lines = session.output.split("\n");
-            if (lines.length > 100) {
-                return {
-                    content: lines.slice(0, 100).join("\n") +
-                        `\n[${lines.length - 100} more lines truncated]`,
-                    exitCode: 0,
-                    isError: false,
-                };
+            let output = session.output;
+            // Cap individual line lengths to 500 chars to prevent minified/base64 flood
+            if (mode === "content") {
+                const MAX_LINE_LEN = 500;
+                output = output
+                    .split("\n")
+                    .map((line) => line.length > MAX_LINE_LEN
+                    ? line.slice(0, MAX_LINE_LEN) + "… [truncated]"
+                    : line)
+                    .join("\n");
+            }
+            // Apply pagination (offset + head_limit)
+            const defaultLimit = mode === "files_with_matches" ? 200 : 150;
+            const limit = headLimit === 0 ? Infinity : (headLimit ?? defaultLimit);
+            const lines = output.split("\n");
+            const total = lines.length;
+            // Apply offset then limit
+            const sliced = lines.slice(offset, offset + limit);
+            const paginated = sliced.join("\n");
+            const parts2 = [];
+            if (paginated)
+                parts2.push(paginated);
+            // Show pagination info when offset is used or results were truncated
+            if (offset > 0 || offset + limit < total) {
+                const shown = sliced.length;
+                const remaining = Math.max(0, total - offset - shown);
+                parts2.push(`\n[Showing ${shown} results (offset=${offset}, limit=${limit === Infinity ? "unlimited" : limit})${remaining > 0 ? `, ${remaining} more available` : ""}]`);
             }
             return {
-                content: session.output || "No matches found.",
+                content: parts2.join("\n") || "No matches found.",
                 exitCode: 0,
                 isError: false,
             };

package/dist/agent/tools/ls.js

@@ -1,9 +1,19 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
+function formatSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes}B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)}K`;
+    if (bytes < 1024 * 1024 * 1024)
+        return `${(bytes / (1024 * 1024)).toFixed(1)}M`;
+    return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)}G`;
+}
 export function createLsTool(getCwd) {
     return {
         name: "ls",
-        description: "List files and directories in a given path.",
+        description: "List files and directories with timestamps and sizes. " +
+            "Use for exploring a single directory. Use glob for recursive file search by pattern.",
         input_schema: {
             type: "object",
             properties: {
@@ -16,10 +26,17 @@ export function createLsTool(getCwd) {
         showOutput: false,
         getDisplayInfo: (args) => ({
             kind: "read",
+            icon: "◆",
             locations: args.path
                 ? [{ path: args.path }]
                 : [],
         }),
+        formatResult: (_args, result) => {
+            if (result.isError || result.content === "(empty directory)")
+                return { summary: "0 entries" };
+            const lines = result.content.split("\n").filter(Boolean);
+            return { summary: `${lines.length} entries` };
+        },
         async execute(args) {
             const dirPath = args.path ?? ".";
             const absPath = path.resolve(getCwd(), dirPath);
@@ -27,7 +44,19 @@ export function createLsTool(getCwd) {
                 const entries = await fs.readdir(absPath, {
                     withFileTypes: true,
                 });
-                const lines = entries.map((e) => e.isDirectory() ? `${e.name}/` : e.name);
+                const lines = [];
+                for (const e of entries) {
+                    const fullPath = path.join(absPath, e.name);
+                    try {
+                        const stat = await fs.stat(fullPath);
+                        const size = e.isDirectory() ? "-" : formatSize(stat.size);
+                        const mtime = stat.mtime.toISOString().slice(0, 16).replace("T", " ");
+                        lines.push(`${mtime}  ${size.padStart(8)}  ${e.isDirectory() ? e.name + "/" : e.name}`);
+                    }
+                    catch {
+                        lines.push(`${"?".padStart(16)}  ${"?".padStart(8)}  ${e.isDirectory() ? e.name + "/" : e.name}`);
+                    }
+                }
                 return {
                     content: lines.join("\n") || "(empty directory)",
                     exitCode: 0,

package/dist/agent/tools/read-file.d.ts

@@ -1,2 +1,10 @@
 import type { ToolDefinition } from "../types.js";
-export declare function createReadFileTool(getCwd: () => string): ToolDefinition;
+/** Tracks the last-read state of a file for deduplication. */
+export interface FileReadState {
+    mtimeMs: number;
+    offset: number;
+    limit: number | undefined;
+}
+/** Shared cache — keyed by absolute path. */
+export type FileReadCache = Map<string, FileReadState>;
+export declare function createReadFileTool(getCwd: () => string, cache?: FileReadCache): ToolDefinition;

package/dist/agent/tools/read-file.js

@@ -1,9 +1,11 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
-export function createReadFileTool(getCwd) {
+export function createReadFileTool(getCwd, cache) {
     return {
         name: "read_file",
-        description: "Read a file's contents with line numbers. Optionally specify offset and limit for large files.",
+        description: "Read a file's contents with line numbers. Use offset and limit for large files. " +
+            "Always read a file before editing it. " +
+            "If the file hasn't changed since last read, returns a stub to save context.",
         input_schema: {
             type: "object",
             properties: {
@@ -25,16 +27,52 @@ export function createReadFileTool(getCwd) {
         showOutput: false,
         getDisplayInfo: (args) => ({
             kind: "read",
+            icon: "◆",
             locations: [{ path: args.path }],
         }),
+        formatResult: (_args, result) => {
+            if (result.isError)
+                return {};
+            if (result.content.startsWith("File unchanged"))
+                return { summary: "cached" };
+            const lines = result.content.split("\n").filter(l => !l.startsWith("["));
+            return { summary: `${lines.length} lines` };
+        },
         async execute(args) {
             const filePath = args.path;
             const absPath = path.resolve(getCwd(), filePath);
+            const reqOffset = args.offset ?? 1;
+            const reqLimit = args.limit;
             try {
+                const stat = await fs.stat(absPath);
+                // Deduplication: if the file hasn't changed and same range, return stub
+                if (cache) {
+                    const prev = cache.get(absPath);
+                    if (prev &&
+                        prev.mtimeMs === stat.mtimeMs &&
+                        prev.offset === reqOffset &&
+                        prev.limit === reqLimit) {
+                        return {
+                            content: "File unchanged since last read. The content from the earlier read_file result in this conversation is still current — refer to that instead of re-reading.",
+                            exitCode: 0,
+                            isError: false,
+                        };
+                    }
+                }
+                // Check file size before reading to avoid OOM on huge files
+                const MAX_FILE_SIZE = 2 * 1024 * 1024; // 2MB
+                if (stat.size > MAX_FILE_SIZE && !args.offset && !args.limit) {
+                    const sizeMB = (stat.size / (1024 * 1024)).toFixed(1);
+                    return {
+                        content: `File is ${sizeMB}MB (${stat.size} bytes) — too large to read in full. Use offset and limit to read specific sections, e.g. offset=1 limit=200.`,
+                        exitCode: 1,
+                        isError: true,
+                    };
+                }
                 const content = await fs.readFile(absPath, "utf-8");
                 const lines = content.split("\n");
-                const start = (args.offset ?? 1) - 1; // 1-indexed → 0-indexed
-                const end = args.limit ? start + args.limit : lines.length;
+                const start = reqOffset - 1; // 1-indexed → 0-indexed
+                const end = reqLimit ? start + reqLimit : lines.length;
                 const slice = lines.slice(start, end);
                 // Add line numbers (1-indexed)
                 const numbered = slice
@@ -44,6 +82,14 @@ export function createReadFileTool(getCwd) {
                 const suffix = truncated
                     ? `\n[${lines.length - end} more lines, use offset=${end + 1} to continue]`
                     : "";
+                // Update cache on successful read
+                if (cache) {
+                    cache.set(absPath, {
+                        mtimeMs: stat.mtimeMs,
+                        offset: reqOffset,
+                        limit: reqLimit,
+                    });
+                }
                 return { content: numbered + suffix, exitCode: 0, isError: false };
             }
             catch (err) {

package/dist/agent/tools/user-shell.js

@@ -8,7 +8,7 @@
 export function createUserShellTool(opts) {
     return {
         name: "user_shell",
-        description: "Run a command in the user's live shell (visible in terminal). Output is returned to you by default. Use for cd, export, source, or commands the user wants to see. Set return_output=false for long-running or interactive commands.",
+        description: "Run a command with lasting effects in the user's live shell (cd, export, install packages, start servers, apply changes). Output is shown directly to the user but NOT returned to you by default — set return_output=true if you need to inspect the result.",
         input_schema: {
             type: "object",
             properties: {
@@ -16,6 +16,10 @@ export function createUserShellTool(opts) {
                     type: "string",
                     description: "Command to execute in user's shell",
                 },
+                timeout: {
+                    type: "number",
+                    description: "Timeout in seconds (default: 30)",
+                },
                 return_output: {
                     type: "boolean",
                     default: false,
@@ -28,29 +32,52 @@ export function createUserShellTool(opts) {
         modifiesFiles: true,
         getDisplayInfo: () => ({
             kind: "execute",
+            icon: "▷",
             locations: [],
         }),
         async execute(args) {
             const command = args.command;
+            const timeoutSec = args.timeout ?? 30;
             const returnOutput = args.return_output ?? false;
-            // Execute via the shell-exec extension's async pipe
-            const result = await opts.bus.emitPipeAsync("shell:exec-request", {
-                command,
-                output: "",
-                cwd: opts.getCwd(),
-                done: false,
-            });
+            // Execute via the shell-exec extension's async pipe with timeout
+            let result;
+            try {
+                const execPromise = opts.bus.emitPipeAsync("shell:exec-request", {
+                    command,
+                    output: "",
+                    cwd: opts.getCwd(),
+                    exitCode: null,
+                    done: false,
+                });
+                const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error("timeout")), timeoutSec * 1000));
+                result = await Promise.race([execPromise, timeoutPromise]);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                if (msg === "timeout") {
+                    return {
+                        content: `Command timed out after ${timeoutSec}s.`,
+                        exitCode: -1,
+                        isError: true,
+                    };
+                }
+                return { content: `Error: ${msg}`, exitCode: -1, isError: true };
+            }
+            const exitCode = result.exitCode ?? 0;
+            const isError = exitCode !== 0 && exitCode !== null;
             if (returnOutput) {
                 return {
                     content: result.output || "(no output)",
-                    exitCode: 0,
-                    isError: false,
+                    exitCode,
+                    isError,
                 };
             }
             return {
-                content: "Command executed.",
-                exitCode: 0,
-                isError: false,
+                content: isError
+                    ? `Command failed with exit code ${exitCode}.`
+                    : "Command executed.",
+                exitCode,
+                isError,
             };
         },
     };

package/dist/agent/tools/write-file.js

@@ -4,7 +4,8 @@ import { computeDiff } from "../../utils/diff.js";
 export function createWriteFileTool(getCwd) {
     return {
         name: "write_file",
-        description: "Create or overwrite a file with the given content. Creates parent directories if needed. Prefer edit_file for modifying existing files.",
+        description: "Create a new file or completely overwrite an existing one. Creates parent directories if needed. " +
+            "ALWAYS prefer edit_file for modifying existing files — only use write_file for new files or complete rewrites.",
         input_schema: {
             type: "object",
             properties: {
@@ -24,8 +25,15 @@ export function createWriteFileTool(getCwd) {
         requiresPermission: true,
         getDisplayInfo: (args) => ({
             kind: "write",
+            icon: "✎",
             locations: [{ path: args.path }],
         }),
+        formatResult: (_args, result) => {
+            if (result.isError)
+                return {};
+            const m = result.content.match(/\((\+\d+(?:\s-\d+)?)\)/);
+            return m ? { summary: m[1] } : {};
+        },
         async execute(args, onChunk) {
             const filePath = args.path;
             const content = args.content;