nolo-cli 0.1.23 → 0.1.29

package/agent-runtime/localWorkspaceTools.ts

@@ -9,6 +9,7 @@ import type {
 type LocalWorkspaceToolArgs = {
   workspaceRoot: string;
   commandTimeoutMs?: number;
+  commandPrefix?: string[];
 };
 
 type WorkspaceFileArgs = {
@@ -35,6 +36,7 @@ type WorkspaceFileArgs = {
   expectText?: unknown;
   screenshotPath?: unknown;
   metricsPath?: unknown;
+  shell?: unknown;
 };
 
 type OpenAiCompatibleTool = Record<string, unknown> & {
@@ -49,16 +51,12 @@ const WORKSPACE_TOOL_NAMES = [
   "listFiles",
   "readFile",
   "writeFile",
+  "editFile",
+  "searchFiles",
   "searchWorkspace",
   "applyEdit",
   "applyLineEdits",
   "applyPatch",
-  "gitStatus",
-  "gitDiff",
-  "gitCreateBranch",
-  "gitAdd",
-  "gitCommit",
-  "commitWorkspace",
   "runPackageScript",
   "startPreview",
   "getPreviewStatus",
@@ -66,28 +64,26 @@ const WORKSPACE_TOOL_NAMES = [
   "releasePreview",
   "captureVisualState",
   "execShell",
-  "execBash",
 ] as const;
 
 const DEFAULT_LOCAL_CODING_TOOL_NAMES = [
-  "readWorkspaceFile",
-  "writeWorkspaceFile",
-  "replaceWorkspaceText",
-  "searchWorkspace",
-  "applyPatch",
+  "listFiles",
+  "readFile",
+  "writeFile",
+  "editFile",
+  "searchFiles",
+] as const;
+
+const SHELL_TOOL_NAMES = ["execShell"] as const;
+const WORKSPACE_TOOL_NAME_SET = new Set<string>(WORKSPACE_TOOL_NAMES);
+const REMOVED_WORKSPACE_TOOL_NAMES = new Set([
   "gitStatus",
   "gitDiff",
   "gitCreateBranch",
+  "gitAdd",
+  "gitCommit",
   "commitWorkspace",
-  "runPackageScript",
-  "startPreview",
-  "getPreviewStatus",
-  "stopPreview",
-  "releasePreview",
-  "captureVisualState",
-] as const;
-
-const SHELL_TOOL_NAMES = ["execShell", "execBash"] as const;
+]);
 const DEFAULT_WORKSPACE_COMMAND_TIMEOUT_MS = 120_000;
 
 function buildWorkspacePathProperty() {
@@ -118,7 +114,8 @@ function buildReadWorkspaceFileTool(): OpenAiCompatibleTool {
     type: "function",
     function: {
       name: "readWorkspaceFile",
-      description: "Read a UTF-8 text file inside the workspace.",
+      description:
+        "Read a UTF-8 text file inside the workspace. Read before editing when you need the current content or exact text for replaceWorkspaceText; skip unnecessary reads for trivial known writes.",
       parameters: {
         type: "object",
         properties: {
@@ -135,7 +132,8 @@ function buildWriteWorkspaceFileTool(): OpenAiCompatibleTool {
     type: "function",
     function: {
       name: "writeWorkspaceFile",
-      description: "Write UTF-8 text content to a file inside the workspace.",
+      description:
+        "Write full UTF-8 file content inside the workspace. Prefer replaceWorkspaceText for small edits to existing large files; use this for new files or deliberate whole-file rewrites.",
       parameters: {
         type: "object",
         properties: {
@@ -156,7 +154,8 @@ function buildReplaceWorkspaceTextTool(): OpenAiCompatibleTool {
     type: "function",
     function: {
       name: "replaceWorkspaceText",
-      description: "Replace exact UTF-8 text in one workspace file without constructing a patch.",
+      description:
+        "Use for small, exact edits in one workspace file without constructing a patch. Read the file first when you need the exact oldText; set expectedReplacements to avoid accidental broad edits.",
       parameters: {
         type: "object",
         properties: {
@@ -221,123 +220,6 @@ function buildApplyPatchTool(): OpenAiCompatibleTool {
   };
 }
 
-function buildGitStatusTool(): OpenAiCompatibleTool {
-  return {
-    type: "function",
-    function: {
-      name: "gitStatus",
-      description: "Show concise git status for the workspace.",
-      parameters: { type: "object", properties: {} },
-    },
-  };
-}
-
-function buildGitDiffTool(): OpenAiCompatibleTool {
-  return {
-    type: "function",
-    function: {
-      name: "gitDiff",
-      description: "Show git diff for the workspace.",
-      parameters: {
-        type: "object",
-        properties: {
-          path: buildWorkspacePathProperty(),
-          staged: {
-            type: "boolean",
-            description: "When true, show staged changes.",
-          },
-        },
-      },
-    },
-  };
-}
-
-function buildGitCreateBranchTool(): OpenAiCompatibleTool {
-  return {
-    type: "function",
-    function: {
-      name: "gitCreateBranch",
-      description: "Create and switch to a local git branch in the workspace.",
-      parameters: {
-        type: "object",
-        properties: {
-          branch: {
-            type: "string",
-            description: "Branch name to create and check out.",
-          },
-        },
-        required: ["branch"],
-      },
-    },
-  };
-}
-
-function buildGitAddTool(): OpenAiCompatibleTool {
-  return {
-    type: "function",
-    function: {
-      name: "gitAdd",
-      description: "Stage workspace files for commit.",
-      parameters: {
-        type: "object",
-        properties: {
-          paths: {
-            type: "array",
-            items: { type: "string" },
-            description: "Workspace-relative paths to stage.",
-          },
-        },
-        required: ["paths"],
-      },
-    },
-  };
-}
-
-function buildGitCommitTool(): OpenAiCompatibleTool {
-  return {
-    type: "function",
-    function: {
-      name: "gitCommit",
-      description: "Commit staged workspace changes.",
-      parameters: {
-        type: "object",
-        properties: {
-          message: {
-            type: "string",
-            description: "Commit subject.",
-          },
-        },
-        required: ["message"],
-      },
-    },
-  };
-}
-
-function buildCommitWorkspaceTool(): OpenAiCompatibleTool {
-  return {
-    type: "function",
-    function: {
-      name: "commitWorkspace",
-      description: "Stage selected workspace paths, commit them, and return branch, commit hash, and clean status.",
-      parameters: {
-        type: "object",
-        properties: {
-          paths: {
-            type: "array",
-            items: { type: "string" },
-            description: "Workspace-relative paths to stage before committing.",
-          },
-          message: {
-            type: "string",
-            description: "Commit subject.",
-          },
-        },
-        required: ["paths", "message"],
-      },
-    },
-  };
-}
-
 function buildRunPackageScriptTool(): OpenAiCompatibleTool {
   return {
     type: "function",
@@ -433,7 +315,8 @@ function buildExecShellTool(toolName: string): OpenAiCompatibleTool {
     type: "function",
     function: {
       name: toolName,
-      description: "Run a shell command in the local workspace.",
+      description:
+        "Run a shell command in the local workspace. Commands already execute from the workspace root; do not cd into guessed paths such as /workspace, /repo, /home/user, or /home/user/workspace. Prefer one command that performs a complete verification or related git operation instead of many tiny commands. For branch setup, prefer idempotent commands such as git switch -C <branch> when replacing or recreating a benchmark branch is acceptable. Use portable POSIX commands for macOS/BSD shells; avoid GNU-only flags such as cat -A. Do not use cat -A. Do not use brittle byte-offset commands such as xxd -s -32. For separator lines, use echo or printf '%s\\n'. For text-file content or trailing-newline checks, prefer readFile over shell byte inspection when that tool is available. Do not run repeated git status, git log, git rev-parse, or branch checks after a successful command already returned the needed clean status and commit information; use one final verification command. If a command fails, use the error output to adjust the next command rather than repeating the same shape.",
       parameters: {
         type: "object",
         properties: {
@@ -451,15 +334,68 @@ function buildExecShellTool(toolName: string): OpenAiCompatibleTool {
   };
 }
 
+function wrapPowerShellCommand(command: string) {
+  return [
+    "[Console]::InputEncoding=[System.Text.Encoding]::UTF8",
+    "[Console]::OutputEncoding=[System.Text.Encoding]::UTF8",
+    "$OutputEncoding=[System.Text.Encoding]::UTF8",
+    "$PSStyle.OutputRendering='PlainText'",
+    command,
+  ].join("; ");
+}
+
+function findPowerShellExecutable() {
+  return Bun.which("pwsh") || Bun.which("powershell.exe") || Bun.which("powershell");
+}
+
+function buildPowerShellCommand(command: string) {
+  const executable = findPowerShellExecutable();
+  if (!executable) throw new Error("PowerShell is not available on this machine.");
+  return [
+    executable,
+    "-NoLogo",
+    "-NoProfile",
+    "-NonInteractive",
+    "-ExecutionPolicy",
+    "Bypass",
+    "-Command",
+    wrapPowerShellCommand(command),
+  ];
+}
+
+function buildBashCommand(command: string) {
+  const executable = Bun.which("bash") || Bun.which("sh");
+  if (!executable) throw new Error("bash/sh is not available on this machine.");
+  return [executable, "-lc", command];
+}
+
+function buildWorkspaceShellCommand(args: {
+  toolName: string;
+  command: string;
+  shell?: unknown;
+}) {
+  if (args.shell === "powershell") return buildPowerShellCommand(args.command);
+  if (args.shell === "bash") return buildBashCommand(args.command);
+  return process.platform === "win32"
+    ? buildPowerShellCommand(args.command)
+    : buildBashCommand(args.command);
+}
+
 function renameWorkspaceToolDefinition(
   tool: OpenAiCompatibleTool,
   name: string
 ): OpenAiCompatibleTool {
+  const description = typeof tool.function?.description === "string"
+    ? tool.function.description
+        .replaceAll("replaceWorkspaceText", "editFile")
+        .replaceAll("readWorkspaceFile", "readFile")
+    : tool.function?.description;
   return {
     ...tool,
     function: {
       ...(tool.function ?? {}),
       name,
+      description,
     },
   };
 }
@@ -474,23 +410,24 @@ function buildWorkspaceToolDefinition(toolName: string) {
   if (toolName === "writeWorkspaceFile" || toolName === "writeFile") {
     return renameWorkspaceToolDefinition(buildWriteWorkspaceFileTool(), toolName);
   }
-  if (toolName === "replaceWorkspaceText" || toolName === "applyEdit" || toolName === "applyLineEdits") {
+  if (
+    toolName === "replaceWorkspaceText" ||
+    toolName === "editFile" ||
+    toolName === "applyEdit" ||
+    toolName === "applyLineEdits"
+  ) {
     return renameWorkspaceToolDefinition(buildReplaceWorkspaceTextTool(), toolName);
   }
-  if (toolName === "searchWorkspace") return buildSearchWorkspaceTool();
+  if (toolName === "searchWorkspace" || toolName === "searchFiles") {
+    return renameWorkspaceToolDefinition(buildSearchWorkspaceTool(), toolName);
+  }
   if (toolName === "applyPatch") return buildApplyPatchTool();
-  if (toolName === "gitStatus") return buildGitStatusTool();
-  if (toolName === "gitDiff") return buildGitDiffTool();
-  if (toolName === "gitCreateBranch") return buildGitCreateBranchTool();
-  if (toolName === "gitAdd") return buildGitAddTool();
-  if (toolName === "gitCommit") return buildGitCommitTool();
-  if (toolName === "commitWorkspace") return buildCommitWorkspaceTool();
   if (toolName === "runPackageScript") return buildRunPackageScriptTool();
   if (toolName === "startPreview" || toolName === "getPreviewStatus" || toolName === "stopPreview" || toolName === "releasePreview") {
     return buildPreviewLifecycleTool(toolName);
   }
   if (toolName === "captureVisualState") return buildCaptureVisualStateTool();
-  if (toolName === "execShell" || toolName === "execBash") return buildExecShellTool(toolName);
+  if (toolName === "execShell") return buildExecShellTool(toolName);
   return null;
 }
 
@@ -500,22 +437,40 @@ function removeRedundantWorkspaceToolAliases(toolNames: Set<string>) {
   if (next.has("readWorkspaceFile")) next.delete("readFile");
   if (next.has("writeWorkspaceFile")) next.delete("writeFile");
   if (next.has("replaceWorkspaceText")) {
+    next.delete("editFile");
     next.delete("applyEdit");
     next.delete("applyLineEdits");
   }
+  if (next.has("searchWorkspace")) next.delete("searchFiles");
   return next;
 }
 
+function filterDeclaredWorkspaceToolNames(args: {
+  toolNames?: string[];
+  exposeShellTools: boolean;
+}) {
+  return (args.toolNames ?? []).filter((toolName) =>
+    WORKSPACE_TOOL_NAME_SET.has(toolName) &&
+    !REMOVED_WORKSPACE_TOOL_NAMES.has(toolName) &&
+    (args.exposeShellTools || !SHELL_TOOL_NAMES.includes(toolName as any))
+  );
+}
+
 export function buildLocalWorkspaceToolset(args: {
   declaredToolNames?: string[];
   exposeShellTools?: boolean;
 }) {
   const exposeShellTools = args.exposeShellTools === true;
+  const toolNames = removeRedundantWorkspaceToolAliases(new Set([
+    ...DEFAULT_LOCAL_CODING_TOOL_NAMES,
+    ...(exposeShellTools ? SHELL_TOOL_NAMES : []),
+    ...filterDeclaredWorkspaceToolNames({
+      toolNames: args.declaredToolNames,
+      exposeShellTools,
+    }),
+  ]));
   return {
-    toolNames: [
-      ...DEFAULT_LOCAL_CODING_TOOL_NAMES,
-      ...(exposeShellTools ? SHELL_TOOL_NAMES : []),
-    ],
+    toolNames: [...toolNames],
     exposeShellTools,
   };
 }
@@ -525,9 +480,14 @@ export function buildLocalWorkspacePolicyToolNames(args: {
   exposeShellTools?: boolean;
 }) {
   return [...new Set([
-    ...buildLocalWorkspaceToolset(args).toolNames,
-    ...(args.declaredToolNames ?? []),
-  ])];
+    ...buildLocalWorkspaceToolset({
+      exposeShellTools: args.exposeShellTools,
+    }).toolNames,
+    ...filterDeclaredWorkspaceToolNames({
+      toolNames: args.declaredToolNames,
+      exposeShellTools: args.exposeShellTools === true,
+    }),
+  ])].filter((toolName) => !REMOVED_WORKSPACE_TOOL_NAMES.has(toolName));
 }
 
 export function buildLocalWorkspaceOpenAiTools(args: {
@@ -538,7 +498,7 @@ export function buildLocalWorkspaceOpenAiTools(args: {
   return WORKSPACE_TOOL_NAMES
     .filter((toolName) => {
       if (!declaredTools.has(toolName)) return false;
-      if (!args.exposeShellTools && (toolName === "execShell" || toolName === "execBash")) {
+      if (!args.exposeShellTools && toolName === "execShell") {
         return false;
       }
       return true;
@@ -653,26 +613,6 @@ function requireVisualWaitSelector(args: WorkspaceFileArgs) {
   return selector;
 }
 
-function requireGitBranchName(args: WorkspaceFileArgs) {
-  const branch = typeof args.branch === "string" ? args.branch.trim() : "";
-  if (!branch) throw new Error("gitCreateBranch requires a non-empty branch.");
-  return branch;
-}
-
-function requireGitCommitMessage(args: WorkspaceFileArgs) {
-  const message = typeof args.message === "string" ? args.message.trim() : "";
-  if (!message) throw new Error("gitCommit requires a non-empty message.");
-  return message;
-}
-
-function readGitAddPaths(args: WorkspaceFileArgs) {
-  const paths = Array.isArray(args.paths)
-    ? args.paths.map((value) => String(value).trim()).filter(Boolean)
-    : [];
-  if (paths.length === 0) throw new Error("gitAdd requires at least one path.");
-  return paths;
-}
-
 function readPackageScriptArgs(args: WorkspaceFileArgs) {
   return Array.isArray(args.args)
     ? args.args.map((value) => String(value)).filter(Boolean)
@@ -769,10 +709,15 @@ async function runWorkspaceCommand(args: {
   command: string[];
   stdin?: string;
   timeoutMs?: number;
+  commandPrefix?: string[];
 }) {
   const timeoutMs = args.timeoutMs ?? DEFAULT_WORKSPACE_COMMAND_TIMEOUT_MS;
   const detached = process.platform !== "win32";
-  const proc = Bun.spawn(args.command, {
+  const command = [
+    ...(args.commandPrefix ?? []),
+    ...args.command,
+  ];
+  const proc = Bun.spawn(command, {
     cwd: resolve(args.workspaceRoot),
     stdout: "pipe",
     stderr: "pipe",
@@ -1050,7 +995,7 @@ async function applyPatchTool(args: {
     throw new Error(
       [
         "applyPatch failed during git apply --check.",
-        "Use replaceWorkspaceText/applyEdit for exact single-file edits when possible.",
+        "Use editFile/applyEdit for exact single-file edits when possible.",
         checkResult.content,
       ].join("\n\n")
     );
@@ -1067,172 +1012,6 @@ async function applyPatchTool(args: {
   };
 }
 
-async function gitStatusTool(args: {
-  workspaceRoot: string;
-}): Promise<AgentRuntimeToolResult> {
-  const result = await runWorkspaceCommand({
-    workspaceRoot: args.workspaceRoot,
-    command: ["git", "status", "--short"],
-  });
-  return {
-    content: result.content,
-    metadata: { exitCode: result.exitCode },
-  };
-}
-
-async function gitDiffTool(args: {
-  call: AgentRuntimeToolCallInput;
-  workspaceRoot: string;
-}): Promise<AgentRuntimeToolResult> {
-  const parsed = parseWorkspaceToolArguments(args.call.arguments);
-  const command = ["git", "diff"];
-  const staged = parsed.staged === true;
-  if (staged) command.push("--staged");
-  if (typeof parsed.path === "string" && parsed.path.trim()) {
-    const absolutePath = resolveLocalWorkspaceToolPath({
-      workspaceRoot: args.workspaceRoot,
-      requestedPath: parsed.path.trim(),
-    });
-    command.push("--", normalizeWorkspaceRelativePath({
-      workspaceRoot: resolve(args.workspaceRoot),
-      targetPath: absolutePath,
-    }));
-  }
-  const result = await runWorkspaceCommand({
-    workspaceRoot: args.workspaceRoot,
-    command,
-  });
-  return {
-    content: result.content,
-    metadata: { staged, exitCode: result.exitCode },
-  };
-}
-
-async function gitCreateBranchTool(args: {
-  call: AgentRuntimeToolCallInput;
-  workspaceRoot: string;
-}): Promise<AgentRuntimeToolResult> {
-  const parsed = parseWorkspaceToolArguments(args.call.arguments);
-  const branch = requireGitBranchName(parsed);
-  const result = await runWorkspaceCommand({
-    workspaceRoot: args.workspaceRoot,
-    command: ["git", "switch", "-c", branch],
-  });
-  if (result.exitCode !== 0) throw new Error(result.content);
-  return {
-    content: result.content,
-    metadata: { branch, exitCode: result.exitCode },
-  };
-}
-
-async function gitAddTool(args: {
-  call: AgentRuntimeToolCallInput;
-  workspaceRoot: string;
-}): Promise<AgentRuntimeToolResult> {
-  const parsed = parseWorkspaceToolArguments(args.call.arguments);
-  const paths = readGitAddPaths(parsed).map((requestedPath) => {
-    const absolutePath = resolveLocalWorkspaceToolPath({
-      workspaceRoot: args.workspaceRoot,
-      requestedPath,
-    });
-    return normalizeWorkspaceRelativePath({
-      workspaceRoot: resolve(args.workspaceRoot),
-      targetPath: absolutePath,
-    });
-  });
-  const result = await runWorkspaceCommand({
-    workspaceRoot: args.workspaceRoot,
-    command: ["git", "add", "--", ...paths],
-  });
-  if (result.exitCode !== 0) throw new Error(result.content);
-  return {
-    content: result.content,
-    metadata: { paths, exitCode: result.exitCode },
-  };
-}
-
-async function gitCommitTool(args: {
-  call: AgentRuntimeToolCallInput;
-  workspaceRoot: string;
-}): Promise<AgentRuntimeToolResult> {
-  const parsed = parseWorkspaceToolArguments(args.call.arguments);
-  const message = requireGitCommitMessage(parsed);
-  const result = await runWorkspaceCommand({
-    workspaceRoot: args.workspaceRoot,
-    command: ["git", "commit", "-m", message],
-  });
-  if (result.exitCode !== 0) throw new Error(result.content);
-  return {
-    content: result.content,
-    metadata: { exitCode: result.exitCode },
-  };
-}
-
-async function commitWorkspaceTool(args: {
-  call: AgentRuntimeToolCallInput;
-  workspaceRoot: string;
-}): Promise<AgentRuntimeToolResult> {
-  const parsed = parseWorkspaceToolArguments(args.call.arguments);
-  const paths = readGitAddPaths(parsed).map((requestedPath) => {
-    const absolutePath = resolveLocalWorkspaceToolPath({
-      workspaceRoot: args.workspaceRoot,
-      requestedPath,
-    });
-    return normalizeWorkspaceRelativePath({
-      workspaceRoot: resolve(args.workspaceRoot),
-      targetPath: absolutePath,
-    });
-  });
-  const message = requireGitCommitMessage(parsed);
-  const addResult = await runWorkspaceCommand({
-    workspaceRoot: args.workspaceRoot,
-    command: ["git", "add", "--", ...paths],
-  });
-  if (addResult.exitCode !== 0) throw new Error(addResult.content);
-
-  const commitResult = await runWorkspaceCommand({
-    workspaceRoot: args.workspaceRoot,
-    command: ["git", "commit", "-m", message],
-  });
-  if (commitResult.exitCode !== 0) throw new Error(commitResult.content);
-
-  const [branchResult, hashResult, statusResult] = await Promise.all([
-    runWorkspaceCommand({
-      workspaceRoot: args.workspaceRoot,
-      command: ["git", "branch", "--show-current"],
-    }),
-    runWorkspaceCommand({
-      workspaceRoot: args.workspaceRoot,
-      command: ["git", "rev-parse", "HEAD"],
-    }),
-    runWorkspaceCommand({
-      workspaceRoot: args.workspaceRoot,
-      command: ["git", "status", "--short"],
-    }),
-  ]);
-  const branch = branchResult.stdout.trim();
-  const commitHash = hashResult.stdout.trim();
-  const status = statusResult.stdout.trim();
-  return {
-    content: [
-      `branch: ${branch}`,
-      `commit: ${commitHash}`,
-      `status: ${status || "clean"}`,
-      "",
-      commitResult.content,
-    ].join("\n"),
-    metadata: {
-      paths,
-      message,
-      branch,
-      commitHash,
-      status,
-      clean: status === "",
-      exitCode: commitResult.exitCode,
-    },
-  };
-}
-
 async function runPackageScriptTool(args: {
   call: AgentRuntimeToolCallInput;
   workspaceRoot: string;
@@ -1401,13 +1180,19 @@ async function execShellTool(args: {
   call: AgentRuntimeToolCallInput;
   workspaceRoot: string;
   commandTimeoutMs?: number;
+  commandPrefix?: string[];
 }): Promise<AgentRuntimeToolResult> {
   const parsed = parseWorkspaceToolArguments(args.call.arguments);
   const command = requireShellCommand(parsed, args.call.name);
   const result = await runWorkspaceCommand({
     workspaceRoot: args.workspaceRoot,
-    command: ["/bin/sh", "-lc", command],
+    command: buildWorkspaceShellCommand({
+      toolName: args.call.name,
+      command,
+      shell: parsed.shell,
+    }),
     timeoutMs: args.commandTimeoutMs,
+    commandPrefix: args.commandPrefix,
   });
   return {
     content: result.content,
@@ -1433,6 +1218,10 @@ export function createLocalWorkspaceToolExecutors(args: LocalWorkspaceToolArgs)
       call,
       workspaceRoot: args.workspaceRoot,
     }),
+    editFile: (call: AgentRuntimeToolCallInput) => replaceWorkspaceTextTool({
+      call,
+      workspaceRoot: args.workspaceRoot,
+    }),
     applyEdit: (call: AgentRuntimeToolCallInput) => replaceWorkspaceTextTool({
       call,
       workspaceRoot: args.workspaceRoot,
@@ -1457,30 +1246,11 @@ export function createLocalWorkspaceToolExecutors(args: LocalWorkspaceToolArgs)
       call,
       workspaceRoot: args.workspaceRoot,
     }),
-    applyPatch: (call: AgentRuntimeToolCallInput) => applyPatchTool({
+    searchFiles: (call: AgentRuntimeToolCallInput) => searchWorkspaceTool({
       call,
       workspaceRoot: args.workspaceRoot,
     }),
-    gitStatus: () => gitStatusTool({
-      workspaceRoot: args.workspaceRoot,
-    }),
-    gitDiff: (call: AgentRuntimeToolCallInput) => gitDiffTool({
-      call,
-      workspaceRoot: args.workspaceRoot,
-    }),
-    gitCreateBranch: (call: AgentRuntimeToolCallInput) => gitCreateBranchTool({
-      call,
-      workspaceRoot: args.workspaceRoot,
-    }),
-    gitAdd: (call: AgentRuntimeToolCallInput) => gitAddTool({
-      call,
-      workspaceRoot: args.workspaceRoot,
-    }),
-    gitCommit: (call: AgentRuntimeToolCallInput) => gitCommitTool({
-      call,
-      workspaceRoot: args.workspaceRoot,
-    }),
-    commitWorkspace: (call: AgentRuntimeToolCallInput) => commitWorkspaceTool({
+    applyPatch: (call: AgentRuntimeToolCallInput) => applyPatchTool({
       call,
       workspaceRoot: args.workspaceRoot,
     }),
@@ -1522,11 +1292,7 @@ export function createLocalWorkspaceToolExecutors(args: LocalWorkspaceToolArgs)
       call,
       workspaceRoot: args.workspaceRoot,
       commandTimeoutMs: args.commandTimeoutMs,
-    }),
-    execBash: (call: AgentRuntimeToolCallInput) => execShellTool({
-      call,
-      workspaceRoot: args.workspaceRoot,
-      commandTimeoutMs: args.commandTimeoutMs,
+      commandPrefix: args.commandPrefix,
     }),
   };
 }