wave-agent-sdk 0.0.1

package/dist/tools/bashTool.js

@@ -0,0 +1,351 @@
+import { spawn } from "child_process";
+/**
+ * Bash command execution tool - supports both foreground and background execution
+ */
+export const bashTool = {
+    name: "Bash",
+    config: {
+        type: "function",
+        function: {
+            name: "Bash",
+            description: "Executes a given bash command in a persistent shell session with optional timeout, ensuring proper handling and security measures.",
+            parameters: {
+                type: "object",
+                properties: {
+                    command: {
+                        type: "string",
+                        description: "The command to execute",
+                    },
+                    timeout: {
+                        type: "number",
+                        description: "Optional timeout in milliseconds (max 600000)",
+                    },
+                    description: {
+                        type: "string",
+                        description: "Clear, concise description of what this command does in 5-10 words.",
+                    },
+                    run_in_background: {
+                        type: "boolean",
+                        description: "Set to true to run this command in the background. Use BashOutput to read the output later.",
+                    },
+                },
+                required: ["command"],
+            },
+        },
+    },
+    execute: async (args, context) => {
+        const command = args.command;
+        const runInBackground = args.run_in_background;
+        // Set default timeout: 30s for foreground, no timeout for background
+        const timeout = args.timeout ??
+            (runInBackground ? undefined : 30000);
+        if (!command || typeof command !== "string") {
+            return {
+                success: false,
+                content: "",
+                error: "Command parameter is required and must be a string",
+            };
+        }
+        // Validate timeout
+        if (timeout !== undefined &&
+            (typeof timeout !== "number" || timeout < 0 || timeout > 600000)) {
+            return {
+                success: false,
+                content: "",
+                error: "Timeout must be a number between 0 and 600000 milliseconds",
+            };
+        }
+        if (runInBackground) {
+            // Background execution
+            const backgroundBashManager = context?.backgroundBashManager;
+            if (!backgroundBashManager) {
+                return {
+                    success: false,
+                    content: "",
+                    error: "Background bash manager not available",
+                };
+            }
+            const shellId = backgroundBashManager.startShell(command, timeout);
+            return {
+                success: true,
+                content: `Command started in background with ID: ${shellId}. Use BashOutput tool with bash_id="${shellId}" to monitor output.`,
+                shortResult: `Background process ${shellId} started`,
+            };
+        }
+        // Foreground execution (original behavior)
+        return new Promise((resolve) => {
+            const child = spawn(command, {
+                shell: true,
+                stdio: "pipe",
+                cwd: context.workdir,
+                env: {
+                    ...process.env,
+                },
+            });
+            let outputBuffer = "";
+            let errorBuffer = "";
+            let isAborted = false;
+            // Set up timeout
+            let timeoutHandle;
+            if (timeout && timeout > 0) {
+                timeoutHandle = setTimeout(() => {
+                    if (!isAborted) {
+                        handleAbort("Command timed out");
+                    }
+                }, timeout);
+            }
+            // Handle abort signal
+            const handleAbort = (reason = "Command execution was aborted") => {
+                if (!isAborted) {
+                    isAborted = true;
+                    if (timeoutHandle) {
+                        clearTimeout(timeoutHandle);
+                    }
+                    // Force terminate child process and its children
+                    if (child.pid) {
+                        try {
+                            // Try graceful termination of process group
+                            process.kill(-child.pid, "SIGTERM");
+                            // Set timeout for force kill
+                            setTimeout(() => {
+                                if (child.pid && !child.killed) {
+                                    try {
+                                        process.kill(-child.pid, "SIGKILL");
+                                    }
+                                    catch {
+                                        // logger.error("Failed to force kill process:", killError);
+                                    }
+                                }
+                            }, 1000);
+                        }
+                        catch {
+                            // If process group termination fails, try direct child process termination
+                            try {
+                                child.kill("SIGTERM");
+                                setTimeout(() => {
+                                    if (!child.killed) {
+                                        child.kill("SIGKILL");
+                                    }
+                                }, 1000);
+                            }
+                            catch {
+                                // logger.error("Failed to kill child process:", directKillError);
+                            }
+                        }
+                    }
+                    resolve({
+                        success: false,
+                        content: outputBuffer + (errorBuffer ? "\n" + errorBuffer : ""),
+                        error: reason,
+                    });
+                }
+            };
+            // Handle abort signal from context
+            if (context?.abortSignal) {
+                if (context.abortSignal.aborted) {
+                    handleAbort();
+                    return;
+                }
+                context.abortSignal.addEventListener("abort", () => handleAbort());
+            }
+            child.stdout?.on("data", (data) => {
+                if (!isAborted) {
+                    outputBuffer += data.toString();
+                }
+            });
+            child.stderr?.on("data", (data) => {
+                if (!isAborted) {
+                    errorBuffer += data.toString();
+                }
+            });
+            child.on("exit", (code) => {
+                if (!isAborted) {
+                    if (timeoutHandle) {
+                        clearTimeout(timeoutHandle);
+                    }
+                    const exitCode = code ?? 0;
+                    const combinedOutput = outputBuffer + (errorBuffer ? "\n" + errorBuffer : "");
+                    resolve({
+                        success: exitCode === 0,
+                        content: combinedOutput || `Command executed with exit code: ${exitCode}`,
+                        error: exitCode !== 0
+                            ? `Command failed with exit code: ${exitCode}`
+                            : undefined,
+                    });
+                }
+            });
+            child.on("error", (error) => {
+                if (!isAborted) {
+                    if (timeoutHandle) {
+                        clearTimeout(timeoutHandle);
+                    }
+                    resolve({
+                        success: false,
+                        content: "",
+                        error: `Failed to execute command: ${error.message}`,
+                    });
+                }
+            });
+        });
+    },
+    formatCompactParams: (params) => {
+        const command = params.command;
+        const runInBackground = params.run_in_background;
+        return `${command}${runInBackground ? " background" : ""}`;
+    },
+};
+/**
+ * BashOutput tool - retrieves output from background bash shells
+ */
+export const bashOutputTool = {
+    name: "BashOutput",
+    config: {
+        type: "function",
+        function: {
+            name: "BashOutput",
+            description: "Retrieves output from a running or completed background bash shell",
+            parameters: {
+                type: "object",
+                properties: {
+                    bash_id: {
+                        type: "string",
+                        description: "The ID of the background shell to retrieve output from",
+                    },
+                    filter: {
+                        type: "string",
+                        description: "Optional regular expression to filter the output lines. Only lines matching this regex will be included in the result. Any lines that do not match will no longer be available to read.",
+                    },
+                },
+                required: ["bash_id"],
+            },
+        },
+    },
+    execute: async (args, context) => {
+        const bashId = args.bash_id;
+        const filter = args.filter;
+        if (!bashId || typeof bashId !== "string") {
+            return {
+                success: false,
+                content: "",
+                error: "bash_id parameter is required and must be a string",
+            };
+        }
+        const backgroundBashManager = context?.backgroundBashManager;
+        if (!backgroundBashManager) {
+            return {
+                success: false,
+                content: "",
+                error: "Background bash manager not available",
+            };
+        }
+        const output = backgroundBashManager.getOutput(bashId, filter);
+        if (!output) {
+            return {
+                success: false,
+                content: "",
+                error: `Background shell with ID ${bashId} not found`,
+            };
+        }
+        const shell = backgroundBashManager.getShell(bashId);
+        if (!shell) {
+            return {
+                success: false,
+                content: "",
+                error: `Background shell with ID ${bashId} not found`,
+            };
+        }
+        let content = "";
+        if (output.stdout) {
+            content += output.stdout;
+        }
+        if (output.stderr) {
+            content += (content ? "\n" : "") + output.stderr;
+        }
+        return {
+            success: true,
+            content: content || "No output available",
+            shortResult: `${bashId}: ${output.status}${shell.exitCode !== undefined ? ` (${shell.exitCode})` : ""}`,
+            error: undefined,
+        };
+    },
+    formatCompactParams: (params) => {
+        const bashId = params.bash_id;
+        const filter = params.filter;
+        return filter ? `${bashId} filtered: ${filter}` : bashId;
+    },
+};
+/**
+ * KillBash tool - kills a running background bash shell
+ */
+export const killBashTool = {
+    name: "KillBash",
+    config: {
+        type: "function",
+        function: {
+            name: "KillBash",
+            description: "Kills a running background bash shell by its ID",
+            parameters: {
+                type: "object",
+                properties: {
+                    shell_id: {
+                        type: "string",
+                        description: "The ID of the background shell to kill",
+                    },
+                },
+                required: ["shell_id"],
+            },
+        },
+    },
+    execute: async (args, context) => {
+        const shellId = args.shell_id;
+        if (!shellId || typeof shellId !== "string") {
+            return {
+                success: false,
+                content: "",
+                error: "shell_id parameter is required and must be a string",
+            };
+        }
+        const backgroundBashManager = context?.backgroundBashManager;
+        if (!backgroundBashManager) {
+            return {
+                success: false,
+                content: "",
+                error: "Background bash manager not available",
+            };
+        }
+        const shell = backgroundBashManager.getShell(shellId);
+        if (!shell) {
+            return {
+                success: false,
+                content: "",
+                error: `Background shell with ID ${shellId} not found`,
+            };
+        }
+        if (shell.status !== "running") {
+            return {
+                success: false,
+                content: "",
+                error: `Background shell ${shellId} is not running (status: ${shell.status})`,
+            };
+        }
+        const killed = backgroundBashManager.killShell(shellId);
+        if (killed) {
+            return {
+                success: true,
+                content: `Background shell ${shellId} has been killed`,
+                shortResult: `Killed ${shellId}`,
+            };
+        }
+        else {
+            return {
+                success: false,
+                content: "",
+                error: `Failed to kill background shell ${shellId}`,
+            };
+        }
+    },
+    formatCompactParams: (params) => {
+        const shellId = params.shell_id;
+        return shellId;
+    },
+};

