wave-agent-sdk 0.0.1

package/src/tools/deleteFileTool.ts

@@ -0,0 +1,81 @@
+import { unlink } from "fs/promises";
+import type { ToolPlugin, ToolResult, ToolContext } from "./types.js";
+import { resolvePath, getDisplayPath } from "../utils/path.js";
+
+/**
+ * Delete file tool plugin
+ */
+export const deleteFileTool: ToolPlugin = {
+  name: "Delete",
+  config: {
+    type: "function",
+    function: {
+      name: "Delete",
+      description: `Deletes a file at the specified path. The operation will fail gracefully if:
+    - The file doesn't exist
+    - The operation is rejected for security reasons
+    - The file cannot be deleted`,
+      parameters: {
+        type: "object",
+        properties: {
+          target_file: {
+            type: "string",
+            description:
+              "The path of the file to delete, relative to the workspace root.",
+          },
+        },
+        required: ["target_file"],
+      },
+    },
+  },
+  execute: async (
+    args: Record<string, unknown>,
+    context: ToolContext,
+  ): Promise<ToolResult> => {
+    const targetFile = args.target_file as string;
+
+    if (!targetFile || typeof targetFile !== "string") {
+      return {
+        success: false,
+        content: "",
+        error: "target_file parameter is required and must be a string",
+      };
+    }
+
+    try {
+      const filePath = resolvePath(targetFile, context.workdir);
+
+      // Delete file
+      await unlink(filePath);
+
+      // logger.info(`Successfully deleted file: ${filePath}`);
+
+      return {
+        success: true,
+        content: `Successfully deleted file: ${targetFile}`,
+        shortResult: "File deleted",
+      };
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+        return {
+          success: false,
+          content: "",
+          error: `File does not exist: ${targetFile}`,
+        };
+      }
+
+      return {
+        success: false,
+        content: "",
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  },
+  formatCompactParams: (
+    params: Record<string, unknown>,
+    context: ToolContext,
+  ) => {
+    const targetFile = params.target_file as string;
+    return getDisplayPath(targetFile || "", context.workdir);
+  },
+};

package/src/tools/editTool.ts

@@ -0,0 +1,192 @@
+import { readFile, writeFile } from "fs/promises";
+import type { ToolPlugin, ToolResult, ToolContext } from "./types.js";
+import { resolvePath, getDisplayPath } from "../utils/path.js";
+import { diffLines } from "diff";
+
+/**
+ * Format compact parameter display
+ */
+function formatCompactParams(
+  args: Record<string, unknown>,
+  context: ToolContext,
+): string {
+  const filePath = args.file_path as string;
+  return getDisplayPath(filePath || "", context.workdir);
+}
+
+/**
+ * Single file edit tool plugin
+ */
+export const editTool: ToolPlugin = {
+  name: "Edit",
+  formatCompactParams,
+  config: {
+    type: "function",
+    function: {
+      name: "Edit",
+      description:
+        "Performs exact string replacements in files. \n\nUsage:\n- You must use your `Read` tool at least once in the conversation before editing. This tool will error if you attempt an edit without reading the file. \n- When editing text from read_file tool output, ensure you preserve the exact indentation (tabs/spaces) as it appears AFTER the line number prefix. The line number prefix format is: spaces + line number + tab. Everything after that tab is the actual file content to match. Never include any part of the line number prefix in the old_string or new_string.\n- ALWAYS prefer editing existing files in the codebase. NEVER write new files unless explicitly required.\n- Only use emojis if the user explicitly requests it. Avoid adding emojis to files unless asked.\n- The edit will FAIL if `old_string` is not unique in the file. Either provide a larger string with more surrounding context to make it unique or use `replace_all` to change every instance of `old_string`. \n- Use `replace_all` for replacing and renaming strings across the file. This parameter is useful if you want to rename a variable for instance.",
+      parameters: {
+        type: "object",
+        properties: {
+          file_path: {
+            type: "string",
+            description: "The absolute path to the file to modify",
+          },
+          old_string: {
+            type: "string",
+            description: "The text to replace",
+          },
+          new_string: {
+            type: "string",
+            description:
+              "The text to replace it with (must be different from old_string)",
+          },
+          replace_all: {
+            type: "boolean",
+            default: false,
+            description: "Replace all occurences of old_string (default false)",
+          },
+        },
+        required: ["file_path", "old_string", "new_string"],
+        additionalProperties: false,
+      },
+    },
+  },
+  execute: async (
+    args: Record<string, unknown>,
+    context: ToolContext,
+  ): Promise<ToolResult> => {
+    const filePath = args.file_path as string;
+    const oldString = args.old_string as string;
+    const newString = args.new_string as string;
+    const replaceAll = (args.replace_all as boolean) || false;
+
+    // Validate required parameters
+    if (!filePath || typeof filePath !== "string") {
+      return {
+        success: false,
+        content: "",
+        error: "file_path parameter is required and must be a string",
+      };
+    }
+
+    if (typeof oldString !== "string") {
+      return {
+        success: false,
+        content: "",
+        error: "old_string parameter is required and must be a string",
+      };
+    }
+
+    if (typeof newString !== "string") {
+      return {
+        success: false,
+        content: "",
+        error: "new_string parameter is required and must be a string",
+      };
+    }
+
+    if (oldString === newString) {
+      return {
+        success: false,
+        content: "",
+        error: "old_string and new_string must be different",
+      };
+    }
+
+    try {
+      const resolvedPath = resolvePath(filePath, context.workdir);
+
+      // Read file content
+      let originalContent: string;
+      try {
+        originalContent = await readFile(resolvedPath, "utf-8");
+      } catch (readError) {
+        return {
+          success: false,
+          content: "",
+          error: `Failed to read file: ${readError instanceof Error ? readError.message : String(readError)}`,
+        };
+      }
+
+      // Check if old_string exists
+      if (!originalContent.includes(oldString)) {
+        return {
+          success: false,
+          content: "",
+          error: `old_string not found in file`,
+        };
+      }
+
+      let newContent: string;
+      let replacementCount: number;
+
+      if (replaceAll) {
+        // Replace all matches
+        const regex = new RegExp(escapeRegExp(oldString), "g");
+        newContent = originalContent.replace(regex, newString);
+        replacementCount = (originalContent.match(regex) || []).length;
+      } else {
+        // Replace only the first match, but first check if it's unique
+        const matches = originalContent.split(oldString).length - 1;
+        if (matches > 1) {
+          return {
+            success: false,
+            content: "",
+            error: `old_string appears ${matches} times in the file. Either provide a larger string with more surrounding context to make it unique or use replace_all=true to change every instance.`,
+          };
+        }
+
+        newContent = originalContent.replace(oldString, newString);
+        replacementCount = 1;
+      }
+
+      // Write file
+      try {
+        await writeFile(resolvedPath, newContent, "utf-8");
+      } catch (writeError) {
+        return {
+          success: false,
+          content: "",
+          error: `Failed to write file: ${writeError instanceof Error ? writeError.message : String(writeError)}`,
+        };
+      }
+
+      // Generate diff information
+      const diffResult = diffLines(originalContent, newContent);
+
+      const shortResult = replaceAll
+        ? `Replaced ${replacementCount} instances`
+        : "Text replaced successfully";
+
+      // logger.info(`Edit tool: ${shortResult}`);
+
+      return {
+        success: true,
+        content: shortResult,
+        shortResult,
+        filePath: resolvedPath,
+        originalContent,
+        newContent,
+        diffResult,
+      };
+    } catch (error) {
+      const errorMessage =
+        error instanceof Error ? error.message : String(error);
+      // logger.error(`Edit tool error: ${errorMessage}`);
+      return {
+        success: false,
+        content: "",
+        error: errorMessage,
+      };
+    }
+  },
+};
+
+/**
+ * Escape regular expression special characters
+ */
+function escapeRegExp(string: string): string {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/src/tools/globTool.ts

@@ -0,0 +1,135 @@
+import { glob } from "glob";
+import { stat } from "fs/promises";
+import type { ToolPlugin, ToolResult, ToolContext } from "./types.js";
+import { resolvePath, getDisplayPath } from "../utils/path.js";
+import { getGlobIgnorePatterns } from "../utils/fileFilter.js";
+
+/**
+ * Glob Tool Plugin - Fast file pattern matching
+ */
+export const globTool: ToolPlugin = {
+  name: "Glob",
+  config: {
+    type: "function",
+    function: {
+      name: "Glob",
+      description:
+        '- Fast file pattern matching tool that works with any codebase size\n- Supports glob patterns like "**/*.js" or "src/**/*.ts"\n- Returns matching file paths sorted by modification time\n- Use this tool when you need to find files by name patterns\n- When you are doing an open ended search that may require multiple rounds of globbing and grepping, use the Agent tool instead\n- You have the capability to call multiple tools in a single response. It is always better to speculatively perform multiple searches as a batch that are potentially useful.',
+      parameters: {
+        type: "object",
+        properties: {
+          pattern: {
+            type: "string",
+            description: "The glob pattern to match files against",
+          },
+          path: {
+            type: "string",
+            description:
+              'The directory to search in. If not specified, the current working directory will be used. IMPORTANT: Omit this field to use the default directory. DO NOT enter "undefined" or "null" - simply omit it for the default behavior. Must be a valid directory path if provided.',
+          },
+        },
+        required: ["pattern"],
+      },
+    },
+  },
+  execute: async (
+    args: Record<string, unknown>,
+    context: ToolContext,
+  ): Promise<ToolResult> => {
+    const pattern = args.pattern as string;
+    const searchPath = args.path as string;
+
+    if (!pattern || typeof pattern !== "string") {
+      return {
+        success: false,
+        content: "",
+        error: "pattern parameter is required and must be a string",
+      };
+    }
+
+    try {
+      // Determine search directory
+      const workdir = searchPath
+        ? resolvePath(searchPath, context.workdir)
+        : context.workdir;
+
+      // Execute glob search
+      const matches = await glob(pattern, {
+        cwd: workdir,
+        ignore: getGlobIgnorePatterns(workdir),
+        dot: false,
+        absolute: false,
+        nocase: false, // Keep case sensitive
+      });
+
+      if (matches.length === 0) {
+        return {
+          success: true,
+          content: "No files match the pattern",
+          shortResult: "No matches found",
+        };
+      }
+
+      // Get file modification time and sort
+      const filesWithStats = await Promise.allSettled(
+        matches.map(async (file) => {
+          try {
+            const fullPath = resolvePath(file, context.workdir);
+            const stats = await stat(fullPath);
+            return {
+              path: file,
+              mtime: stats.mtime,
+            };
+          } catch {
+            // If unable to get file stats, use current time
+            return {
+              path: file,
+              mtime: new Date(),
+            };
+          }
+        }),
+      );
+
+      // Filter successful results and sort by modification time
+      const sortedFiles = filesWithStats
+        .filter((result) => result.status === "fulfilled")
+        .map(
+          (result) =>
+            (result as PromiseFulfilledResult<{ path: string; mtime: Date }>)
+              .value,
+        )
+        .sort((a, b) => b.mtime.getTime() - a.mtime.getTime()) // Most recently modified files first
+        .map((item) => item.path);
+
+      // Format output
+      const output = sortedFiles
+        .map((file, index) => `${index + 1}. ${file}`)
+        .join("\n");
+
+      return {
+        success: true,
+        content: output,
+        shortResult: `Found ${sortedFiles.length} file${sortedFiles.length === 1 ? "" : "s"}`,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        content: "",
+        error: `Glob search failed: ${error instanceof Error ? error.message : String(error)}`,
+      };
+    }
+  },
+  formatCompactParams: (
+    params: Record<string, unknown>,
+    context: ToolContext,
+  ) => {
+    const pattern = params.pattern as string;
+    const path = params.path as string;
+
+    if (path) {
+      const displayPath = getDisplayPath(path, context.workdir);
+      return `${pattern} in ${displayPath}`;
+    }
+    return pattern || "";
+  },
+};