@zhijiewang/openharness 2.1.0 → 2.3.1

package/dist/tools/BashTool/index.js

@@ -1,5 +1,5 @@
+import { spawn } from "node:child_process";
 import { z } from "zod";
-import { spawn } from "child_process";
 import { safeEnv } from "../../utils/safe-env.js";
 const inputSchema = z.object({
     command: z.string(),
@@ -8,7 +8,7 @@ const inputSchema = z.object({
     run_in_background: z.boolean().optional(),
 });
 const MAX_OUTPUT = 100_000;
-const DEFAULT_TIMEOUT = 120_000;
+const _DEFAULT_TIMEOUT = 120_000;
 const MAX_TIMEOUT = 600_000;
 export const BashTool = {
     name: "Bash",
@@ -38,17 +38,25 @@ export const BashTool = {
             });
             let stdout = "";
             let stderr = "";
-            proc.stdout.on("data", (chunk) => { stdout += chunk.toString(); });
-            proc.stderr.on("data", (chunk) => { stderr += chunk.toString(); });
-            const timer = setTimeout(() => { proc.kill("SIGTERM"); }, timeoutMs);
+            proc.stdout.on("data", (chunk) => {
+                stdout += chunk.toString();
+            });
+            proc.stderr.on("data", (chunk) => {
+                stderr += chunk.toString();
+            });
+            const timer = setTimeout(() => {
+                proc.kill("SIGTERM");
+            }, timeoutMs);
             if (context.abortSignal) {
-                context.abortSignal.addEventListener("abort", () => { proc.kill("SIGTERM"); });
+                context.abortSignal.addEventListener("abort", () => {
+                    proc.kill("SIGTERM");
+                });
             }
             proc.on("close", (code) => {
                 clearTimeout(timer);
-                let output = stdout + (stderr ? "\n[stderr]\n" + stderr : "");
+                let output = stdout + (stderr ? `\n[stderr]\n${stderr}` : "");
                 if (output.length > MAX_OUTPUT) {
-                    output = output.slice(0, MAX_OUTPUT) + "\n... [truncated]";
+                    output = `${output.slice(0, MAX_OUTPUT)}\n... [truncated]`;
                 }
                 // Notify via output chunk when background process completes
                 if (context.onOutputChunk && context.callId) {
@@ -94,9 +102,9 @@ export const BashTool = {
             }
             proc.on("close", (code) => {
                 clearTimeout(timer);
-                let output = stdout + (stderr ? "\n[stderr]\n" + stderr : "");
+                let output = stdout + (stderr ? `\n[stderr]\n${stderr}` : "");
                 if (output.length > MAX_OUTPUT) {
-                    output = output.slice(0, MAX_OUTPUT) + "\n... [truncated]";
+                    output = `${output.slice(0, MAX_OUTPUT)}\n... [truncated]`;
                 }
                 if (killed) {
                     output += "\n[timed out]";

package/dist/tools/CronTool/index.js

@@ -13,47 +13,65 @@ const deleteSchema = z.object({
 const listSchema = z.object({
     action: z.literal("list"),
 });
-const inputSchema = z.discriminatedUnion("action", [createSchema, deleteSchema, listSchema]);
+const _inputSchema = z.discriminatedUnion("action", [createSchema, deleteSchema, listSchema]);
 export const CronCreateTool = {
     name: "CronCreate",
     description: "Create a scheduled recurring task that runs a prompt on an interval.",
     inputSchema: createSchema,
     riskLevel: "medium",
-    isReadOnly() { return false; },
-    isConcurrencySafe() { return true; },
+    isReadOnly() {
+        return false;
+    },
+    isConcurrencySafe() {
+        return true;
+    },
     async call(input) {
         const cron = createCron(input.name, input.schedule, input.prompt);
         return { output: `Created cron '${cron.name}' (${cron.id}) — schedule: ${cron.schedule}`, isError: false };
     },
-    prompt() { return "CronCreate: Schedule a recurring task. Schedules: 'every 5m', 'every 2h', 'every 1d'."; },
+    prompt() {
+        return "CronCreate: Schedule a recurring task. Schedules: 'every 5m', 'every 2h', 'every 1d'.";
+    },
 };
 export const CronDeleteTool = {
     name: "CronDelete",
     description: "Delete a scheduled recurring task.",
     inputSchema: deleteSchema,
     riskLevel: "medium",
-    isReadOnly() { return false; },
-    isConcurrencySafe() { return true; },
+    isReadOnly() {
+        return false;
+    },
+    isConcurrencySafe() {
+        return true;
+    },
     async call(input) {
         const ok = deleteCron(input.id);
         return { output: ok ? `Deleted cron ${input.id}` : `Cron ${input.id} not found`, isError: !ok };
     },
-    prompt() { return "CronDelete: Remove a scheduled task by ID."; },
+    prompt() {
+        return "CronDelete: Remove a scheduled task by ID.";
+    },
 };
 export const CronListTool = {
     name: "CronList",
     description: "List all scheduled recurring tasks.",
     inputSchema: listSchema,
     riskLevel: "low",
-    isReadOnly() { return true; },
-    isConcurrencySafe() { return true; },
+    isReadOnly() {
+        return true;
+    },
+    isConcurrencySafe() {
+        return true;
+    },
     async call() {
         const crons = listCrons();
         if (crons.length === 0)
             return { output: "No scheduled tasks.", isError: false };
-        const lines = crons.map(c => `${c.id}  ${c.name.padEnd(20)}  ${c.schedule.padEnd(12)}  ${c.enabled ? '✓' : '✗'}  runs: ${c.runCount}`);
-        return { output: `Scheduled tasks:\n${lines.join('\n')}`, isError: false };
+        const lines = crons.map((c) => `${c.id}  ${c.name.padEnd(20)}  ${c.schedule.padEnd(12)}  ${c.enabled ? "✓" : "✗"}  runs: ${c.runCount}`);
+        return { output: `Scheduled tasks:\n${lines.join("\n")}`, isError: false };
+    },
+    prompt() {
+        return "CronList: Show all scheduled recurring tasks.";
     },
-    prompt() { return "CronList: Show all scheduled recurring tasks."; },
 };
 //# sourceMappingURL=index.js.map

package/dist/tools/DiagnosticsTool/index.js

@@ -2,7 +2,9 @@ import { z } from "zod";
 import { LspClient } from "../../lsp/client.js";
 const inputSchema = z.object({
     file_path: z.string().describe("Absolute path to the file to check"),
-    action: z.enum(["diagnostics", "definition", "references", "hover"]).default("diagnostics")
+    action: z
+        .enum(["diagnostics", "definition", "references", "hover"])
+        .default("diagnostics")
         .describe("Action: diagnostics (errors/warnings), definition (go-to-def), references (find-refs), hover (type info)"),
     line: z.number().optional().describe("Line number (0-indexed) for definition/references"),
     character: z.number().optional().describe("Column number (0-indexed) for definition/references"),
@@ -10,17 +12,17 @@ const inputSchema = z.object({
 // Singleton LSP client per language server
 const lspClients = new Map();
 function getLspCommand(filePath) {
-    if (filePath.endsWith('.ts') || filePath.endsWith('.tsx') || filePath.endsWith('.js') || filePath.endsWith('.jsx')) {
-        return { command: 'npx', args: ['typescript-language-server', '--stdio'] };
+    if (filePath.endsWith(".ts") || filePath.endsWith(".tsx") || filePath.endsWith(".js") || filePath.endsWith(".jsx")) {
+        return { command: "npx", args: ["typescript-language-server", "--stdio"] };
     }
-    if (filePath.endsWith('.py')) {
-        return { command: 'pylsp', args: [] };
+    if (filePath.endsWith(".py")) {
+        return { command: "pylsp", args: [] };
     }
-    if (filePath.endsWith('.go')) {
-        return { command: 'gopls', args: ['serve'] };
+    if (filePath.endsWith(".go")) {
+        return { command: "gopls", args: ["serve"] };
     }
-    if (filePath.endsWith('.rs')) {
-        return { command: 'rust-analyzer', args: [] };
+    if (filePath.endsWith(".rs")) {
+        return { command: "rust-analyzer", args: [] };
     }
     return null;
 }
@@ -45,8 +47,12 @@ export const DiagnosticsTool = {
     description: "Get code diagnostics (errors, warnings), go-to-definition, or find-references using the language server.",
     inputSchema,
     riskLevel: "low",
-    isReadOnly() { return true; },
-    isConcurrencySafe() { return true; },
+    isReadOnly() {
+        return true;
+    },
+    isConcurrencySafe() {
+        return true;
+    },
     async call(input, context) {
         const client = await getClient(input.file_path, context.workingDir);
         if (!client) {
@@ -62,11 +68,11 @@ export const DiagnosticsTool = {
                 if (diags.length === 0)
                     return { output: "No diagnostics found.", isError: false };
                 const severityMap = { 1: "Error", 2: "Warning", 3: "Info", 4: "Hint" };
-                const lines = diags.map(d => {
+                const lines = diags.map((d) => {
                     const sev = severityMap[d.severity ?? 1] ?? "Unknown";
                     return `${sev} [${d.source ?? ""}] L${d.range.start.line + 1}:${d.range.start.character}: ${d.message}`;
                 });
-                return { output: lines.join('\n'), isError: false };
+                return { output: lines.join("\n"), isError: false };
             }
             if (input.action === "definition") {
                 if (input.line === undefined || input.character === undefined) {
@@ -76,8 +82,8 @@ export const DiagnosticsTool = {
                 const locs = await client.getDefinition(input.file_path, input.line, input.character);
                 if (locs.length === 0)
                     return { output: "No definition found.", isError: false };
-                const lines = locs.map(l => `${l.uri.replace('file://', '')}:${l.range.start.line + 1}:${l.range.start.character}`);
-                return { output: lines.join('\n'), isError: false };
+                const lines = locs.map((l) => `${l.uri.replace("file://", "")}:${l.range.start.line + 1}:${l.range.start.character}`);
+                return { output: lines.join("\n"), isError: false };
             }
             if (input.action === "references") {
                 if (input.line === undefined || input.character === undefined) {
@@ -87,8 +93,8 @@ export const DiagnosticsTool = {
                 const refs = await client.getReferences(input.file_path, input.line, input.character);
                 if (refs.length === 0)
                     return { output: "No references found.", isError: false };
-                const lines = refs.map(r => `${r.uri.replace('file://', '')}:${r.range.start.line + 1}:${r.range.start.character}`);
-                return { output: `${refs.length} reference(s):\n${lines.join('\n')}`, isError: false };
+                const lines = refs.map((r) => `${r.uri.replace("file://", "")}:${r.range.start.line + 1}:${r.range.start.character}`);
+                return { output: `${refs.length} reference(s):\n${lines.join("\n")}`, isError: false };
             }
             if (input.action === "hover") {
                 if (input.line === undefined || input.character === undefined) {
@@ -97,15 +103,15 @@ export const DiagnosticsTool = {
                 await client.openFile(input.file_path);
                 // Hover uses textDocument/hover which returns MarkupContent
                 try {
-                    const result = await client.send('textDocument/hover', {
-                        textDocument: { uri: `file://${input.file_path.replace(/\\/g, '/')}` },
+                    const result = await client.send("textDocument/hover", {
+                        textDocument: { uri: `file://${input.file_path.replace(/\\/g, "/")}` },
                         position: { line: input.line, character: input.character },
                     });
-                    if (!result || !result.contents)
+                    if (!result?.contents)
                         return { output: "No hover information.", isError: false };
-                    const content = typeof result.contents === 'string'
+                    const content = typeof result.contents === "string"
                         ? result.contents
-                        : result.contents.value ?? JSON.stringify(result.contents);
+                        : (result.contents.value ?? JSON.stringify(result.contents));
                     return { output: content, isError: false };
                 }
                 catch {

package/dist/tools/EnterPlanModeTool/index.js

@@ -1,10 +1,90 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
 import { z } from "zod";
-import * as fs from "fs/promises";
-import * as path from "path";
+/**
+ * Generate a memorable plan filename from three random words.
+ * Pattern: adjective-verb-noun (e.g., "twinkling-riding-crown")
+ */
+function generatePlanName() {
+    const adjectives = [
+        "bright",
+        "calm",
+        "dark",
+        "eager",
+        "fast",
+        "gentle",
+        "happy",
+        "keen",
+        "light",
+        "merry",
+        "noble",
+        "plain",
+        "quiet",
+        "rare",
+        "sharp",
+        "tall",
+        "vivid",
+        "warm",
+        "young",
+        "bold",
+        "clean",
+        "deep",
+        "fair",
+        "grand",
+    ];
+    const verbs = [
+        "flying",
+        "riding",
+        "singing",
+        "dancing",
+        "running",
+        "walking",
+        "building",
+        "crafting",
+        "drawing",
+        "growing",
+        "hiding",
+        "jumping",
+        "leading",
+        "making",
+        "passing",
+        "rising",
+        "saving",
+        "taking",
+        "turning",
+        "watching",
+    ];
+    const nouns = [
+        "arrow",
+        "badge",
+        "crown",
+        "dream",
+        "flame",
+        "grove",
+        "heart",
+        "ivory",
+        "jewel",
+        "knot",
+        "latch",
+        "maple",
+        "night",
+        "ocean",
+        "pearl",
+        "quest",
+        "ridge",
+        "stone",
+        "tower",
+        "vault",
+        "whale",
+        "zenith",
+    ];
+    const pick = (arr) => arr[Math.floor(Math.random() * arr.length)];
+    return `${pick(adjectives)}-${pick(verbs)}-${pick(nouns)}`;
+}
 const inputSchema = z.object({});
 export const EnterPlanModeTool = {
     name: "EnterPlanMode",
-    description: "Enter plan mode, creating .oh/plan.md if it does not exist.",
+    description: "Enter plan mode, creating a unique plan file in .oh/plans/.",
     inputSchema,
     riskLevel: "low",
     isReadOnly() {
@@ -14,24 +94,23 @@ export const EnterPlanModeTool = {
         return false;
     },
     async call(_input, context) {
-        const dir = path.join(context.workingDir, ".oh");
-        const filePath = path.join(dir, "plan.md");
+        const plansDir = path.join(context.workingDir, ".oh", "plans");
+        const planName = generatePlanName();
+        const filePath = path.join(plansDir, `${planName}.md`);
         try {
-            await fs.mkdir(dir, { recursive: true });
-            try {
-                await fs.access(filePath);
-            }
-            catch {
-                await fs.writeFile(filePath, "# Plan\n\n", "utf-8");
-            }
-            return { output: "Plan mode entered.", isError: false };
+            await fs.mkdir(plansDir, { recursive: true });
+            await fs.writeFile(filePath, `# Plan\n\n<!-- Write your plan here -->\n`, "utf-8");
+            return {
+                output: `Plan mode entered. Plan file: ${filePath}\nWrite your plan to this file using the Write or Edit tool.`,
+                isError: false,
+            };
         }
         catch (err) {
             return { output: `Error entering plan mode: ${err.message}`, isError: true };
         }
     },
     prompt() {
-        return `Enter plan mode. Creates .oh/plan.md if it does not already exist. No parameters required.`;
+        return `Enter plan mode. Creates a unique plan file at .oh/plans/<name>.md. Write your plan to this file, then call ExitPlanMode when done. No parameters required.`;
     },
 };
 //# sourceMappingURL=index.js.map

package/dist/tools/EnterWorktreeTool/index.js

@@ -8,9 +8,13 @@ export const EnterWorktreeTool = {
     description: "Create an isolated git worktree for safe experimentation. Changes won't affect the main working directory.",
     inputSchema,
     riskLevel: "medium",
-    isReadOnly() { return false; },
-    isConcurrencySafe() { return false; },
-    async call(input, context) {
+    isReadOnly() {
+        return false;
+    },
+    isConcurrencySafe() {
+        return false;
+    },
+    async call(_input, context) {
         if (!isGitRepo(context.workingDir)) {
             return { output: "Not a git repository — worktrees require git.", isError: true };
         }

package/dist/tools/ExitPlanModeTool/index.d.ts

@@ -1,6 +1,27 @@
 import { z } from "zod";
 import type { Tool } from "../../Tool.js";
-declare const inputSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+declare const inputSchema: z.ZodObject<{
+    allowedPrompts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        tool: z.ZodEnum<["Bash"]>;
+        prompt: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        tool: "Bash";
+        prompt: string;
+    }, {
+        tool: "Bash";
+        prompt: string;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    allowedPrompts?: {
+        tool: "Bash";
+        prompt: string;
+    }[] | undefined;
+}, {
+    allowedPrompts?: {
+        tool: "Bash";
+        prompt: string;
+    }[] | undefined;
+}>;
 export declare const ExitPlanModeTool: Tool<typeof inputSchema>;
 export {};
 //# sourceMappingURL=index.d.ts.map

package/dist/tools/ExitPlanModeTool/index.js

@@ -1,8 +1,16 @@
 import { z } from "zod";
-const inputSchema = z.object({});
+const inputSchema = z.object({
+    allowedPrompts: z
+        .array(z.object({
+        tool: z.enum(["Bash"]).describe("The tool this prompt applies to"),
+        prompt: z.string().describe("Semantic description of the action, e.g. 'run tests', 'install dependencies'"),
+    }))
+        .optional()
+        .describe("Prompt-based permissions needed to implement the plan"),
+});
 export const ExitPlanModeTool = {
     name: "ExitPlanMode",
-    description: "Exit plan mode.",
+    description: "Exit plan mode and signal that the plan is ready for user approval.",
     inputSchema,
     riskLevel: "low",
     isReadOnly() {
@@ -11,11 +19,18 @@ export const ExitPlanModeTool = {
     isConcurrencySafe() {
         return false;
     },
-    async call(_input, _context) {
-        return { output: "Plan mode exited.", isError: false };
+    async call(input, _context) {
+        const parts = ["Plan mode exited. Plan is ready for review."];
+        if (input.allowedPrompts?.length) {
+            parts.push("Requested permissions:");
+            for (const p of input.allowedPrompts) {
+                parts.push(`  - ${p.tool}: ${p.prompt}`);
+            }
+        }
+        return { output: parts.join("\n"), isError: false };
     },
     prompt() {
-        return `Exit plan mode. No parameters required.`;
+        return `Exit plan mode and signal that the plan is ready for user approval. Optionally specify allowedPrompts to pre-authorize specific actions (e.g., running tests) during plan execution.`;
     },
 };
 //# sourceMappingURL=index.js.map

package/dist/tools/ExitWorktreeTool/index.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { removeWorktree, hasWorktreeChanges } from "../../git/index.js";
+import { hasWorktreeChanges, removeWorktree } from "../../git/index.js";
 const inputSchema = z.object({
     path: z.string().describe("Path to the worktree to remove"),
     force: z.boolean().optional().describe("Force removal even with uncommitted changes"),
@@ -9,8 +9,12 @@ export const ExitWorktreeTool = {
     description: "Remove a git worktree. Warns if there are uncommitted changes unless force is true.",
     inputSchema,
     riskLevel: "medium",
-    isReadOnly() { return false; },
-    isConcurrencySafe() { return false; },
+    isReadOnly() {
+        return false;
+    },
+    isConcurrencySafe() {
+        return false;
+    },
     async call(input) {
         if (!input.force && hasWorktreeChanges(input.path)) {
             return {
@@ -23,7 +27,10 @@ export const ExitWorktreeTool = {
             return { output: `Worktree removed: ${input.path}`, isError: false };
         }
         catch (err) {
-            return { output: `Failed to remove worktree: ${err instanceof Error ? err.message : String(err)}`, isError: true };
+            return {
+                output: `Failed to remove worktree: ${err instanceof Error ? err.message : String(err)}`,
+                isError: true,
+            };
         }
     },
     prompt() {

package/dist/tools/FileEditTool/index.js

@@ -1,6 +1,6 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
 import { z } from "zod";
-import * as fs from "fs/promises";
-import * as path from "path";
 const inputSchema = z.object({
     file_path: z.string(),
     old_string: z.string(),
@@ -44,9 +44,7 @@ export const FileEditTool = {
                 ? content.split(input.old_string).join(input.new_string)
                 : content.replace(input.old_string, input.new_string);
             await fs.writeFile(filePath, newContent, "utf-8");
-            const occurrences = input.replace_all
-                ? content.split(input.old_string).length - 1
-                : 1;
+            const occurrences = input.replace_all ? content.split(input.old_string).length - 1 : 1;
             return {
                 output: `Edited ${filePath}: replaced ${occurrences} occurrence(s).\n--- old\n${input.old_string}\n+++ new\n${input.new_string}`,
                 isError: false,

package/dist/tools/FileReadTool/index.js

@@ -1,6 +1,6 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
 import { z } from "zod";
-import * as fs from "fs/promises";
-import * as path from "path";
 const inputSchema = z.object({
     file_path: z.string(),
     offset: z.number().optional(),
@@ -16,14 +16,14 @@ function parsePageRange(pages) {
         const trimmed = part.trim();
         if (trimmed.includes("-")) {
             const [start, end] = trimmed.split("-").map(Number);
-            if (!isNaN(start) && !isNaN(end)) {
+            if (!Number.isNaN(start) && !Number.isNaN(end)) {
                 for (let i = start; i <= Math.min(end, start + 19); i++)
                     result.push(i);
             }
         }
         else {
             const n = Number(trimmed);
-            if (!isNaN(n))
+            if (!Number.isNaN(n))
                 result.push(n);
         }
     }
@@ -55,8 +55,13 @@ export const FileReadTool = {
                 const buffer = await fs.readFile(filePath);
                 const base64 = buffer.toString("base64");
                 const mimeTypes = {
-                    ".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg",
-                    ".gif": "image/gif", ".webp": "image/webp", ".bmp": "image/bmp", ".svg": "image/svg+xml",
+                    ".png": "image/png",
+                    ".jpg": "image/jpeg",
+                    ".jpeg": "image/jpeg",
+                    ".gif": "image/gif",
+                    ".webp": "image/webp",
+                    ".bmp": "image/bmp",
+                    ".svg": "image/svg+xml",
                 };
                 return { output: `__IMAGE__:${mimeTypes[ext] ?? "image/png"}:${base64}`, isError: false };
             }
@@ -64,7 +69,10 @@ export const FileReadTool = {
             if (ext === ".pdf") {
                 // Guard against very large PDFs without page filter
                 if (stat.size > 20 * 1024 * 1024 && !input.pages) {
-                    return { output: `PDF is ${(stat.size / 1024 / 1024).toFixed(1)} MB. Provide a 'pages' parameter (e.g., "1-5") to read specific pages.`, isError: true };
+                    return {
+                        output: `PDF is ${(stat.size / 1024 / 1024).toFixed(1)} MB. Provide a 'pages' parameter (e.g., "1-5") to read specific pages.`,
+                        isError: true,
+                    };
                 }
                 const buffer = await fs.readFile(filePath);
                 // Basic PDF text extraction — look for text between BT/ET markers or stream content
@@ -128,9 +136,7 @@ export const FileReadTool = {
             const offset = Math.max(0, (input.offset ?? 1) - 1);
             const limit = input.limit ?? DEFAULT_LIMIT;
             const lines = allLines.slice(offset, offset + limit);
-            const numbered = lines
-                .map((line, i) => `${offset + i + 1}\t${line}`)
-                .join("\n");
+            const numbered = lines.map((line, i) => `${offset + i + 1}\t${line}`).join("\n");
             const total = allLines.length;
             const shown = lines.length;
             let result = numbered;

package/dist/tools/FileWriteTool/index.js

@@ -1,6 +1,6 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
 import { z } from "zod";
-import * as fs from "fs/promises";
-import * as path from "path";
 const inputSchema = z.object({
     file_path: z.string(),
     content: z.string(),

package/dist/tools/GlobTool/index.js

@@ -1,7 +1,7 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
 import { z } from "zod";
-import * as fs from "fs/promises";
-import * as path from "path";
-import { walkDir, matchGlob } from "../../utils/fs.js";
+import { matchGlob, walkDir } from "../../utils/fs.js";
 const inputSchema = z.object({
     pattern: z.string(),
     path: z.string().optional(),
@@ -35,9 +35,7 @@ export const GlobTool = {
                 }
                 matches.sort();
                 return {
-                    output: matches.length
-                        ? matches.join("\n")
-                        : "No files matched the pattern.",
+                    output: matches.length ? matches.join("\n") : "No files matched the pattern.",
                     isError: false,
                 };
             }
@@ -49,9 +47,7 @@ export const GlobTool = {
                 .slice(0, MAX_RESULTS)
                 .sort();
             return {
-                output: matched.length
-                    ? matched.join("\n")
-                    : "No files matched the pattern.",
+                output: matched.length ? matched.join("\n") : "No files matched the pattern.",
                 isError: false,
             };
         }

package/dist/tools/GrepTool/index.d.ts

@@ -20,8 +20,8 @@ declare const inputSchema: z.ZodObject<{
     path?: string | undefined;
     type?: string | undefined;
     glob?: string | undefined;
-    context?: number | undefined;
     offset?: number | undefined;
+    context?: number | undefined;
     output_mode?: "content" | "files_with_matches" | "count" | undefined;
     head_limit?: number | undefined;
     multiline?: boolean | undefined;
@@ -35,8 +35,8 @@ declare const inputSchema: z.ZodObject<{
     path?: string | undefined;
     type?: string | undefined;
     glob?: string | undefined;
-    context?: number | undefined;
     offset?: number | undefined;
+    context?: number | undefined;
     output_mode?: "content" | "files_with_matches" | "count" | undefined;
     head_limit?: number | undefined;
     multiline?: boolean | undefined;