package/dist/tools/deleteFileTool.d.ts

@@ -0,0 +1,6 @@
+import type { ToolPlugin } from "./types.js";
+/**
+ * Delete file tool plugin
+ */
+export declare const deleteFileTool: ToolPlugin;
+//# sourceMappingURL=deleteFileTool.d.ts.map

package/dist/tools/deleteFileTool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deleteFileTool.d.ts","sourceRoot":"","sources":["../../src/tools/deleteFileTool.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAA2B,MAAM,YAAY,CAAC;AAGtE;;GAEG;AACH,eAAO,MAAM,cAAc,EAAE,UAyE5B,CAAC"}

package/dist/tools/deleteFileTool.js

@@ -0,0 +1,67 @@
+import { unlink } from "fs/promises";
+import { resolvePath, getDisplayPath } from "../utils/path.js";
+/**
+ * Delete file tool plugin
+ */
+export const deleteFileTool = {
+    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, context) => {
+        const targetFile = args.target_file;
+        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.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, context) => {
+        const targetFile = params.target_file;
+        return getDisplayPath(targetFile || "", context.workdir);
+    },
+};

package/dist/tools/editTool.d.ts

@@ -0,0 +1,6 @@
+import type { ToolPlugin } from "./types.js";
+/**
+ * Single file edit tool plugin
+ */
+export declare const editTool: ToolPlugin;
+//# sourceMappingURL=editTool.d.ts.map

