ai-code-agents 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,13 +1,9 @@
 // src/environments/docker-environment.ts
 import { exec } from "child_process";
-
-// src/util/escape-command-arg.ts
-function escapeCommandArg(arg) {
-  if ("" === arg) {
-    return "''";
-  }
-  return `'${arg.replace(/'/g, "'\\''")}'`;
-}
+import {
+  UnixEnvironmentBase,
+  escapeCommandArg
+} from "@ai-code-agents/environment-utils";
 
 // src/util/escape-command.ts
 function escapeCommand(command) {
@@ -15,278 +11,6 @@ function escapeCommand(command) {
   return `"${escaped}"`;
 }
 
-// src/util/validate-relative-path.ts
-import * as path from "path";
-function validateRelativePath(filePath) {
-  if (path.isAbsolute(filePath)) {
-    throw new Error("Absolute paths are not allowed.");
-  }
-  if (filePath.startsWith("~")) {
-    throw new Error('Paths starting with "~" are not allowed.');
-  }
-  if (filePath.includes("\0")) {
-    throw new Error("Paths must not contain null bytes.");
-  }
-  const normalizedPath = path.normalize(filePath);
-  if (normalizedPath.startsWith("..")) {
-    throw new Error("Path traversal is not allowed.");
-  }
-}
-
-// src/environments/filesystem-environment-base.ts
-var FilesystemEnvironmentBase = class {
-  _envConfig;
-  /**
-   * Constructs a new environment instance.
-   *
-   * @param config - Environment configuration.
-   */
-  constructor(config) {
-    this._envConfig = config;
-  }
-  /**
-   * Reads the content of a file at the specified path.
-   *
-   * @param path - The path to the file to read, relative to the project directory.
-   * @returns A promise that resolves to a ReadFileResult.
-   */
-  async readFile(path5) {
-    validateRelativePath(path5);
-    if (!await this.fileExists(path5)) {
-      throw new Error(`File not found: ${path5}`);
-    }
-    const content = await this.readFileContent(path5);
-    return {
-      path: path5,
-      content
-    };
-  }
-  /**
-   * Writes content to a file at the specified path.
-   *
-   * If a file is already present at the path, it will be overwritten.
-   *
-   * @param path - The path to the file to write, relative to the project directory.
-   * @param content - The content to write to the file.
-   * @returns A promise that resolves to a WriteFileResult.
-   */
-  async writeFile(path5, content) {
-    validateRelativePath(path5);
-    await this.writeFileContent(path5, content);
-    return {
-      path: path5,
-      message: "File written successfully."
-    };
-  }
-  /**
-   * Deletes a file at the specified path.
-   *
-   * @param path - The path to the file to delete, relative to the project directory.
-   * @returns A promise that resolves to a DeleteFileResult.
-   */
-  async deleteFile(path5) {
-    validateRelativePath(path5);
-    if (!await this.fileExists(path5)) {
-      return {
-        path: path5,
-        message: "File was already deleted."
-      };
-    }
-    await this.deleteFileContent(path5);
-    return {
-      path: path5,
-      message: "File deleted successfully."
-    };
-  }
-  /**
-   * Moves a file from a source path to a destination path.
-   *
-   * If a file is already present at the destination path, it will be overwritten.
-   *
-   * @param sourcePath - The path to the file to move.
-   * @param destinationPath - The path to move the file to.
-   * @returns A promise that resolves to a MoveFileResult.
-   */
-  async moveFile(sourcePath, destinationPath) {
-    validateRelativePath(sourcePath);
-    validateRelativePath(destinationPath);
-    if (!await this.fileExists(sourcePath)) {
-      throw new Error(`File not found: ${sourcePath}`);
-    }
-    await this.moveFileContent(sourcePath, destinationPath);
-    return {
-      sourcePath,
-      destinationPath,
-      message: "File moved successfully."
-    };
-  }
-  /**
-   * Copies a file from a source path to a destination path.
-   *
-   * If a file is already present at the destination path, it will be overwritten.
-   *
-   * @param sourcePath - The path to the file to copy.
-   * @param destinationPath - The path to copy the file to.
-   * @returns A promise that resolves to a CopyFileResult.
-   */
-  async copyFile(sourcePath, destinationPath) {
-    validateRelativePath(sourcePath);
-    validateRelativePath(destinationPath);
-    if (!await this.fileExists(sourcePath)) {
-      throw new Error(`File not found: ${sourcePath}`);
-    }
-    await this.copyFileContent(sourcePath, destinationPath);
-    return {
-      sourcePath,
-      destinationPath,
-      message: "File copied successfully."
-    };
-  }
-  /**
-   * Moves the content of a file from a source path to a destination path, relative to the project directory.
-   *
-   * When this method is called, it is guaranteed that the source file exists.
-   * This method unconditionally moves the content, even if a file already exists at the destination path.
-   *
-   * @param relativeSourcePath - The path to the file to move, relative to the project directory.
-   * @param relativeDestinationPath - The path to move the file to, relative to the project directory.
-   */
-  async moveFileContent(relativeSourcePath, relativeDestinationPath) {
-    const content = await this.readFileContent(relativeSourcePath);
-    this.writeFileContent(relativeDestinationPath, content);
-    this.deleteFileContent(relativeSourcePath);
-  }
-  /**
-   * Copies the content of a file from a source path to a destination path, relative to the project directory.
-   *
-   * When this method is called, it is guaranteed that the source file exists.
-   * This method unconditionally copies the content, even if a file already exists at the destination path.
-   *
-   * @param relativeSourcePath - The path to the file to copy, relative to the project directory.
-   * @param relativeDestinationPath - The path to copy the file to, relative to the project directory.
-   */
-  async copyFileContent(relativeSourcePath, relativeDestinationPath) {
-    const content = await this.readFileContent(relativeSourcePath);
-    this.writeFileContent(relativeDestinationPath, content);
-  }
-};
-
-// src/environments/command-line-environment-base.ts
-var CommandLineEnvironmentBase = class extends FilesystemEnvironmentBase {
-  /**
-   * Runs a CLI command in environment.
-   *
-   * @param command - The command to run.
-   * @returns A promise that resolves to a RunCommandResult.
-   */
-  async runCommand(command) {
-    const [exitCode, stdout, stderr] = await this.executeCommand(command);
-    return {
-      command,
-      exitCode,
-      stdout,
-      stderr
-    };
-  }
-};
-
-// src/environments/unix-environment-base.ts
-var UnixEnvironmentBase = class extends CommandLineEnvironmentBase {
-  /**
-   * Checks whether a file exists at the specified path relative to the project directory.
-   *
-   * @param relativePath - The path to the file to check, relative to the project directory.
-   * @returns True if the file exists, false otherwise.
-   */
-  async fileExists(relativePath) {
-    const command = `if [ -e ${escapeCommandArg(relativePath)} ]; then echo "yes"; else echo "no"; fi`;
-    const { exitCode, stdout } = await this.runCommand(command);
-    return exitCode === 0 && stdout.trim() === "yes";
-  }
-  /**
-   * Gets the content of a file at the specified path, relative to the project directory.
-   *
-   * When this method is called, it is guaranteed that the file exists.
-   *
-   * @param relativePath - The path to the file to read, relative to the project directory.
-   * @returns The content of the file.
-   */
-  async readFileContent(relativePath) {
-    const command = `cat ${escapeCommandArg(relativePath)}`;
-    const { exitCode, stdout } = await this.runCommand(command);
-    return exitCode === 0 ? stdout : "";
-  }
-  /**
-   * Writes content to a file at the specified path, relative to the project directory.
-   *
-   * This method unconditionally writes the content, even if a file already exists at the path, or if the file is new.
-   *
-   * @param relativePath - The path to the file to write, relative to the project directory.
-   * @param content - The content to write to the file.
-   */
-  async writeFileContent(relativePath, content) {
-    const command = `sh -c "echo ${escapeCommandArg(
-      content
-    )} > ${escapeCommandArg(relativePath)}"`;
-    const { exitCode, stderr } = await this.runCommand(command);
-    if (exitCode !== 0) {
-      throw new Error(`Failed to write file: ${stderr || "Unknown error"}`);
-    }
-  }
-  /**
-   * Deletes a file at the specified path, relative to the project directory.
-   *
-   * When this method is called, it is guaranteed that the file exists.
-   *
-   * @param relativePath - The path to the file to delete, relative to the project directory.
-   */
-  async deleteFileContent(relativePath) {
-    const command = `rm ${escapeCommandArg(relativePath)}`;
-    const { exitCode, stderr } = await this.runCommand(command);
-    if (exitCode !== 0) {
-      throw new Error(`Failed to delete file: ${stderr || "Unknown error"}`);
-    }
-  }
-  /**
-   * Moves the content of a file from a source path to a destination path, relative to the project directory.
-   *
-   * When this method is called, it is guaranteed that the source file exists.
-   * This method unconditionally moves the content, even if a file already exists at the destination path.
-   *
-   * @param relativeSourcePath - The path to the file to move, relative to the project directory.
-   * @param relativeDestinationPath - The path to move the file to, relative to the project directory.
-   */
-  async moveFileContent(relativeSourcePath, relativeDestinationPath) {
-    const command = `mv ${escapeCommandArg(relativeSourcePath)} ${escapeCommandArg(
-      relativeDestinationPath
-    )}`;
-    const { exitCode, stderr } = await this.runCommand(command);
-    if (exitCode !== 0) {
-      throw new Error(`Failed to move file: ${stderr || "Unknown error"}`);
-    }
-  }
-  /**
-   * Copies the content of a file from a source path to a destination path, relative to the project directory.
-   *
-   * When this method is called, it is guaranteed that the source file exists.
-   * This method unconditionally copies the content, even if a file already exists at the destination path.
-   *
-   * @param relativeSourcePath - The path to the file to copy, relative to the project directory.
-   * @param relativeDestinationPath - The path to copy the file to, relative to the project directory.
-   */
-  async copyFileContent(relativeSourcePath, relativeDestinationPath) {
-    const command = `cp ${escapeCommandArg(relativeSourcePath)} ${escapeCommandArg(
-      relativeDestinationPath
-    )}`;
-    const result = await this.runCommand(command);
-    if (result.exitCode !== 0) {
-      throw new Error(
-        `Failed to copy file: ${result.stderr || "Unknown error"}`
-      );
-    }
-  }
-};
-
 // src/environments/docker-environment.ts
 var DockerEnvironmentName = "docker";
 var DockerEnvironment = class extends UnixEnvironmentBase {
@@ -329,7 +53,8 @@ var DockerEnvironment = class extends UnixEnvironmentBase {
 };
 
 // src/environments/mock-filesystem-environment.ts
-import path2 from "path";
+import path from "path";
+import { FilesystemEnvironmentBase } from "@ai-code-agents/environment-utils";
 var MockFilesystemEnvironmentName = "mock-filesystem";
 var MockFilesystemEnvironment = class extends FilesystemEnvironmentBase {
   files;
@@ -342,8 +67,8 @@ var MockFilesystemEnvironment = class extends FilesystemEnvironmentBase {
   constructor(config = {}) {
     super(config);
     const { initialFiles, directoryPath } = this._envConfig;
-    this.files = initialFiles ?? /* @__PURE__ */ new Map();
-    this._preparePath = directoryPath ? (filePath) => path2.join(directoryPath, filePath) : (filePath) => filePath;
+    this.files = initialFiles ? new Map(Object.entries(initialFiles)) : /* @__PURE__ */ new Map();
+    this._preparePath = directoryPath ? (filePath) => path.join(directoryPath, filePath) : (filePath) => filePath;
   }
   /**
    * Gets the environment name.
@@ -396,9 +121,10 @@ var MockFilesystemEnvironment = class extends FilesystemEnvironmentBase {
 
 // src/environments/node-filesystem-environment.ts
 import fs from "fs/promises";
-import path3 from "path";
+import path2 from "path";
+import { FilesystemEnvironmentBase as FilesystemEnvironmentBase2 } from "@ai-code-agents/environment-utils";
 var NodeFilesystemEnvironmentName = "node-filesystem";
-var NodeFilesystemEnvironment = class extends FilesystemEnvironmentBase {
+var NodeFilesystemEnvironment = class extends FilesystemEnvironmentBase2 {
   /**
    * Constructs a new NodeFilesystemEnvironment instance.
    *
@@ -425,7 +151,7 @@ var NodeFilesystemEnvironment = class extends FilesystemEnvironmentBase {
    * @returns True if the file exists, false otherwise.
    */
   async fileExists(relativePath) {
-    const absolutePath = path3.join(this._envConfig.directoryPath, relativePath);
+    const absolutePath = path2.join(this._envConfig.directoryPath, relativePath);
     try {
       await fs.stat(absolutePath);
       return true;
@@ -442,7 +168,7 @@ var NodeFilesystemEnvironment = class extends FilesystemEnvironmentBase {
    * @returns The content of the file.
    */
   async readFileContent(relativePath) {
-    const absolutePath = path3.join(this._envConfig.directoryPath, relativePath);
+    const absolutePath = path2.join(this._envConfig.directoryPath, relativePath);
     return fs.readFile(absolutePath, "utf-8");
   }
   /**
@@ -454,7 +180,7 @@ var NodeFilesystemEnvironment = class extends FilesystemEnvironmentBase {
    * @param content - The content to write to the file.
    */
   async writeFileContent(relativePath, content) {
-    const absolutePath = path3.join(this._envConfig.directoryPath, relativePath);
+    const absolutePath = path2.join(this._envConfig.directoryPath, relativePath);
     await fs.writeFile(absolutePath, content, "utf-8");
   }
   /**
@@ -465,7 +191,7 @@ var NodeFilesystemEnvironment = class extends FilesystemEnvironmentBase {
    * @param relativePath - The path to the file to delete, relative to the project directory.
    */
   async deleteFileContent(relativePath) {
-    const absolutePath = path3.join(this._envConfig.directoryPath, relativePath);
+    const absolutePath = path2.join(this._envConfig.directoryPath, relativePath);
     await fs.rm(absolutePath);
   }
   /**
@@ -478,11 +204,11 @@ var NodeFilesystemEnvironment = class extends FilesystemEnvironmentBase {
    * @param relativeDestinationPath - The path to move the file to, relative to the project directory.
    */
   async moveFileContent(relativeSourcePath, relativeDestinationPath) {
-    const sourcePath = path3.join(
+    const sourcePath = path2.join(
       this._envConfig.directoryPath,
       relativeSourcePath
     );
-    const destinationPath = path3.join(
+    const destinationPath = path2.join(
       this._envConfig.directoryPath,
       relativeDestinationPath
     );
@@ -492,8 +218,12 @@ var NodeFilesystemEnvironment = class extends FilesystemEnvironmentBase {
 
 // src/environments/unsafe-local-environment.ts
 import { exec as exec2 } from "child_process";
+import {
+  UnixEnvironmentBase as UnixEnvironmentBase2,
+  escapeCommandArg as escapeCommandArg2
+} from "@ai-code-agents/environment-utils";
 var UnsafeLocalEnvironmentName = "unsafe-local";
-var UnsafeLocalEnvironment = class extends UnixEnvironmentBase {
+var UnsafeLocalEnvironment = class extends UnixEnvironmentBase2 {
   _commandPrefix;
   /**
    * Constructs a new environment instance.
@@ -509,7 +239,7 @@ var UnsafeLocalEnvironment = class extends UnixEnvironmentBase {
       throw new Error('The directory path must be absolute (start with "/")');
     }
     super(config);
-    this._commandPrefix = `cd ${escapeCommandArg(directoryPath)} && `;
+    this._commandPrefix = `cd ${escapeCommandArg2(directoryPath)} && `;
   }
   /**
    * Gets the environment name.
@@ -536,180 +266,17 @@ var UnsafeLocalEnvironment = class extends UnixEnvironmentBase {
 };
 
 // src/tools/copy-file-tool.ts
-import { z as z2 } from "zod";
-
-// src/types.ts
-import * as z from "zod";
-var ReadFileResult = z.object({
-  path: z.string().meta({
-    description: "The path to the file that was read."
-  }),
-  content: z.string().meta({
-    description: "The content of the file that was read."
-  })
-});
-var WriteFileResult = z.object({
-  path: z.string().meta({
-    description: "The path to the file that was written."
-  }),
-  message: z.string().meta({
-    description: "A message indicating the result of the write operation."
-  })
-});
-var DeleteFileResult = z.object({
-  path: z.string().meta({
-    description: "The path to the file that was deleted."
-  }),
-  message: z.string().meta({
-    description: "A message indicating the result of the delete operation."
-  })
-});
-var MoveFileResult = z.object({
-  sourcePath: z.string().meta({
-    description: "The original path of the file that was moved."
-  }),
-  destinationPath: z.string().meta({
-    description: "The new path of the file that was moved to."
-  }),
-  message: z.string().meta({
-    description: "A message indicating the result of the move operation."
-  })
-});
-var CopyFileResult = z.object({
-  sourcePath: z.string().meta({
-    description: "The original path of the file that was copied."
-  }),
-  destinationPath: z.string().meta({
-    description: "The new path of the file that was copied to."
-  }),
-  message: z.string().meta({
-    description: "A message indicating the result of the copy operation."
-  })
-});
-var RunCommandResult = z.object({
-  command: z.string().meta({
-    description: "The command that was executed."
-  }),
-  exitCode: z.number().meta({
-    description: "The exit code of the command."
-  }),
-  stdout: z.string().meta({
-    description: "The standard output of the command."
-  }),
-  stderr: z.string().meta({
-    description: "The standard error output of the command."
-  })
-});
-
-// src/tools/tool-base.ts
-var ToolBase = class {
-  _toolConfig;
-  _name;
-  _description;
-  _inputSchema;
-  _outputSchema;
-  _needsApproval;
-  /**
-   * Constructs a new tool instance.
-   *
-   * @param toolConfig - Optional tool config, can be used to override some defaults.
-   */
-  constructor(toolConfig) {
-    const {
-      name: defaultName,
-      description: defaultDescription,
-      inputSchema,
-      outputSchema,
-      needsApproval: defaultNeedsApproval
-    } = this.getMetadata();
-    this._name = toolConfig?.name || defaultName;
-    this._description = toolConfig?.description || defaultDescription;
-    this._inputSchema = inputSchema;
-    this._outputSchema = outputSchema;
-    this._needsApproval = toolConfig?.needsApproval !== void 0 ? toolConfig.needsApproval : defaultNeedsApproval;
-  }
-  /**
-   * Gets the tool name.
-   *
-   * @returns The tool name.
-   */
-  get name() {
-    return this._name;
-  }
-  /**
-   * Gets the tool description.
-   *
-   * @returns The tool description.
-   */
-  get description() {
-    return this._description;
-  }
-  /**
-   * Gets the input schema for the tool.
-   *
-   * @returns The input schema.
-   */
-  get inputSchema() {
-    return this._inputSchema;
-  }
-  /**
-   * Gets the input schema for the tool.
-   *
-   * @returns The input schema.
-   */
-  get outputSchema() {
-    return this._outputSchema;
-  }
-  /**
-   * Gets whether the tool needs approval before use.
-   *
-   * @returns True if the tool needs approval, false otherwise.
-   */
-  get needsApproval() {
-    return this._needsApproval;
-  }
-};
-
-// src/tools/environment-tool-base.ts
-var EnvironmentToolBase = class extends ToolBase {
-  _environment;
-  /**
-   * Constructs a new `EnvironmentToolBase` instance.
-   *
-   * @param environment - The execution environment to apply the tool in.
-   * @param toolConfig - Optional tool config, can be used to override some defaults.
-   */
-  constructor(environment, toolConfig) {
-    super(toolConfig);
-    this._environment = environment;
-  }
-  /**
-   * Gets the current execution environment for the tool.
-   *
-   * @returns The current execution environment.
-   */
-  get environment() {
-    return this._environment;
-  }
-  /**
-   * Executes the tool with the given input.
-   *
-   * @param input - The input for the tool.
-   * @param _options - Options from the tool call.
-   * @returns A promise that resolves to the tool execution result.
-   */
-  execute(input, _options) {
-    return this.executeForEnvironment(this._environment, input);
-  }
-};
-
-// src/tools/copy-file-tool.ts
+import { z } from "zod";
+import {
+  EnvironmentToolBase,
+  CopyFileResult
+} from "@ai-code-agents/environment-utils";
 var CopyFileToolName = "copy_file";
-var CopyFileToolInput = z2.object({
-  sourcePath: z2.string().meta({
+var CopyFileToolInput = z.object({
+  sourcePath: z.string().meta({
     description: "The path to the file to copy, relative to the project directory."
   }),
-  destinationPath: z2.string().meta({
+  destinationPath: z.string().meta({
     description: "The path to the destination where the file should be copied, relative to the project directory. If the file already exists, it will be overwritten."
   })
 });
@@ -744,10 +311,11 @@ var CopyFileTool = class extends EnvironmentToolBase {
   /**
    * Converts the tool output to a format suitable for model consumption.
    *
-   * @param output - The output from the tool execution.
+   * @param options - The tool result, including the output from the tool execution.
    * @returns The formatted tool result.
    */
-  toModelOutput(output) {
+  toModelOutput(options) {
+    const { output } = options;
     return {
       type: "text",
       value: `File \`${output.sourcePath}\` copied successfully to \`${output.destinationPath}\`.`
@@ -772,15 +340,19 @@ var CopyFileTool = class extends EnvironmentToolBase {
 };
 
 // src/tools/delete-file-tool.ts
-import { z as z3 } from "zod";
+import { z as z2 } from "zod";
+import {
+  EnvironmentToolBase as EnvironmentToolBase2,
+  DeleteFileResult
+} from "@ai-code-agents/environment-utils";
 var DeleteFileToolName = "delete_file";
-var DeleteFileToolInput = z3.object({
-  path: z3.string().meta({
+var DeleteFileToolInput = z2.object({
+  path: z2.string().meta({
     description: "The path to the file to delete, relative to the project directory."
   })
 });
 var DeleteFileToolOutput = DeleteFileResult;
-var DeleteFileTool = class extends EnvironmentToolBase {
+var DeleteFileTool = class extends EnvironmentToolBase2 {
   /**
    * Returns the metadata for the tool.
    *
@@ -810,10 +382,11 @@ var DeleteFileTool = class extends EnvironmentToolBase {
   /**
    * Converts the tool output to a format suitable for model consumption.
    *
-   * @param output - The output from the tool execution.
+   * @param options - The tool result, including the output from the tool execution.
    * @returns The formatted tool result.
    */
-  toModelOutput(output) {
+  toModelOutput(options) {
+    const { output } = options;
     return {
       type: "text",
       value: `File \`${output.path}\` deleted successfully.`
@@ -837,43 +410,46 @@ var DeleteFileTool = class extends EnvironmentToolBase {
 };
 
 // src/tools/edit-file-tool.ts
-import { z as z4 } from "zod";
+import { z as z3 } from "zod";
+import {
+  EnvironmentToolBase as EnvironmentToolBase3
+} from "@ai-code-agents/environment-utils";
 var EditFileToolName = "edit_file";
-var EditFileToolInput = z4.object({
-  path: z4.string().meta({
+var EditFileToolInput = z3.object({
+  path: z3.string().meta({
     description: "The path to the file to edit, relative to the project directory."
   }),
-  oldString: z4.string().meta({
+  oldString: z3.string().meta({
     description: "The exact string to replace in the file."
   }),
-  newString: z4.string().meta({
+  newString: z3.string().meta({
     description: "The string to replace the old string with."
   }),
-  replaceAll: z4.boolean().optional().meta({
+  replaceAll: z3.boolean().optional().meta({
     description: "Whether to replace all occurrences of the old string. Defaults to false."
   })
 });
-var EditFileToolOutput = z4.object({
-  path: z4.string().meta({
+var EditFileToolOutput = z3.object({
+  path: z3.string().meta({
     description: "The path to the file that was edited."
   }),
-  oldString: z4.string().meta({
+  oldString: z3.string().meta({
     description: "The old string that was replaced."
   }),
-  newString: z4.string().meta({
+  newString: z3.string().meta({
     description: "The new string that replaced the old string."
   }),
-  replacements: z4.number().meta({
+  replacements: z3.number().meta({
     description: "The number of replacements made."
   }),
-  message: z4.string().meta({
+  message: z3.string().meta({
     description: "A message indicating the result of the edit operation."
   })
 });
-function escapeRegExp(string2) {
-  return string2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function escapeRegExp(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-var EditFileTool = class extends EnvironmentToolBase {
+var EditFileTool = class extends EnvironmentToolBase3 {
   /**
    * Returns the metadata for the tool.
    *
@@ -928,10 +504,11 @@ var EditFileTool = class extends EnvironmentToolBase {
   /**
    * Converts the tool output to a format suitable for model consumption.
    *
-   * @param output - The output from the tool execution.
+   * @param options - The tool result, including the output from the tool execution.
    * @returns The formatted tool result.
    */
-  toModelOutput(output) {
+  toModelOutput(options) {
+    const { output } = options;
     return {
       type: "text",
       value: `Edited file \`${output.path}\` with ${output.replacements} replacement(s).`
@@ -979,7 +556,11 @@ var EditFileTool = class extends EnvironmentToolBase {
 };
 
 // src/tools/get-project-file-structure-tool.ts
-import { z as z5 } from "zod";
+import { z as z4 } from "zod";
+import {
+  EnvironmentToolBase as EnvironmentToolBase4,
+  escapeCommandArg as escapeCommandArg4
+} from "@ai-code-agents/environment-utils";
 
 // src/util/build-tree-from-files.ts
 function renderTree(node, prefix = "") {
@@ -995,46 +576,133 @@ function renderTree(node, prefix = "") {
       result += renderTree(node[entry], nextPrefix);
     }
   }
-  return result;
+  return result;
+}
+function buildTreeFromFiles(files) {
+  if (files.length === 0) {
+    return "";
+  }
+  const sortedFiles = [...files].sort();
+  const tree = {};
+  for (const file of sortedFiles) {
+    const parts = file.split("/");
+    let current = tree;
+    for (const part of parts) {
+      if (!current[part]) {
+        current[part] = {};
+      }
+      current = current[part];
+    }
+  }
+  return renderTree(tree).trim();
+}
+
+// src/util/get-gitignored-paths.ts
+import path3 from "path";
+import {
+  escapeCommandArg as escapeCommandArg3
+} from "@ai-code-agents/environment-utils";
+async function getGitIgnoredPaths(env) {
+  const gitignorePath = await getClosestGitIgnorePath(env);
+  if (!gitignorePath) {
+    return [];
+  }
+  const { stdout: pwd } = await env.runCommand("pwd");
+  const currentDir = pwd.trim();
+  const gitignoreDir = path3.dirname(gitignorePath);
+  try {
+    const { stdout, exitCode } = await env.runCommand(
+      `cat ${escapeCommandArg3(gitignorePath)}`
+    );
+    if (exitCode !== 0) {
+      return [];
+    }
+    const rawRules = stdout.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
+    const relPath = path3.relative(gitignoreDir, currentDir);
+    if (relPath === "") {
+      return rawRules.map(
+        (rule) => rule.startsWith("/") ? rule.slice(1) : rule
+      );
+    }
+    const relPathSegments = relPath.split(path3.sep);
+    const sanitizedRules = [];
+    for (const rule of rawRules) {
+      const isAnchored = rule.startsWith("/") || rule.includes("/") && rule.indexOf("/") !== rule.length - 1;
+      if (!isAnchored || rule.startsWith("**/")) {
+        sanitizedRules.push(rule.startsWith("**/") ? rule.slice(3) : rule);
+        continue;
+      }
+      const normalizedRule = rule.startsWith("/") ? rule.slice(1) : rule;
+      const cleanRule = normalizedRule.endsWith("/") ? normalizedRule.slice(0, -1) : normalizedRule;
+      const ruleSegments = cleanRule.split("/");
+      let matches = true;
+      let i = 0;
+      for (; i < relPathSegments.length; i++) {
+        if (i >= ruleSegments.length) {
+          sanitizedRules.push(".");
+          matches = false;
+          break;
+        }
+        if (!matchSegment(ruleSegments[i], relPathSegments[i])) {
+          matches = false;
+          break;
+        }
+      }
+      if (matches) {
+        const remaining = ruleSegments.slice(i).join("/");
+        if (remaining) {
+          sanitizedRules.push(
+            normalizedRule.endsWith("/") && !remaining.endsWith("/") ? `${remaining}/` : remaining
+          );
+        } else {
+          sanitizedRules.push(".");
+        }
+      }
+    }
+    return [...new Set(sanitizedRules)];
+  } catch (_error) {
+    return [];
+  }
 }
-function buildTreeFromFiles(files) {
-  if (files.length === 0) {
-    return "";
+function matchSegment(pattern, segment) {
+  if (pattern === "*") {
+    return true;
   }
-  const sortedFiles = [...files].sort();
-  const tree = {};
-  for (const file of sortedFiles) {
-    const parts = file.split("/");
-    let current = tree;
-    for (const part of parts) {
-      if (!current[part]) {
-        current[part] = {};
-      }
-      current = current[part];
-    }
+  if (pattern === segment) {
+    return true;
   }
-  return renderTree(tree).trim();
+  if (pattern.includes("*") || pattern.includes("?")) {
+    const regexStr = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+    const regex = new RegExp(`^${regexStr}$`);
+    return regex.test(segment);
+  }
+  return false;
+}
+async function getClosestGitIgnorePath(env) {
+  const command = 'd=$PWD; while [ -n "$d" ] && [ ! -f "$d/.gitignore" ]; do d=${d%/*}; done; [ -f "$d/.gitignore" ] && echo "$d/.gitignore"';
+  const { stdout } = await env.runCommand(command);
+  return stdout.trim();
 }
 
 // src/tools/get-project-file-structure-tool.ts
 var GetProjectFileStructureToolName = "get_project_file_structure";
-var GetProjectFileStructureToolInput = z5.object({
-  path: z5.string().optional().meta({
+var GetProjectFileStructureToolInput = z4.object({
+  path: z4.string().optional().meta({
     description: 'Root path to list files from, relative to the project directory. Defaults to ".".'
   }),
-  excludeGitIgnored: z5.boolean().optional().meta({
+  excludeGitIgnored: z4.boolean().optional().meta({
     description: "Whether to exclude files ignored by Git. Defaults to true."
   })
 });
-var GetProjectFileStructureToolOutput = z5.object({
-  files: z5.array(z5.string()).meta({
+var GetProjectFileStructureToolOutput = z4.object({
+  files: z4.array(z4.string()).meta({
     description: "List of all file paths found, relative to the root path."
   }),
-  excludeGitIgnored: z5.boolean().meta({
+  excludeGitIgnored: z4.boolean().meta({
     description: "Whether files ignored by Git were excluded."
   })
 });
-var GetProjectFileStructureTool = class extends EnvironmentToolBase {
+var GetProjectFileStructureTool = class extends EnvironmentToolBase4 {
   /**
    * Returns the metadata for the tool.
    *
@@ -1060,21 +728,16 @@ var GetProjectFileStructureTool = class extends EnvironmentToolBase {
    */
   async executeForEnvironment(env, input) {
     const { path: path5 = ".", excludeGitIgnored = true } = input;
-    const escapedPath = escapeCommandArg(path5);
+    const escapedPath = escapeCommandArg4(path5);
     let command = `find ${escapedPath} -type f`;
     if (excludeGitIgnored) {
-      let gitIgnoredPaths = [];
-      try {
-        const { content: gitignoreContent } = await env.readFile(".gitignore");
-        gitIgnoredPaths = gitignoreContent.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
-      } catch (_error) {
-      }
+      const gitIgnoredPaths = await getGitIgnoredPaths(env);
       for (const gitIgnoredPath of gitIgnoredPaths) {
         if (!gitIgnoredPath.endsWith("/")) {
-          const escapedPath2 = escapeCommandArg(`*/${gitIgnoredPath}/*`);
-          command += ` -not -name ${escapeCommandArg(gitIgnoredPath)} -not -path ${escapedPath2}`;
+          const escapedPath2 = escapeCommandArg4(`*/${gitIgnoredPath}/*`);
+          command += ` -not -name ${escapeCommandArg4(gitIgnoredPath)} -not -path ${escapedPath2}`;
         } else {
-          const escapedPath2 = escapeCommandArg(`*/${gitIgnoredPath}*`);
+          const escapedPath2 = escapeCommandArg4(`*/${gitIgnoredPath}*`);
           command += ` -not -path ${escapedPath2}`;
         }
       }
@@ -1096,10 +759,11 @@ var GetProjectFileStructureTool = class extends EnvironmentToolBase {
   /**
    * Converts the tool output to a format suitable for model consumption.
    *
-   * @param output - The output from the tool execution.
+   * @param options - The tool result, including the output from the tool execution.
    * @returns The formatted tool result.
    */
-  toModelOutput(output) {
+  toModelOutput(options) {
+    const { output } = options;
     const tree = buildTreeFromFiles(output.files);
     if (!tree) {
       return {
@@ -1137,7 +801,12 @@ var GetProjectFileStructureTool = class extends EnvironmentToolBase {
 };
 
 // src/tools/glob-tool.ts
-import { z as z6 } from "zod";
+import { z as z5 } from "zod";
+import {
+  EnvironmentToolBase as EnvironmentToolBase5,
+  escapeCommandArg as escapeCommandArg5,
+  validateRelativePath
+} from "@ai-code-agents/environment-utils";
 
 // src/util/glob-to-reg-exp.ts
 function globToRegExp(glob) {
@@ -1185,32 +854,32 @@ function globToRegExp(glob) {
 
 // src/tools/glob-tool.ts
 var GlobToolName = "glob";
-var GlobToolInput = z6.object({
-  searchPattern: z6.string().meta({
+var GlobToolInput = z5.object({
+  searchPattern: z5.string().meta({
     description: 'The glob pattern to search for, relative to the search path / project directory (e.g. "**/*.ts", "docs/*.md").'
   }),
-  searchPath: z6.string().optional().meta({
+  searchPath: z5.string().optional().meta({
     description: "The path to search within, relative to the project directory. Defaults to the project directory."
   }),
-  excludeGitIgnored: z6.boolean().optional().meta({
+  excludeGitIgnored: z5.boolean().optional().meta({
     description: "Whether to exclude files ignored by Git. Defaults to true."
   })
 });
-var GlobToolOutput = z6.object({
-  searchPattern: z6.string().meta({
+var GlobToolOutput = z5.object({
+  searchPattern: z5.string().meta({
     description: "The glob pattern that was searched for."
   }),
-  searchPath: z6.string().meta({
+  searchPath: z5.string().meta({
     description: "The path that was searched within."
   }),
-  excludeGitIgnored: z6.boolean().meta({
+  excludeGitIgnored: z5.boolean().meta({
     description: "Whether files ignored by Git were excluded."
   }),
-  matchingPaths: z6.array(z6.string()).meta({
+  matchingPaths: z5.array(z5.string()).meta({
     description: "The list of file paths that matched the glob search, relative to the project directory."
   })
 });
-var GlobTool = class extends EnvironmentToolBase {
+var GlobTool = class extends EnvironmentToolBase5 {
   /**
    * Returns the metadata for the tool.
    *
@@ -1245,21 +914,16 @@ var GlobTool = class extends EnvironmentToolBase {
       validateRelativePath(searchPath);
     }
     const untrailingslashedSearchPath = searchPath === "" ? "." : searchPath.replace(/\/+$/, "");
-    const escapedSearchPath = escapeCommandArg(untrailingslashedSearchPath);
+    const escapedSearchPath = escapeCommandArg5(untrailingslashedSearchPath);
     let command = `find ${escapedSearchPath} -type f`;
     if (excludeGitIgnored) {
-      let gitIgnoredPaths = [];
-      try {
-        const { content: gitignoreContent } = await env.readFile(".gitignore");
-        gitIgnoredPaths = gitignoreContent.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
-      } catch (_error) {
-      }
+      const gitIgnoredPaths = await getGitIgnoredPaths(env);
       for (const gitIgnoredPath of gitIgnoredPaths) {
         if (!gitIgnoredPath.endsWith("/")) {
-          const escapedPath = escapeCommandArg(`*/${gitIgnoredPath}/*`);
-          command += ` -not -name ${escapeCommandArg(gitIgnoredPath)} -not -path ${escapedPath}`;
+          const escapedPath = escapeCommandArg5(`*/${gitIgnoredPath}/*`);
+          command += ` -not -name ${escapeCommandArg5(gitIgnoredPath)} -not -path ${escapedPath}`;
         } else {
-          const escapedPath = escapeCommandArg(`*/${gitIgnoredPath}*`);
+          const escapedPath = escapeCommandArg5(`*/${gitIgnoredPath}*`);
           command += ` -not -path ${escapedPath}`;
         }
       }
@@ -1295,10 +959,11 @@ var GlobTool = class extends EnvironmentToolBase {
   /**
    * Converts the tool output to a format suitable for model consumption.
    *
-   * @param output - The output from the tool execution.
+   * @param options - The tool result, including the output from the tool execution.
    * @returns The formatted tool result.
    */
-  toModelOutput(output) {
+  toModelOutput(options) {
+    const { output } = options;
     if (output.matchingPaths.length === 0) {
       return {
         type: "text",
@@ -1347,8 +1012,276 @@ ${bulletPoints}
   }
 };
 
+// src/tools/grep-tool.ts
+import { z as z6 } from "zod";
+import {
+  EnvironmentToolBase as EnvironmentToolBase6,
+  escapeCommandArg as escapeCommandArg6,
+  validateRelativePath as validateRelativePath2
+} from "@ai-code-agents/environment-utils";
+var GrepToolName = "grep";
+var GrepToolInput = z6.object({
+  regexpPattern: z6.string().meta({
+    description: "The regular expression pattern to search for in file contents."
+  }),
+  searchPattern: z6.string().optional().meta({
+    description: 'The glob pattern to filter which files are searched (e.g. "**/*.ts"). If omitted, searches all files.'
+  }),
+  searchPath: z6.string().optional().meta({
+    description: "The path to search within, relative to the project directory. Defaults to the project directory."
+  }),
+  contextLines: z6.number().int().nonnegative().optional().meta({
+    description: "The number of context lines to include before and after each match."
+  })
+});
+var GrepMatch = z6.object({
+  path: z6.string().meta({
+    description: "The path to the file containing the match, relative to the project directory."
+  }),
+  lineNumber: z6.number().int().meta({
+    description: "The line number of the match (1-based)."
+  }),
+  line: z6.string().meta({
+    description: "The content of the matching line."
+  }),
+  beforeContext: z6.array(z6.string()).optional().meta({
+    description: "Lines of context before the match."
+  }),
+  afterContext: z6.array(z6.string()).optional().meta({
+    description: "Lines of context after the match."
+  })
+});
+var GrepToolOutput = z6.object({
+  regexpPattern: z6.string().meta({
+    description: "The regular expression pattern that was searched for."
+  }),
+  searchPattern: z6.string().optional().meta({
+    description: "The glob pattern used to filter files."
+  }),
+  searchPath: z6.string().optional().meta({
+    description: "The path that was searched within."
+  }),
+  contextLines: z6.number().optional().meta({
+    description: "The number of context lines included."
+  }),
+  matches: z6.array(GrepMatch).meta({
+    description: "The list of matches found."
+  })
+});
+var GrepTool = class extends EnvironmentToolBase6 {
+  /**
+   * Returns the metadata for the tool.
+   *
+   * The name, description, and needsApproval properties are defaults which can be overridden in the constructor.
+   *
+   * @returns The tool metadata.
+   */
+  getMetadata() {
+    return {
+      name: GrepToolName,
+      description: "Searches for a regular expression pattern within the content of files in the project.",
+      inputSchema: GrepToolInput,
+      outputSchema: GrepToolOutput,
+      needsApproval: false
+    };
+  }
+  /**
+   * Executes the tool in the given execution environment with the given input.
+   *
+   * @param env - The execution environment to use.
+   * @param input - The input for the tool.
+   * @returns A promise that resolves to the tool execution result.
+   */
+  async executeForEnvironment(env, input) {
+    const {
+      regexpPattern,
+      searchPattern,
+      searchPath = "",
+      contextLines = 0
+    } = input;
+    if (searchPath) {
+      validateRelativePath2(searchPath);
+    }
+    const globTool = new GlobTool(env);
+    const globResult = await globTool.execute(
+      {
+        searchPattern: searchPattern || "**/*",
+        searchPath
+      },
+      {}
+    );
+    const filesToSearch = globResult.matchingPaths;
+    if (filesToSearch.length === 0) {
+      return {
+        regexpPattern,
+        searchPattern,
+        searchPath,
+        contextLines,
+        matches: []
+      };
+    }
+    const BATCH_SIZE = 50;
+    const matches = [];
+    for (let i = 0; i < filesToSearch.length; i += BATCH_SIZE) {
+      const batch = filesToSearch.slice(i, i + BATCH_SIZE);
+      const escapedFilePaths = batch.map(escapeCommandArg6).join(" ");
+      const command = `grep -n -H -I -E ${escapeCommandArg6(regexpPattern)} ${escapedFilePaths}`;
+      const { stdout, exitCode } = await env.runCommand(command);
+      if (exitCode > 1) {
+        throw new Error(`Failed to execute grep command "${command}".`);
+      }
+      if (stdout) {
+        const lines = stdout.split("\n");
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          const firstColonIndex = line.indexOf(":");
+          if (firstColonIndex === -1) continue;
+          const secondColonIndex = line.indexOf(":", firstColonIndex + 1);
+          if (secondColonIndex === -1) continue;
+          const filePath = line.substring(0, firstColonIndex);
+          const lineNumberStr = line.substring(
+            firstColonIndex + 1,
+            secondColonIndex
+          );
+          const content = line.substring(secondColonIndex + 1);
+          const lineNumber = parseInt(lineNumberStr, 10);
+          if (isNaN(lineNumber)) continue;
+          matches.push({
+            path: filePath,
+            lineNumber,
+            line: content
+          });
+        }
+      }
+    }
+    if (contextLines > 0 && matches.length > 0) {
+      const matchesByFile = /* @__PURE__ */ new Map();
+      for (const match of matches) {
+        if (!matchesByFile.has(match.path)) {
+          matchesByFile.set(match.path, []);
+        }
+        matchesByFile.get(match.path).push(match);
+      }
+      for (const [filePath, fileMatches] of matchesByFile) {
+        try {
+          const { content } = await env.readFile(filePath);
+          const lines = content.split("\n");
+          for (const match of fileMatches) {
+            const lineIndex = match.lineNumber - 1;
+            const start = Math.max(0, lineIndex - contextLines);
+            const end = Math.min(lines.length, lineIndex + contextLines + 1);
+            match.beforeContext = lines.slice(start, lineIndex);
+            match.afterContext = lines.slice(lineIndex + 1, end);
+          }
+        } catch (_error) {
+        }
+      }
+    }
+    return {
+      regexpPattern,
+      searchPattern,
+      searchPath,
+      contextLines,
+      matches
+    };
+  }
+  /**
+   * Converts the tool output to a format suitable for model consumption.
+   *
+   * @param options - The tool result, including the output from the tool execution.
+   * @returns The formatted tool result.
+   */
+  toModelOutput(options) {
+    const { output } = options;
+    if (output.matches.length === 0) {
+      return {
+        type: "text",
+        value: "No matches found."
+      };
+    }
+    let result = `Found ${output.matches.length} matches:
+`;
+    const matchesByFile = /* @__PURE__ */ new Map();
+    for (const match of output.matches) {
+      if (!matchesByFile.has(match.path)) {
+        matchesByFile.set(match.path, []);
+      }
+      matchesByFile.get(match.path).push(match);
+    }
+    for (const [filePath, matches] of matchesByFile) {
+      result += `
+File: ${filePath}
+`;
+      for (const match of matches) {
+        if (match.beforeContext && match.beforeContext.length > 0) {
+          match.beforeContext.forEach((line, idx) => {
+            result += `  ${match.lineNumber - match.beforeContext.length + idx}: ${line}
+`;
+          });
+        }
+        result += `> ${match.lineNumber}: ${match.line}
+`;
+        if (match.afterContext && match.afterContext.length > 0) {
+          match.afterContext.forEach((line, idx) => {
+            result += `  ${match.lineNumber + 1 + idx}: ${line}
+`;
+          });
+        }
+        if (output.contextLines && output.contextLines > 0) {
+          result += "---\n";
+        }
+      }
+    }
+    return {
+      type: "text",
+      value: result
+    };
+  }
+  /**
+   * Gets the examples for the tool.
+   *
+   * @returns The tool examples.
+   */
+  get examples() {
+    return [
+      {
+        input: {
+          regexpPattern: "interface.*Tool",
+          searchPattern: "src/**/*.ts"
+        },
+        output: `Found 2 matches:
+
+File: src/types.ts
+> 120: export interface ToolInterface<ToolInputType, ToolOutputType> {
+> 135: export interface EnvironmentToolInterface<
+
+File: src/tools/tool-base.ts
+> 10: export abstract class ToolBase<
+`
+      },
+      {
+        input: {
+          regexpPattern: "TODO",
+          contextLines: 1
+        },
+        output: `Found 1 matches:
+
+File: src/index.ts
+  10: // Some code before
+> 11: // TODO: Implement feature X
+  12: // Some code after
+`
+      }
+    ];
+  }
+};
+
 // src/tools/list-directory-tool.ts
 import { z as z7 } from "zod";
+import {
+  EnvironmentToolBase as EnvironmentToolBase7,
+  escapeCommandArg as escapeCommandArg7
+} from "@ai-code-agents/environment-utils";
 var ListDirectoryToolName = "list_directory";
 var ListDirectoryToolInput = z7.object({
   path: z7.string().meta({
@@ -1366,7 +1299,7 @@ var ListDirectoryToolOutput = z7.object({
     description: "List of subdirectories in the directory."
   })
 });
-var ListDirectoryTool = class extends EnvironmentToolBase {
+var ListDirectoryTool = class extends EnvironmentToolBase7 {
   /**
    * Returns the metadata for the tool.
    *
@@ -1391,7 +1324,7 @@ var ListDirectoryTool = class extends EnvironmentToolBase {
    * @returns A promise that resolves to the tool execution result.
    */
   async executeForEnvironment(env, input) {
-    const escapedPath = escapeCommandArg(input.path);
+    const escapedPath = escapeCommandArg7(input.path);
     const command = `ls -la ${escapedPath}`;
     const { stdout, stderr, exitCode } = await env.runCommand(command);
     if (exitCode !== 0) {
@@ -1424,10 +1357,11 @@ var ListDirectoryTool = class extends EnvironmentToolBase {
   /**
    * Converts the tool output to a format suitable for model consumption.
    *
-   * @param output - The output from the tool execution.
+   * @param options - The tool result, including the output from the tool execution.
    * @returns The formatted tool result.
    */
-  toModelOutput(output) {
+  toModelOutput(options) {
+    const { output } = options;
     const formatEntries = (entries, type) => {
       if (entries.length === 0) {
         return `No ${type} found.`;
@@ -1474,6 +1408,10 @@ Directories:
 
 // src/tools/move-file-tool.ts
 import { z as z8 } from "zod";
+import {
+  EnvironmentToolBase as EnvironmentToolBase8,
+  MoveFileResult
+} from "@ai-code-agents/environment-utils";
 var MoveFileToolName = "move_file";
 var MoveFileToolInput = z8.object({
   sourcePath: z8.string().meta({
@@ -1484,7 +1422,7 @@ var MoveFileToolInput = z8.object({
   })
 });
 var MoveFileToolOutput = MoveFileResult;
-var MoveFileTool = class extends EnvironmentToolBase {
+var MoveFileTool = class extends EnvironmentToolBase8 {
   /**
    * Returns the metadata for the tool.
    *
@@ -1514,10 +1452,11 @@ var MoveFileTool = class extends EnvironmentToolBase {
   /**
    * Converts the tool output to a format suitable for model consumption.
    *
-   * @param output - The output from the tool execution.
+   * @param options - The tool result, including the output from the tool execution.
    * @returns The formatted tool result.
    */
-  toModelOutput(output) {
+  toModelOutput(options) {
+    const { output } = options;
     return {
       type: "text",
       value: `File \`${output.sourcePath}\` moved successfully to \`${output.destinationPath}\`.`
@@ -1543,6 +1482,10 @@ var MoveFileTool = class extends EnvironmentToolBase {
 
 // src/tools/read-file-tool.ts
 import { z as z9 } from "zod";
+import {
+  EnvironmentToolBase as EnvironmentToolBase9,
+  ReadFileResult
+} from "@ai-code-agents/environment-utils";
 
 // src/util/get-language-identifier-from-file-path.ts
 import path4 from "path";
@@ -1720,7 +1663,7 @@ ${output.content}
 \`\`\`
 `;
 };
-var ReadFileTool = class extends EnvironmentToolBase {
+var ReadFileTool = class extends EnvironmentToolBase9 {
   /**
    * Returns the metadata for the tool.
    *
@@ -1750,10 +1693,11 @@ var ReadFileTool = class extends EnvironmentToolBase {
   /**
    * Converts the tool output to a format suitable for model consumption.
    *
-   * @param output - The output from the tool execution.
+   * @param options - The tool result, including the output from the tool execution.
    * @returns The formatted tool result.
    */
-  toModelOutput(output) {
+  toModelOutput(options) {
+    const { output } = options;
     return {
       type: "text",
       value: formatModelResponse(output)
@@ -1797,13 +1741,17 @@ export function Loader(props: LoaderProps) {
 
 // src/tools/read-many-files-tool.ts
 import { z as z10 } from "zod";
+import {
+  EnvironmentToolBase as EnvironmentToolBase10,
+  ReadFileResult as ReadFileResult2
+} from "@ai-code-agents/environment-utils";
 var ReadManyFilesToolName = "read_many_files";
 var ReadManyFilesToolInput = z10.object({
   paths: z10.array(z10.string()).meta({
     description: "The paths to the files to read, relative to the project directory."
   })
 });
-var ReadManyFilesToolOutput = z10.record(z10.string(), ReadFileResult);
+var ReadManyFilesToolOutput = z10.record(z10.string(), ReadFileResult2);
 var formatModelResponse2 = (output) => {
   const language = getLanguageIdentifierFromFilePath(output.path);
   return `File: \`${output.path}\`
@@ -1813,7 +1761,7 @@ ${output.content}
 \`\`\`
 `;
 };
-var ReadManyFilesTool = class extends EnvironmentToolBase {
+var ReadManyFilesTool = class extends EnvironmentToolBase10 {
   /**
    * Returns the metadata for the tool.
    *
@@ -1849,10 +1797,11 @@ var ReadManyFilesTool = class extends EnvironmentToolBase {
   /**
    * Converts the tool output to a format suitable for model consumption.
    *
-   * @param output - The output from the tool execution.
+   * @param options - The tool result, including the output from the tool execution.
    * @returns The formatted tool result.
    */
-  toModelOutput(output) {
+  toModelOutput(options) {
+    const { output } = options;
     const fileContentResponses = Object.values(output).map(
       (fileResult) => formatModelResponse2(fileResult)
     );
@@ -1909,6 +1858,10 @@ export function Loader(props: LoaderProps) {
 
 // src/tools/run-command-tool.ts
 import { z as z11 } from "zod";
+import {
+  EnvironmentToolBase as EnvironmentToolBase11,
+  RunCommandResult
+} from "@ai-code-agents/environment-utils";
 var RunCommandToolName = "run_command";
 var RunCommandToolInput = z11.object({
   command: z11.string().meta({ description: "The CLI command to run, including all arguments." })
@@ -1929,7 +1882,7 @@ Output (stdout): ${stdout}
 Error Output (stderr): ${stderr}
 `;
 }
-var RunCommandTool = class extends EnvironmentToolBase {
+var RunCommandTool = class extends EnvironmentToolBase11 {
   /**
    * Returns the metadata for the tool.
    *
@@ -1959,10 +1912,11 @@ var RunCommandTool = class extends EnvironmentToolBase {
   /**
    * Converts the tool output to a format suitable for model consumption.
    *
-   * @param output - The output from the tool execution.
+   * @param options - The tool result, including the output from the tool execution.
    * @returns The formatted tool result.
    */
-  toModelOutput(output) {
+  toModelOutput(options) {
+    const { output } = options;
     return {
       type: "text",
       value: formatCommandResultToModelResponse(output)
@@ -2034,6 +1988,10 @@ added 1 package, and changed 1 package in 2s
 
 // src/tools/write-file-tool.ts
 import { z as z12 } from "zod";
+import {
+  EnvironmentToolBase as EnvironmentToolBase12,
+  WriteFileResult
+} from "@ai-code-agents/environment-utils";
 var WriteFileToolName = "write_file";
 var WriteFileToolInput = z12.object({
   path: z12.string().meta({
@@ -2044,7 +2002,7 @@ var WriteFileToolInput = z12.object({
   })
 });
 var WriteFileToolOutput = WriteFileResult;
-var WriteFileTool = class extends EnvironmentToolBase {
+var WriteFileTool = class extends EnvironmentToolBase12 {
   /**
    * Returns the metadata for the tool.
    *
@@ -2074,10 +2032,11 @@ var WriteFileTool = class extends EnvironmentToolBase {
   /**
    * Converts the tool output to a format suitable for model consumption.
    *
-   * @param output - The output from the tool execution.
+   * @param options - The tool result, including the output from the tool execution.
    * @returns The formatted tool result.
    */
-  toModelOutput(output) {
+  toModelOutput(options) {
+    const { output } = options;
     return {
       type: "text",
       value: `File \`${output.path}\` written successfully.`
@@ -2107,6 +2066,9 @@ var WriteFileTool = class extends EnvironmentToolBase {
 
 // src/tools/submit-tool.ts
 import { z as z13 } from "zod";
+import {
+  ToolBase
+} from "@ai-code-agents/environment-utils";
 var SubmitToolName = "submit";
 var SubmitToolInput = z13.object({});
 var SubmitToolOutput = z13.object({});
@@ -2131,7 +2093,7 @@ var SubmitTool = class extends ToolBase {
    * Executes the tool with the given input.
    *
    * @param _ - The input for the tool. Unused.
-   * @param __ - Options from the tool call. Unused.
+   * @param __ - Options for the tool execution. Unused.
    * @returns A promise that resolves to the tool execution result.
    */
   async execute(_, __) {
@@ -2140,7 +2102,7 @@ var SubmitTool = class extends ToolBase {
   /**
    * Converts the tool output to a format suitable for model consumption.
    *
-   * @param _ - The output from the tool execution. Unused.
+   * @param _ - The tool result, including the output from the tool execution. Unused.
    * @returns The formatted tool result.
    */
   toModelOutput(_) {
@@ -2161,7 +2123,7 @@ var SubmitTool = class extends ToolBase {
 
 // src/agent-creators.ts
 import {
-  Experimental_Agent as Agent,
+  ToolLoopAgent,
   stepCountIs,
   hasToolCall
 } from "ai";
@@ -2169,10 +2131,13 @@ import {
 // src/instructions.ts
 function getAdditionalInstructions(config) {
   const { maxSteps, allowSubmit, tools } = config;
-  const exampleSections = [];
+  const exampleSections = [
+    "# Tool Examples",
+    "You have access to several tools to assist you in completing your task. Here are some examples of how to use them:"
+  ];
   for (const [toolName, tool] of Object.entries(tools)) {
     if ("examples" in tool && Array.isArray(tool.examples) && tool.examples.length > 0) {
-      let toolSection = `### Tool: \`${toolName}\`
+      let toolSection = `## Tool: \`${toolName}\`
 
 `;
       for (const example of tool.examples) {
@@ -2181,40 +2146,48 @@ function getAdditionalInstructions(config) {
       exampleSections.push(toolSection.trim());
     }
   }
-  const workflowGuidelines = [
-    /*
-     * If there are examples, the tool information is already mentioned in a separate Tool Examples section.
-     * Therefore the line below is only relevant if there are no examples.
-     */
-    ...!exampleSections.length ? [
-      "You have access to several tools to assist you in completing your task."
-    ] : [],
-    "You must issue tool calls to complete your task. Do not engage with the user directly.",
-    ...allowSubmit ? [
-      `Once you think you have completed your task, call the \`${SubmitToolName}\` tool to submit your results.`
-    ] : [],
-    `You have a maximum of ${maxSteps} steps to complete your task.`
-  ];
-  const importantWorkflowGuidelines = `## Important Workflow Guidelines
-
-${workflowGuidelines.map((line) => `- ${line}`).join("\n")}
-
-Remember, you don't get to ask the user any clarifying questions, just use the tools available to complete your task. You're on your own now.
+  const constraintSections = ["# Behavioral Guidelines"];
+  const constraintsByType = getCodeAgentConstraints({ maxSteps, allowSubmit });
+  if (constraintsByType.must && constraintsByType.must.length > 0) {
+    let constraintSection = "## You MUST:\n\n";
+    for (const constraint of constraintsByType.must) {
+      constraintSection += `- ${constraint}
 `;
-  if (exampleSections.length) {
-    return `## Tool Examples
-
-You have access to several tools to assist you in completing your task. Here are some examples of how to use them:
-
-${exampleSections.join("\n\n")}
-
-` + importantWorkflowGuidelines;
+    }
+    constraintSections.push(constraintSection.trim());
+  }
+  if (constraintsByType.must_not && constraintsByType.must_not.length > 0) {
+    let constraintSection = "## You MUST NOT:\n\n";
+    for (const constraint of constraintsByType.must_not) {
+      constraintSection += `- ${constraint}
+`;
+    }
+    constraintSections.push(constraintSection.trim());
+  }
+  if (constraintsByType.should && constraintsByType.should.length > 0) {
+    let constraintSection = "## You SHOULD:\n\n";
+    for (const constraint of constraintsByType.should) {
+      constraintSection += `- ${constraint}
+`;
+    }
+    constraintSections.push(constraintSection.trim());
+  }
+  if (constraintsByType.should_not && constraintsByType.should_not.length > 0) {
+    let constraintSection = "## You SHOULD NOT:\n\n";
+    for (const constraint of constraintsByType.should_not) {
+      constraintSection += `- ${constraint}
+`;
+    }
+    constraintSections.push(constraintSection.trim());
   }
-  return importantWorkflowGuidelines;
+  const finalReminder = getCodeAgentFinalReminder();
+  return [...exampleSections, ...constraintSections, finalReminder].join(
+    "\n\n"
+  );
 }
 function formatExampleForInstructions(toolName, example) {
-  const input = typeof example.input === "undefined" ? "" : typeof example.input === "string" || typeof example.input === "number" ? example.input : JSON.stringify(example.input, null, 2);
-  const output = typeof example.output === "undefined" ? "" : typeof example.output === "string" || typeof example.output === "number" ? example.output : JSON.stringify(example.output, null, 2);
+  const input = formatValueForExample(example.input);
+  const output = formatValueForExample(example.output);
   if (output === "") {
     return `<example>
 <tool_call>
@@ -2231,8 +2204,42 @@ ${output}
 </tool_response>
 </example>`;
 }
+function formatValueForExample(value) {
+  if (typeof value === "undefined") {
+    return "";
+  }
+  if (typeof value === "string") {
+    return `"${value}"`;
+  }
+  if (typeof value === "number") {
+    return value.toString();
+  }
+  if (typeof value === "boolean") {
+    return value ? "true" : "false";
+  }
+  return JSON.stringify(value, null, 2);
+}
+function getCodeAgentConstraints(config) {
+  const { maxSteps, allowSubmit } = config;
+  return {
+    must: [
+      "Always issue tool calls to complete your task",
+      ...allowSubmit ? [
+        `Call the \`${SubmitToolName}\` tool once you think you have completed your task, to submit your results`
+      ] : [],
+      `Complete your task within ${maxSteps} steps`
+    ],
+    must_not: ["Engage with the user directly"]
+  };
+}
+function getCodeAgentFinalReminder() {
+  return "Remember, you don't get to ask the user any clarifying questions, just use the tools available to complete your task. You're on your own now.";
+}
 
 // src/tool-creators.ts
+import {
+  isCommandLine
+} from "@ai-code-agents/environment-utils";
 var availableEnvironmentTools = {
   [ReadFileToolName]: ReadFileTool,
   [WriteFileToolName]: WriteFileTool,
@@ -2243,12 +2250,14 @@ var availableEnvironmentTools = {
   [ReadManyFilesToolName]: ReadManyFilesTool,
   [GetProjectFileStructureToolName]: GetProjectFileStructureTool,
   [GlobToolName]: GlobTool,
+  [GrepToolName]: GrepTool,
   [ListDirectoryToolName]: ListDirectoryTool,
   [RunCommandToolName]: RunCommandTool
 };
 var cliOnlyTools = [
   GetProjectFileStructureToolName,
   GlobToolName,
+  GrepToolName,
   ListDirectoryToolName,
   RunCommandToolName
 ];
@@ -2257,6 +2266,7 @@ var readonlyTools = [
   ReadManyFilesToolName,
   GetProjectFileStructureToolName,
   GlobToolName,
+  GrepToolName,
   ListDirectoryToolName
 ];
 var dangerousTools = [
@@ -2284,7 +2294,7 @@ function createEnvironmentTool(toolName, environment, config) {
 }
 function createToolsForEnvironment(environment, toolsDefinition = "all") {
   const sanitizedToolsDefinition = sanitizeToolsDefinition(toolsDefinition);
-  const isCliEnvironment = "runCommand" in environment;
+  const isCliEnvironment = isCommandLine(environment);
   const tools = {};
   for (const toolDefinition of sanitizedToolsDefinition) {
     const actualToolName = toolDefinition.toolName;
@@ -2305,7 +2315,7 @@ function createToolsForEnvironment(environment, toolsDefinition = "all") {
     }
     tools[toolNameToUse] = createEnvironmentTool(
       actualToolName,
-      isCliEnvironment ? environment : environment,
+      environment,
       toolConfig
     );
   }
@@ -2361,6 +2371,54 @@ function sanitizeToolsDefinition(toolsDefinition) {
   });
 }
 
+// src/util/truncate.ts
+function truncateString(str) {
+  const lines = str.split("\n");
+  while (lines.length > 0 && lines[lines.length - 1] === "") {
+    lines.pop();
+  }
+  const isMultiline = lines.length > 1;
+  if (isMultiline) {
+    if (lines.length > 5) {
+      const truncatedLines = lines.slice(0, 5).join("\n");
+      const moreLines = lines.length - 5;
+      const lineSuffix = moreLines === 1 ? "line" : "lines";
+      return `${truncatedLines}
+...(${moreLines} more ${lineSuffix})`;
+    }
+    return lines.join("\n");
+  }
+  const singleLine = lines[0] || "";
+  if (singleLine.length > 300) {
+    const moreChars = singleLine.length - 300;
+    return `${singleLine.slice(0, 300)}...(${moreChars} more characters)`;
+  }
+  return singleLine;
+}
+function truncateObject(obj) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (typeof value === "string") {
+      result[key] = truncateString(value);
+    } else if (Array.isArray(value)) {
+      result[key] = value.map((item) => {
+        if (typeof item === "string") {
+          return truncateString(item);
+        }
+        if (typeof item === "object" && item !== null) {
+          return truncateObject(item);
+        }
+        return item;
+      });
+    } else if (typeof value === "object" && value !== null) {
+      result[key] = truncateObject(value);
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
 // src/util/get-step-log.ts
 function getStepLog(stepResult) {
   const { content } = stepResult;
@@ -2374,13 +2432,17 @@ function getStepLog(stepResult) {
     }
     logEntry += ": ";
     if (part.type === "tool-call" && "input" in part) {
-      logEntry += typeof part.input === "string" ? part.input : JSON.stringify(part.input);
+      logEntry += typeof part.input === "string" ? truncateString(part.input) : part.input === null || part.input === void 0 ? String(part.input) : JSON.stringify(
+        truncateObject(part.input)
+      );
     } else if (part.type === "tool-result" && "output" in part) {
-      logEntry += typeof part.output === "string" ? part.output : JSON.stringify(part.output);
+      logEntry += typeof part.output === "string" ? truncateString(part.output) : part.output === null || part.output === void 0 ? String(part.output) : JSON.stringify(
+        truncateObject(part.output)
+      );
     } else if (part.type === "tool-error" && "error" in part) {
       logEntry += typeof part.error === "object" && part.error !== null && "message" in part.error ? part.error.message : String(part.error);
     } else if (part.type === "text" && "text" in part) {
-      logEntry += part.text;
+      logEntry += truncateString(part.text);
     }
     logEntry += "\n";
   });
@@ -2389,6 +2451,9 @@ function getStepLog(stepResult) {
 
 // src/agent-creators.ts
 function createCodeAgent(agentConfig) {
+  return new ToolLoopAgent(createCodeAgentSettings(agentConfig));
+}
+function createCodeAgentSettings(agentConfig) {
   const {
     maxSteps,
     allowSubmit,
@@ -2397,46 +2462,29 @@ function createCodeAgent(agentConfig) {
     tools: originalTools,
     stopWhen: originalStopWhen,
     prepareStep: originalPrepareStep,
-    system: originalSystemInstruction,
+    instructions: originalSystemInstruction,
     ...remainingConfig
   } = agentConfig;
   let agentSettings;
-  let environmentTools;
+  let tools;
   if ("environments" in remainingConfig) {
     const { environments, environmentToolsDefinition, ...agentSettingsInput } = remainingConfig;
     agentSettings = { ...agentSettingsInput };
-    environmentTools = {};
-    for (const [environmentName, environment] of Object.entries(environments)) {
-      if (!(environmentName in environmentToolsDefinition)) {
-        throw new Error(
-          `No tools definition provided for environment "${environmentName}". Please provide a tools definition for each environment.`
-        );
-      }
-      const envTools = createToolsForNamedEnvironment(
-        environmentName,
-        environment,
-        environmentToolsDefinition[environmentName]
-      );
-      for (const [toolName, tool] of Object.entries(envTools)) {
-        if (toolName in environmentTools) {
-          throw new Error(
-            `Tool name conflict: The tool name "${toolName}" from environment "${environmentName}" is already used by another environment's tools.`
-          );
-        }
-        environmentTools[toolName] = tool;
-      }
-    }
+    tools = createCodeAgentTools(
+      { environments, environmentToolsDefinition },
+      originalTools
+    );
   } else if ("environment" in remainingConfig) {
     const { environment, environmentToolsDefinition, ...agentSettingsInput } = remainingConfig;
     agentSettings = { ...agentSettingsInput };
-    environmentTools = createToolsForEnvironment(
-      environment,
-      environmentToolsDefinition
+    tools = createCodeAgentTools(
+      { environment, environmentToolsDefinition },
+      originalTools
     );
   } else {
     agentSettings = { ...remainingConfig };
+    tools = originalTools || {};
   }
-  const tools = environmentTools && originalTools ? mergeTools(environmentTools, originalTools) : originalTools || environmentTools || {};
   if (allowSubmit) {
     if (SubmitToolName in tools) {
       throw new Error(
@@ -2464,16 +2512,54 @@ ${stepLog}`, stepCount - 1);
   } : originalPrepareStep;
   const stopWhenCondition = allowSubmit ? [stepCountIs(maxSteps), hasToolCall(SubmitToolName)] : stepCountIs(maxSteps);
   const stopWhen = originalStopWhen ? mergeStopWhen(originalStopWhen, stopWhenCondition) : stopWhenCondition;
-  const system = !omitAdditionalInstructions ? mergeSystemInstructions(
+  const instructions = !omitAdditionalInstructions ? mergeSystemInstructions(
     originalSystemInstruction,
     getAdditionalInstructions({ maxSteps, allowSubmit, tools })
   ) : originalSystemInstruction;
-  return new Agent({
+  return {
     ...agentSettings,
-    system,
+    instructions,
     prepareStep,
     stopWhen
-  });
+  };
+}
+function createCodeAgentTools(agentToolsConfig, originalTools) {
+  if ("environments" in agentToolsConfig) {
+    const { environments, environmentToolsDefinition } = agentToolsConfig;
+    const environmentTools = {};
+    for (const [environmentName, environment] of Object.entries(environments)) {
+      if (!(environmentName in environmentToolsDefinition)) {
+        throw new Error(
+          `No tools definition provided for environment "${environmentName}". Please provide a tools definition for each environment.`
+        );
+      }
+      const envTools = createToolsForNamedEnvironment(
+        environmentName,
+        environment,
+        environmentToolsDefinition[environmentName]
+      );
+      for (const [toolName, tool] of Object.entries(envTools)) {
+        if (toolName in environmentTools) {
+          throw new Error(
+            `Tool name conflict: The tool name "${toolName}" from environment "${environmentName}" is already used by another environment's tools.`
+          );
+        }
+        environmentTools[toolName] = tool;
+      }
+    }
+    return originalTools ? mergeTools(environmentTools, originalTools) : environmentTools;
+  }
+  if ("environment" in agentToolsConfig) {
+    const { environment, environmentToolsDefinition } = agentToolsConfig;
+    const environmentTools = createToolsForEnvironment(
+      environment,
+      environmentToolsDefinition
+    );
+    return originalTools ? mergeTools(environmentTools, originalTools) : environmentTools;
+  }
+  throw new Error(
+    'No environments provided in agent tools configuration. Please provide either "environment" or "environments".'
+  );
 }
 function mergeTools(baseTools, additionalTools) {
   const tools = { ...baseTools };
@@ -2499,9 +2585,26 @@ function mergeStopWhen(baseStopWhen, additionalStopWhen) {
   }
   return [baseStopWhen, additionalStopWhen];
 }
-function mergeSystemInstructions(baseSystem, additionalInstructions) {
-  if (baseSystem) {
-    return `${baseSystem.trimEnd()}
+function mergeSystemInstructions(baseInstructions, additionalInstructions) {
+  if (baseInstructions) {
+    if (Array.isArray(baseInstructions)) {
+      return [
+        ...baseInstructions,
+        {
+          role: "system",
+          content: additionalInstructions
+        }
+      ];
+    }
+    if (typeof baseInstructions === "object") {
+      return {
+        ...baseInstructions,
+        content: `${baseInstructions.content.trimEnd()}
+
+${additionalInstructions}`
+      };
+    }
+    return `${baseInstructions.trimEnd()}
 
 ${additionalInstructions}`;
   }
@@ -2526,12 +2629,10 @@ function createEnvironment(environmentName, config) {
   return new EnvironmentClass(config);
 }
 export {
-  CopyFileResult,
   CopyFileTool,
   CopyFileToolInput,
   CopyFileToolName,
   CopyFileToolOutput,
-  DeleteFileResult,
   DeleteFileTool,
   DeleteFileToolInput,
   DeleteFileToolName,
@@ -2553,20 +2654,22 @@ export {
   GlobToolInput,
   GlobToolName,
   GlobToolOutput,
+  GrepTool,
+  GrepToolInput,
+  GrepToolName,
+  GrepToolOutput,
   ListDirectoryTool,
   ListDirectoryToolInput,
   ListDirectoryToolName,
   ListDirectoryToolOutput,
   MockFilesystemEnvironment,
   MockFilesystemEnvironmentName,
-  MoveFileResult,
   MoveFileTool,
   MoveFileToolInput,
   MoveFileToolName,
   MoveFileToolOutput,
   NodeFilesystemEnvironment,
   NodeFilesystemEnvironmentName,
-  ReadFileResult,
   ReadFileTool,
   ReadFileToolInput,
   ReadFileToolName,
@@ -2575,7 +2678,6 @@ export {
   ReadManyFilesToolInput,
   ReadManyFilesToolName,
   ReadManyFilesToolOutput,
-  RunCommandResult,
   RunCommandTool,
   RunCommandToolInput,
   RunCommandToolName,
@@ -2586,12 +2688,13 @@ export {
   SubmitToolOutput,
   UnsafeLocalEnvironment,
   UnsafeLocalEnvironmentName,
-  WriteFileResult,
   WriteFileTool,
   WriteFileToolInput,
   WriteFileToolName,
   WriteFileToolOutput,
   createCodeAgent,
+  createCodeAgentSettings,
+  createCodeAgentTools,
   createEnvironment,
   createEnvironmentTool,
   createToolsForEnvironment,