wave-agent-sdk 0.0.1

package/dist/tools/globTool.js

@@ -0,0 +1,113 @@
+import { glob } from "glob";
+import { stat } from "fs/promises";
+import { resolvePath, getDisplayPath } from "../utils/path.js";
+import { getGlobIgnorePatterns } from "../utils/fileFilter.js";
+/**
+ * Glob Tool Plugin - Fast file pattern matching
+ */
+export const globTool = {
+    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, context) => {
+        const pattern = args.pattern;
+        const searchPath = args.path;
+        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
+                .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, context) => {
+        const pattern = params.pattern;
+        const path = params.path;
+        if (path) {
+            const displayPath = getDisplayPath(path, context.workdir);
+            return `${pattern} in ${displayPath}`;
+        }
+        return pattern || "";
+    },
+};

package/dist/tools/grepTool.d.ts

@@ -0,0 +1,6 @@
+import type { ToolPlugin } from "./types.js";
+/**
+ * Grep tool plugin - powerful search tool based on ripgrep
+ */
+export declare const grepTool: ToolPlugin;
+//# sourceMappingURL=grepTool.d.ts.map

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

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

package/dist/tools/grepTool.js

@@ -0,0 +1,268 @@
+import { spawn } from "child_process";
+import { getGlobIgnorePatterns } from "../utils/fileFilter.js";
+import { rgPath } from "@vscode/ripgrep";
+import { getDisplayPath } from "../utils/path.js";
+/**
+ * Grep tool plugin - powerful search tool based on ripgrep
+ */
+export const grepTool = {
+    name: "Grep",
+    config: {
+        type: "function",
+        function: {
+            name: "Grep",
+            description: 'A powerful search tool built on ripgrep\n\n  Usage:\n  - ALWAYS use Grep for search tasks. NEVER invoke `grep` or `rg` as a Bash command. The Grep tool has been optimized for correct permissions and access.\n  - Supports full regex syntax (e.g., "log.*Error", "function\\s+\\w+")\n  - Filter files with glob parameter (e.g., "*.js", "**/*.tsx") or type parameter (e.g., "js", "py", "rust")\n  - Output modes: "content" shows matching lines, "files_with_matches" shows only file paths (default), "count" shows match counts\n  - Use Task tool for open-ended searches requiring multiple rounds\n  - Pattern syntax: Uses ripgrep (not grep) - literal braces need escaping (use `interface\\{\\}` to find `interface{}` in Go code)\n  - Multiline matching: By default patterns match within single lines only. For cross-line patterns like `struct \\{[\\s\\S]*?field`, use `multiline: true`',
+            parameters: {
+                type: "object",
+                properties: {
+                    pattern: {
+                        type: "string",
+                        description: "The regular expression pattern to search for in file contents",
+                    },
+                    path: {
+                        type: "string",
+                        description: "File or directory to search in (rg PATH). Defaults to current working directory.",
+                    },
+                    glob: {
+                        type: "string",
+                        description: 'Glob pattern to filter files (e.g. "*.js", "*.{ts,tsx}") - maps to rg --glob',
+                    },
+                    output_mode: {
+                        type: "string",
+                        enum: ["content", "files_with_matches", "count"],
+                        description: 'Output mode: "content" shows matching lines (supports -A/-B/-C context, -n line numbers, head_limit), "files_with_matches" shows file paths (supports head_limit), "count" shows match counts (supports head_limit). Defaults to "files_with_matches".',
+                    },
+                    "-B": {
+                        type: "number",
+                        description: 'Number of lines to show before each match (rg -B). Requires output_mode: "content", ignored otherwise.',
+                    },
+                    "-A": {
+                        type: "number",
+                        description: 'Number of lines to show after each match (rg -A). Requires output_mode: "content", ignored otherwise.',
+                    },
+                    "-C": {
+                        type: "number",
+                        description: 'Number of lines to show before and after each match (rg -C). Requires output_mode: "content", ignored otherwise.',
+                    },
+                    "-n": {
+                        type: "boolean",
+                        description: 'Show line numbers in output (rg -n). Requires output_mode: "content", ignored otherwise.',
+                    },
+                    "-i": {
+                        type: "boolean",
+                        description: "Case insensitive search (rg -i)",
+                    },
+                    type: {
+                        type: "string",
+                        description: "File type to search (rg --type). Common types: js, py, rust, go, java, etc. More efficient than include for standard file types.",
+                    },
+                    head_limit: {
+                        type: "number",
+                        description: 'Limit output to first N lines/entries, equivalent to "| head -N". Works across all output modes: content (limits output lines), files_with_matches (limits file paths), count (limits count entries). When unspecified, shows all results from ripgrep.',
+                    },
+                    multiline: {
+                        type: "boolean",
+                        description: "Enable multiline mode where . matches newlines and patterns can span lines (rg -U --multiline-dotall). Default: false.",
+                    },
+                },
+                required: ["pattern"],
+            },
+        },
+    },
+    execute: async (args, context) => {
+        const pattern = args.pattern;
+        const searchPath = args.path;
+        const globPattern = args.glob;
+        const outputMode = args.output_mode || "files_with_matches";
+        const contextBefore = args["-B"];
+        const contextAfter = args["-A"];
+        const contextAround = args["-C"];
+        const showLineNumbers = args["-n"];
+        const caseInsensitive = args["-i"];
+        const fileType = args.type;
+        const headLimit = args.head_limit;
+        const multiline = args.multiline;
+        if (!pattern || typeof pattern !== "string") {
+            return {
+                success: false,
+                content: "",
+                error: "pattern parameter is required and must be a string",
+            };
+        }
+        if (!rgPath) {
+            return {
+                success: false,
+                content: "",
+                error: "ripgrep is not available. Please install @vscode/ripgrep package.",
+            };
+        }
+        try {
+            const workdir = context.workdir;
+            const rgArgs = ["--color=never"];
+            // Set output mode
+            if (outputMode === "files_with_matches") {
+                rgArgs.push("-l");
+            }
+            else if (outputMode === "count") {
+                rgArgs.push("-c");
+            }
+            // content mode is default, no special parameters needed
+            // Add line numbers (only effective in content mode)
+            if (showLineNumbers && outputMode === "content") {
+                rgArgs.push("-n");
+            }
+            // Add file names (in content mode)
+            if (outputMode === "content") {
+                rgArgs.push("-H");
+            }
+            // Case insensitive
+            if (caseInsensitive) {
+                rgArgs.push("-i");
+            }
+            // Multiline mode
+            if (multiline) {
+                rgArgs.push("-U", "--multiline-dotall");
+            }
+            // Context lines (only effective in content mode)
+            if (outputMode === "content") {
+                if (contextAround) {
+                    rgArgs.push("-C", contextAround.toString());
+                }
+                else {
+                    if (contextBefore) {
+                        rgArgs.push("-B", contextBefore.toString());
+                    }
+                    if (contextAfter) {
+                        rgArgs.push("-A", contextAfter.toString());
+                    }
+                }
+            }
+            // File type filtering
+            if (fileType) {
+                rgArgs.push("--type", fileType);
+            }
+            // Glob pattern filtering
+            if (globPattern) {
+                rgArgs.push("--glob", globPattern);
+            }
+            // Get common ignore rules
+            const ignorePatterns = getGlobIgnorePatterns(workdir);
+            for (const exclude of ignorePatterns) {
+                rgArgs.push("--glob", `!${exclude}`);
+            }
+            // Add search pattern - use -e parameter to avoid patterns starting with - being mistaken as command line options
+            rgArgs.push("-e", pattern);
+            // Add search path
+            if (searchPath) {
+                rgArgs.push(searchPath);
+            }
+            else {
+                rgArgs.push(".");
+            }
+            const result = await executeCommand(rgPath, rgArgs, workdir);
+            if (result.error && result.exitCode !== 1) {
+                // rg returns 1 for no matches, not an error
+                return {
+                    success: false,
+                    content: "",
+                    error: `ripgrep failed: ${result.stderr}`,
+                };
+            }
+            const output = result.stdout.trim();
+            if (!output) {
+                return {
+                    success: true,
+                    content: "No matches found",
+                    shortResult: "No matches found",
+                };
+            }
+            // Apply head_limit
+            let finalOutput = output;
+            let lines = output.split("\n");
+            if (headLimit && headLimit > 0 && lines.length > headLimit) {
+                lines = lines.slice(0, headLimit);
+                finalOutput = lines.join("\n");
+            }
+            // Generate short result
+            let shortResult;
+            const totalLines = output.split("\n").length;
+            if (outputMode === "files_with_matches") {
+                shortResult = `Found ${totalLines} file${totalLines === 1 ? "" : "s"}`;
+            }
+            else if (outputMode === "count") {
+                shortResult = `Match counts for ${totalLines} file${totalLines === 1 ? "" : "s"}`;
+            }
+            else {
+                shortResult = `Found ${totalLines} matching line${totalLines === 1 ? "" : "s"}`;
+            }
+            if (headLimit && totalLines > headLimit) {
+                shortResult += ` (showing first ${headLimit})`;
+            }
+            return {
+                success: true,
+                content: finalOutput,
+                shortResult,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                content: "",
+                error: `Search failed: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+    },
+    formatCompactParams: (params, context) => {
+        const pattern = params.pattern;
+        const outputMode = params.output_mode;
+        const fileType = params.type;
+        const path = params.path;
+        let result = pattern || "";
+        if (fileType) {
+            result += ` ${fileType}`;
+        }
+        if (path) {
+            const displayPath = getDisplayPath(path, context.workdir);
+            result += ` in ${displayPath}`;
+        }
+        if (outputMode && outputMode !== "files_with_matches") {
+            result += ` [${outputMode}]`;
+        }
+        return result;
+    },
+};
+/**
+ * Execute command and return result
+ */
+function executeCommand(command, args, cwd) {
+    return new Promise((resolve) => {
+        const child = spawn(command, args, {
+            cwd,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        child.stdout?.on("data", (data) => {
+            stdout += data.toString();
+        });
+        child.stderr?.on("data", (data) => {
+            stderr += data.toString();
+        });
+        child.on("close", (code) => {
+            resolve({
+                stdout,
+                stderr,
+                exitCode: code,
+                error: code !== 0 && code !== 1, // rg returns 1 for no matches, not an error
+            });
+        });
+        child.on("error", (err) => {
+            resolve({
+                stdout,
+                stderr: err.message,
+                exitCode: null,
+                error: true,
+            });
+        });
+    });
+}

package/dist/tools/lsTool.d.ts

@@ -0,0 +1,6 @@
+import type { ToolPlugin } from "./types.js";
+/**
+ * LS Tool Plugin - List files and directories
+ */
+export declare const lsTool: ToolPlugin;
+//# sourceMappingURL=lsTool.d.ts.map

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

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

package/dist/tools/lsTool.js

@@ -0,0 +1,160 @@
+import * as fs from "fs";
+import * as path from "path";
+import { minimatch } from "minimatch";
+import { isBinary, getDisplayPath } from "../utils/path.js";
+/**
+ * LS Tool Plugin - List files and directories
+ */
+export const lsTool = {
+    name: "LS",
+    config: {
+        type: "function",
+        function: {
+            name: "LS",
+            description: "Lists files and directories in a given path. The path parameter must be an absolute path, not a relative path. You can optionally provide an array of glob patterns to ignore with the ignore parameter. You should generally prefer the Glob and Grep tools, if you know which directories to search.",
+            parameters: {
+                type: "object",
+                properties: {
+                    path: {
+                        type: "string",
+                        description: "The absolute path to the directory to list (must be absolute, not relative)",
+                    },
+                    ignore: {
+                        type: "array",
+                        items: {
+                            type: "string",
+                        },
+                        description: "List of glob patterns to ignore",
+                    },
+                },
+                required: ["path"],
+            },
+        },
+    },
+    execute: async (args, context) => {
+        const targetPath = args.path;
+        const ignorePatterns = args.ignore;
+        // Note: context.workdir is not used as this tool requires absolute paths
+        void context.workdir;
+        if (!targetPath || typeof targetPath !== "string") {
+            return {
+                success: false,
+                content: "",
+                error: "path parameter is required and must be a string",
+            };
+        }
+        // Validate that the path is absolute
+        if (!path.isAbsolute(targetPath)) {
+            return {
+                success: false,
+                content: "",
+                error: "Path must be an absolute path, not a relative path",
+            };
+        }
+        try {
+            // Check if path exists and is a directory
+            const stats = await fs.promises.stat(targetPath);
+            if (!stats.isDirectory()) {
+                return {
+                    success: false,
+                    content: "",
+                    error: `Path ${targetPath} is not a directory`,
+                };
+            }
+            // Read directory contents
+            const entries = await fs.promises.readdir(targetPath, {
+                withFileTypes: true,
+            });
+            // Process directory items
+            const items = [];
+            for (const entry of entries) {
+                const entryPath = path.join(targetPath, entry.name);
+                // Check if it should be ignored
+                if (ignorePatterns && Array.isArray(ignorePatterns)) {
+                    const shouldIgnore = ignorePatterns.some((pattern) => minimatch(entry.name, pattern) || minimatch(entryPath, pattern));
+                    if (shouldIgnore) {
+                        continue;
+                    }
+                }
+                if (entry.isDirectory()) {
+                    items.push({
+                        name: entry.name,
+                        type: "directory",
+                    });
+                }
+                else if (entry.isFile()) {
+                    try {
+                        const fileStats = await fs.promises.stat(entryPath);
+                        items.push({
+                            name: entry.name,
+                            type: "file",
+                            size: fileStats.size,
+                        });
+                    }
+                    catch {
+                        // If file stats cannot be obtained, still add the file but do not display size
+                        items.push({
+                            name: entry.name,
+                            type: "file",
+                        });
+                    }
+                }
+                else if (entry.isSymbolicLink()) {
+                    items.push({
+                        name: entry.name,
+                        type: "symlink",
+                    });
+                }
+            }
+            // Sort: directories first, then files, both alphabetically
+            items.sort((a, b) => {
+                if (a.type === "directory" && b.type !== "directory")
+                    return -1;
+                if (a.type !== "directory" && b.type === "directory")
+                    return 1;
+                return a.name.localeCompare(b.name);
+            });
+            let content = `Directory: ${targetPath}\n`;
+            content += `Total items: ${items.length}\n\n`;
+            for (const item of items) {
+                let typeIndicator;
+                switch (item.type) {
+                    case "directory":
+                        typeIndicator = "📁";
+                        break;
+                    case "symlink":
+                        typeIndicator = "🔗";
+                        break;
+                    default:
+                        typeIndicator = "📄";
+                }
+                const sizeInfo = item.size !== undefined ? ` (${item.size} bytes)` : "";
+                const binaryInfo = item.type === "file" && isBinary(item.name) ? " [binary]" : "";
+                content += `${typeIndicator} ${item.name}${sizeInfo}${binaryInfo}\n`;
+            }
+            return {
+                success: true,
+                content: content.trim(),
+                shortResult: `${items.length} items (${items.filter((i) => i.type === "directory").length} dirs, ${items.filter((i) => i.type === "file").length} files)`,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                content: "",
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    },
+    formatCompactParams: (params, context) => {
+        const targetPath = params.path;
+        const ignorePatterns = params.ignore;
+        let result = getDisplayPath(targetPath || "", context.workdir);
+        if (ignorePatterns &&
+            Array.isArray(ignorePatterns) &&
+            ignorePatterns.length > 0) {
+            result += ` ignore: ${ignorePatterns.join(", ")}`;
+        }
+        return result;
+    },
+};

package/dist/tools/multiEditTool.d.ts

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

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

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