wave-agent-sdk 1.0.5 → 1.0.6

package/src/tools/globTool.ts

@@ -1,167 +0,0 @@
-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 { GLOB_TOOL_NAME } from "../constants/tools.js";
-
-/**
- * Maximum number of files returned by glob tool
- */
-const MAX_GLOB_RESULTS = 100;
-
-/**
- * Glob Tool Plugin - Fast file pattern matching
- */
-export const globTool: ToolPlugin = {
-  name: GLOB_TOOL_NAME,
-  config: {
-    type: "function",
-    function: {
-      name: GLOB_TOOL_NAME,
-      description:
-        "Fast file pattern matching tool that works with any codebase size",
-      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.',
-          },
-          limit: {
-            type: "number",
-            description: "Maximum number of files to return. Defaults to 100.",
-          },
-        },
-        required: ["pattern"],
-      },
-    },
-  },
-  prompt:
-    () => `- Fast file pattern matching tool that works with any codebase size
-- Supports glob patterns like "**/*.js" or "src/**/*.ts"
-- Returns matching file paths sorted by modification time
-- Use this tool when you need to find files by name patterns
-- When you are doing an open ended search that may require multiple rounds of globbing and grepping, use the Agent tool instead
-- You can call multiple tools in a single response. It is always better to speculatively perform multiple searches in parallel if they are potentially useful.`,
-  execute: async (
-    args: Record<string, unknown>,
-    context: ToolContext,
-  ): Promise<ToolResult> => {
-    const pattern = args.pattern as string;
-    const searchPath = args.path as string;
-    const limit = (args.limit as number) || MAX_GLOB_RESULTS;
-    const startTime = Date.now();
-
-    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 using glob package
-      const matches = await glob(pattern, {
-        cwd: workdir,
-        nodir: true,
-        dot: true,
-        ignore: ["**/.git/**"],
-      });
-
-      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, 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);
-
-      const totalCount = sortedFiles.length;
-      const finalFiles = sortedFiles.slice(0, limit);
-
-      // Format output
-      const output = finalFiles
-        .map((file, index) => `${index + 1}. ${file}`)
-        .join("\n");
-
-      const isTruncated = totalCount > limit;
-      const shortResult = isTruncated
-        ? `Found ${totalCount} files (showing first ${limit})`
-        : `Found ${totalCount} file${totalCount === 1 ? "" : "s"}`;
-
-      const durationMs = Date.now() - startTime;
-
-      return {
-        success: true,
-        content: output,
-        shortResult,
-        metadata: {
-          durationMs,
-          numFiles: totalCount,
-          truncated: isTruncated,
-        },
-      };
-    } 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 || "";
-  },
-};

package/src/tools/grepTool.ts