package/dist/tools/editTool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"editTool.d.ts","sourceRoot":"","sources":["../../src/tools/editTool.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAA2B,MAAM,YAAY,CAAC;AAetE;;GAEG;AACH,eAAO,MAAM,QAAQ,EAAE,UAqKtB,CAAC"}

package/dist/tools/editTool.js

@@ -0,0 +1,168 @@
+import { readFile, writeFile } from "fs/promises";
+import { resolvePath, getDisplayPath } from "../utils/path.js";
+import { diffLines } from "diff";
+/**
+ * Format compact parameter display
+ */
+function formatCompactParams(args, context) {
+    const filePath = args.file_path;
+    return getDisplayPath(filePath || "", context.workdir);
+}
+/**
+ * Single file edit tool plugin
+ */
+export const editTool = {
+    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, context) => {
+        const filePath = args.file_path;
+        const oldString = args.old_string;
+        const newString = args.new_string;
+        const replaceAll = args.replace_all || 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;
+            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;
+            let replacementCount;
+            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) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/dist/tools/globTool.d.ts

@@ -0,0 +1,6 @@
+import type { ToolPlugin } from "./types.js";
+/**
+ * Glob Tool Plugin - Fast file pattern matching
+ */
+export declare const globTool: ToolPlugin;
+//# sourceMappingURL=globTool.d.ts.map

package/dist/tools/globTool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"globTool.d.ts","sourceRoot":"","sources":["../../src/tools/globTool.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAA2B,MAAM,YAAY,CAAC;AAItE;;GAEG;AACH,eAAO,MAAM,QAAQ,EAAE,UA6HtB,CAAC"}