@@ -1,399 +0,0 @@
-import type { ToolPlugin, ToolResult, ToolContext } from "./types.js";
-import { spawn } from "child_process";
-import { rgPath } from "../utils/ripgrep.js";
-import { getDisplayPath } from "../utils/path.js";
-import { logger } from "../utils/globalLogger.js";
-import {
-  GREP_TOOL_NAME,
-  BASH_TOOL_NAME,
-  AGENT_TOOL_NAME,
-} from "../constants/tools.js";
-
-// Version control system directories to exclude from searches.
-// These are excluded automatically because they create noise in search results.
-// Mirrors Claude Code's VCS_DIRECTORIES_TO_EXCLUDE.
-const VCS_DIRECTORIES_TO_EXCLUDE = [
-  ".git",
-  ".svn",
-  ".hg",
-  ".bzr",
-  ".jj",
-  ".sl",
-] as const;
-
-/**
- * Grep tool plugin - powerful search tool based on ripgrep
- */
-export const grepTool: ToolPlugin = {
-  name: GREP_TOOL_NAME,
-  config: {
-    type: "function",
-    function: {
-      name: GREP_TOOL_NAME,
-      description: "A powerful search tool built on ripgrep",
-      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. Defaults to true.',
-          },
-          "-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). Defaults to 0 (unlimited).',
-          },
-          multiline: {
-            type: "boolean",
-            description:
-              "Enable multiline mode where . matches newlines and patterns can span lines (rg -U --multiline-dotall). Default: false.",
-          },
-          offset: {
-            type: "number",
-            description: "The number of matches to skip.",
-          },
-          context: {
-            type: "number",
-            description:
-              'Alias for -C. Number of lines to show before and after each match. Requires output_mode: "content", ignored otherwise.',
-          },
-        },
-        required: ["pattern"],
-      },
-    },
-  },
-  prompt: () => `A powerful search tool built on ripgrep
-
-  Usage:
-  - ALWAYS use ${GREP_TOOL_NAME} for search tasks. NEVER invoke \`grep\` or \`rg\` as a ${BASH_TOOL_NAME} command. The ${GREP_TOOL_NAME} tool has been optimized for correct permissions and access.
-  - Supports full regex syntax (e.g., "log.*Error", "function\\s+\\w+")
-  - Filter files with glob parameter (e.g., "*.js", "**/*.tsx") or type parameter (e.g., "js", "py", "rust")
-  - Output modes: "content" shows matching lines, "files_with_matches" shows only file paths (default), "count" shows match counts
-  - Use ${AGENT_TOOL_NAME} tool for open-ended searches requiring multiple rounds
-  - Pattern syntax: Uses ripgrep (not grep) - literal braces need escaping (use \`interface\\{\\}\` to find \`interface{}\` in Go code)
-  - Multiline matching: By default patterns match within single lines only. For cross-line patterns like \`struct \\{[\\s\\S]*?field\`, use \`multiline: true\`
-`,
-  execute: async (
-    args: Record<string, unknown>,
-    context: ToolContext,
-  ): Promise<ToolResult> => {
-    const pattern = args.pattern as string;
-    const searchPath = args.path as string;
-    const globPattern = args.glob as string;
-    const outputMode = (args.output_mode as string) || "files_with_matches";
-    const contextBefore = args["-B"] as number;
-    const contextAfter = args["-A"] as number;
-    const contextAround = args["-C"] as number;
-    const showLineNumbers = args["-n"] !== false;
-    const caseInsensitive = args["-i"] as boolean;
-    const fileType = args.type as string;
-    const headLimit = args.head_limit as number;
-    const multiline = args.multiline as boolean;
-    const offset = args.offset as number;
-    const contextArg = args.context as number;
-
-    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: string[] = [
-        "--color=never",
-        "--max-columns=500",
-        // Search hidden files/directories by default (aligns with Claude Code).
-        // --hidden does NOT disable .gitignore; only --no-ignore would.
-        "--hidden",
-      ];
-
-      // Exclude VCS directories to avoid noise from version control metadata.
-      // --hidden above would otherwise traverse .git/.svn/etc.
-      for (const dir of VCS_DIRECTORIES_TO_EXCLUDE) {
-        rgArgs.push("--glob", `!${dir}`);
-      }
-
-      // 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") {
-        const effectiveContext = contextArg ?? contextAround;
-        if (effectiveContext) {
-          rgArgs.push("-C", effectiveContext.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);
-      }
-
-      // 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);
-
-      // Only a process-level spawn failure (exitCode null) is a hard error.
-      // rg exit 2 means some files were unreadable (e.g. device-name files
-      // like "nul" on Windows); stdout still holds usable partial results.
-      if (result.exitCode === null) {
-        return {
-          success: false,
-          content: "",
-          error: `ripgrep failed: ${result.stderr}`,
-        };
-      }
-
-      if (result.exitCode !== 0 && result.exitCode !== 1) {
-        logger.debug(
-          `ripgrep exited with code ${result.exitCode}, keeping partial results: ${result.stderr.trim()}`,
-        );
-      }
-
-      const output = result.stdout.trim();
-      if (!output) {
-        return {
-          success: true,
-          content:
-            "No matches found. Suggestion: specify the 'path' field to search in ignored or other directories (e.g., 'node_modules'), as the default search path is the current working directory and respects .gitignore.",
-          shortResult: "No matches found",
-          metadata: {
-            numMatches: 0,
-          },
-        };
-      }
-
-      let lines = output.split("\n");
-      const totalMatches = lines.length;
-
-      // Apply offset
-      const effectiveOffset = offset || 0;
-      if (effectiveOffset > 0) {
-        lines = lines.slice(effectiveOffset);
-      }
-
-      // Apply head_limit
-      const effectiveHeadLimit = headLimit || 0;
-      let truncated = false;
-      if (effectiveHeadLimit > 0 && lines.length > effectiveHeadLimit) {
-        lines = lines.slice(0, effectiveHeadLimit);
-        truncated = true;
-      }
-
-      const finalOutput = lines.join("\n");
-
-      // Generate short result
-      let shortResult: string;
-      const numMatches = lines.length;
-
-      if (outputMode === "files_with_matches") {
-        shortResult = `Found ${numMatches} file${numMatches === 1 ? "" : "s"}`;
-      } else if (outputMode === "count") {
-        shortResult = `Match counts for ${numMatches} file${numMatches === 1 ? "" : "s"}`;
-      } else {
-        shortResult = `Found ${numMatches} matching line${numMatches === 1 ? "" : "s"}`;
-      }
-
-      if (effectiveOffset > 0 || truncated) {
-        shortResult += ` (showing ${numMatches} of ${totalMatches})`;
-      }
-
-      return {
-        success: true,
-        content: finalOutput,
-        shortResult,
-        metadata: {
-          numMatches: totalMatches,
-          truncated,
-          appliedLimit: effectiveHeadLimit,
-          appliedOffset: effectiveOffset,
-        },
-      };
-    } catch (error) {
-      return {
-        success: false,
-        content: "",
-        error: `Search failed: ${error instanceof Error ? error.message : String(error)}`,
-      };
-    }
-  },
-  formatCompactParams: (
-    params: Record<string, unknown>,
-    context: ToolContext,
-  ) => {
-    const pattern = params.pattern as string;
-    const outputMode = params.output_mode as string;
-    const fileType = params.type as string;
-    const path = params.path as string;
-
-    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: string,
-  args: string[],
-  cwd: string,
-): Promise<{
-  stdout: string;
-  stderr: string;
-  exitCode: number | null;
-  error: boolean;
-}> {
-  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,
-      });
-    });
-  });
-}