shared_tools 0.4.4 → 0.7.0

data/lib/shared_tools/tools/search_codebase_tool.rb

@@ -1,56 +1,85 @@
 # frozen_string_literal: true
 
-require "open3"
+require "find"
+require "pathname"
 
 module SharedTools
   module Tools
-    # Search for a term across files using ripgrep (rg) with grep as fallback.
+    # Search file contents for a regular expression under a directory and
+    # return "path:line: text" hits. Pure Ruby (no `rg`/`grep` dependency).
     # Read-only — no authorization prompt required.
     #
+    # The pattern comes from an LLM, so two abuse vectors are guarded against:
+    #   - ReDoS: the regex is compiled with a per-match timeout, so
+    #     catastrophic backtracking can't hang the process.
+    #   - Runaway scans: results are capped at max_results (default 50, max
+    #     500), and the walk skips binary files, symlinks, oversized files,
+    #     and common noise directories (.git, node_modules, tmp, ...).
+    #
     # @example
     #   tool = SharedTools::Tools::SearchCodebaseTool.new
-    #   tool.execute(term: "def execute")
-    #   tool.execute(term: "RubyLLM", extension: "rb", max_results: 20)
+    #   tool.execute(pattern: "def execute")
+    #   tool.execute(pattern: "RubyLLM", glob: "*.rb", max_results: 20)
+    #   tool.execute(pattern: "TODO", context: 2) # 2 lines of context around each match
     class SearchCodebaseTool < ::RubyLLM::Tool
       MAX_RESULTS_CAP = 500
-
-      def self.name = 'search_codebase'
-
-      description "Search for a term or pattern across files. Uses ripgrep (rg) when available, falls back to grep. Returns matching lines with file path and line number."
-
-      params do
-        string  :term,        description: "The search term or regex pattern to find"
+      DEFAULT_MAX_RESULTS = 50
+      MAX_FILE_BYTES = 5 * 1024 * 1024
+      MAX_CONTEXT = 50
+      REGEX_TIMEOUT = 2
+      IGNORED_DIRS = %w[.git .hg .svn node_modules .bundle tmp].freeze
+
+      def self.tool_name = 'search_codebase'
+
+      description "Search file contents for a regular expression under a directory. Returns " \
+                  "'path:line: text' for each match, or context blocks when context/before/after " \
+                  "is set. Optionally restrict to files whose name matches a glob, and/or match " \
+                  "case-insensitively. Results are capped, ReDoS-guarded, and require no external " \
+                  "search binary."
+
+      parameters do
+        string  :pattern,     description: "Regular expression to search for."
         string  :path,        description: "Directory to search in (default: current directory)", required: false
-        string  :extension,   description: "File extension to restrict the search to, without the dot (e.g. 'rb', 'js')", required: false
-        integer :max_results, description: "Maximum number of matching lines to return (default: 50, max: 500)", required: false
+        string  :glob,        description: "Only search files whose basename matches this glob, e.g. '*.rb'. Optional.", required: false
+        boolean :ignore_case, description: "Case-insensitive match. Default false.", required: false
+        integer :context,     description: "Lines of context to show before AND after each match (like grep -C). Optional.", required: false
+        integer :before,      description: "Lines of context before each match (like grep -B). Overrides context. Optional.", required: false
+        integer :after,       description: "Lines of context after each match (like grep -A). Overrides context. Optional.", required: false
+        integer :max_results, description: "Maximum number of matches to return (default #{DEFAULT_MAX_RESULTS}, max #{MAX_RESULTS_CAP}).", required: false
       end
 
       def initialize(logger: nil)
         @logger = logger || RubyLLM.logger
       end
 
-      def execute(term:, path: ".", extension: nil, max_results: 50)
-        @logger.info("SearchCodebaseTool#execute term=#{term.inspect} path=#{path} extension=#{extension.inspect}")
+      def execute(pattern:, path: ".", glob: nil, ignore_case: false, context: nil, before: nil, after: nil, max_results: DEFAULT_MAX_RESULTS)
+        @logger.info("SearchCodebaseTool#execute pattern=#{pattern.inspect} path=#{path} glob=#{glob.inspect}")
 
-        return { error: "Search term cannot be empty" } if term.strip.empty?
+        return { error: "Search pattern cannot be empty" } if pattern.to_s.strip.empty?
 
-        max_results = [[max_results.to_i, 1].max, MAX_RESULTS_CAP].min
         search_path = File.expand_path(path)
-
         return { error: "Path not found: #{path}" } unless File.exist?(search_path)
-
-        stdout, _stderr, _status = run_search(term: term, path: search_path, extension: extension)
-
-        all_lines  = stdout.lines.map(&:chomp).reject(&:empty?)
-        matches    = all_lines.first(max_results)
-        truncated  = all_lines.size > max_results
-
-        {
-          matches:   matches,
-          count:     matches.size,
-          truncated: truncated,
-          tool:      ripgrep_available? ? "rg" : "grep"
-        }
+        return { error: "Not a directory: #{path}" } unless File.directory?(search_path)
+
+        regex = build_regex(pattern, ignore_case)
+        max = [[max_results.to_i, 1].max, MAX_RESULTS_CAP].min
+        ctx_before = clamp_context(before.nil? ? context : before)
+        ctx_after  = clamp_context(after.nil? ? context : after)
+
+        matches, truncated =
+          if ctx_before.zero? && ctx_after.zero?
+            gather(search_path, regex, glob, max)
+          else
+            gather_with_context(search_path, regex, glob, ctx_before, ctx_after, max)
+          end
+
+        { matches: matches, count: matches.size, truncated: truncated, tool: "ruby" }
+      rescue Regexp::TimeoutError
+        @logger.error("SearchCodebaseTool regex timed out: #{pattern.inspect}")
+        { error: "regex timed out (possible catastrophic backtracking); simplify the pattern" }
+      rescue RegexpError => e
+        @logger.error("SearchCodebaseTool invalid regex: #{e.message}")
+        { error: "invalid regex: #{e.message}" }
       rescue => e
         @logger.error("SearchCodebaseTool error: #{e.message}")
         { error: e.message }
@@ -58,33 +87,135 @@ module SharedTools
 
       private
 
-      def run_search(term:, path:, extension:)
-        if ripgrep_available?
-          run_ripgrep(term: term, path: path, extension: extension)
-        else
-          run_grep(term: term, path: path, extension: extension)
+      def build_regex(pattern, ignore_case)
+        options = ignore_case ? Regexp::IGNORECASE : 0
+        Regexp.new(pattern.to_s, options, timeout: REGEX_TIMEOUT)
+      end
+
+      def clamp_context(value)
+        n = value.to_i
+        return 0 if n <= 0
+
+        [n, MAX_CONTEXT].min
+      end
+
+      def gather(root, regex, glob, max)
+        base = Pathname.new(root)
+        matches = []
+        truncated = false
+
+        catch(:done) do
+          walk(root, glob) do |file|
+            scan(file, regex) do |lineno, text|
+              rel = Pathname.new(file).relative_path_from(base).to_s
+              matches << "#{rel}:#{lineno}: #{text.strip}"
+              if matches.size >= max
+                truncated = true
+                throw :done
+              end
+            end
+          end
         end
+
+        [matches, truncated]
       end
 
-      def run_ripgrep(term:, path:, extension:)
-        args = ["rg", "--no-heading", "-n"]
-        args += ["-g", "*.#{extension}"] if extension
-        args << term
-        args << path
-        Open3.capture3(*args)
+      # Like gather, but expands each match with before/after context lines,
+      # merges overlapping/adjacent ranges per file, and returns formatted
+      # blocks. Match lines use "path:line: text"; context lines use
+      # "path-line- text".
+      def gather_with_context(root, regex, glob, ctx_before, ctx_after, max)
+        base = Pathname.new(root)
+        blocks = []
+        total = 0
+        truncated = false
+
+        catch(:done) do
+          walk(root, glob) do |file|
+            next if binary?(file)
+
+            lines = read_lines(file)
+            next if lines.nil?
+
+            match_idxs = []
+            lines.each_with_index { |line, i| match_idxs << i if regex.match?(line) }
+            next if match_idxs.empty?
+
+            taken = match_idxs.first(max - total)
+            truncated = true if taken.size < match_idxs.size
+            match_set = {}
+            taken.each { |i| match_set[i] = true }
+
+            rel = Pathname.new(file).relative_path_from(base).to_s
+            ranges = taken.map { |i| [[i - ctx_before, 0].max, [i + ctx_after, lines.size - 1].min] }
+            merge_ranges(ranges).each do |lo, hi|
+              block = (lo..hi).map do |i|
+                sep = match_set[i] ? ":" : "-"
+                "#{rel}#{sep}#{i + 1}#{sep} #{lines[i].to_s.strip}"
+              end
+              blocks << block.join("\n")
+            end
+
+            total += taken.size
+            throw :done if total >= max
+          end
+        end
+
+        [blocks, truncated]
+      end
+
+      def read_lines(file)
+        File.readlines(file).map(&:scrub)
+      rescue ArgumentError, SystemCallError
+        nil
+      end
+
+      def merge_ranges(ranges)
+        merged = []
+        ranges.sort_by(&:first).each do |lo, hi|
+          if !merged.empty? && lo <= merged.last[1] + 1
+            merged.last[1] = [merged.last[1], hi].max
+          else
+            merged << [lo, hi]
+          end
+        end
+        merged
+      end
+
+      def walk(root, glob)
+        Find.find(root) do |entry|
+          basename = File.basename(entry)
+
+          if File.directory?(entry)
+            Find.prune if IGNORED_DIRS.include?(basename)
+            next
+          end
+
+          next if File.symlink?(entry)
+          next if glob && !File.fnmatch?(glob, basename, File::FNM_PATHNAME)
+          next unless File.file?(entry)
+          next if File.size(entry) > MAX_FILE_BYTES
+
+          yield entry
+        end
       end
 
-      def run_grep(term:, path:, extension:)
-        args = ["grep", "-r", "-n"]
-        args += ["--include=*.#{extension}"] if extension
-        args << term
-        args << path
-        Open3.capture3(*args)
+      def scan(file, regex)
+        return if binary?(file)
+
+        File.foreach(file).with_index(1) do |line, lineno|
+          safe = line.scrub
+          yield(lineno, safe) if regex.match?(safe)
+        end
+      rescue ArgumentError
+        # Unreadable as text (encoding) — skip the file rather than fail.
+        nil
       end
 
-      def ripgrep_available?
-        return @ripgrep_available unless @ripgrep_available.nil?
-        @ripgrep_available = system("which", "rg", out: File::NULL, err: File::NULL)
+      def binary?(file)
+        File.binread(file, 1024).to_s.include?("".b)
+      rescue StandardError
+        false
       end
     end
   end

data/lib/shared_tools/tools/secure_tool_template.rb

@@ -6,7 +6,7 @@ require 'securerandom'
 module SharedTools
   module Tools
     class SecureToolTemplate < RubyLLM::Tool
-      def self.name = 'secure_tool_template'
+      def self.tool_name = 'secure_tool_template'
 
       description <<~'DESCRIPTION'
         Reference template demonstrating comprehensive security best practices for safe tool development.
@@ -28,7 +28,7 @@ module SharedTools
         sensitive systems, handle user data, or perform privileged operations.
       DESCRIPTION
 
-      params do
+      parameters do
         string :user_input, description: <<~DESC.strip
           User-provided input string that will be processed with comprehensive security validation.
           The input undergoes multiple security checks:

data/lib/shared_tools/tools/system_info_tool.rb

@@ -11,7 +11,7 @@ module SharedTools
     #   tool.execute                     # all categories
     #   tool.execute(category: 'cpu')    # CPU only
     class SystemInfoTool < ::RubyLLM::Tool
-      def self.name = 'system_info_tool'
+      def self.tool_name = 'system_info'
 
       description <<~DESC
         Retrieve system information from the local machine.
@@ -26,7 +26,7 @@ module SharedTools
         - 'all'     (default) — All of the above combined
       DESC
 
-      params do
+      parameters do
         string :category, required: false, description: <<~DESC.strip
           Info category. Options: 'os', 'cpu', 'memory', 'disk', 'network', 'ruby', 'all' (default).
         DESC

data/lib/shared_tools/tools/todo_write_tool.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require_relative "../../shared_tools"
+
+module SharedTools
+  module Tools
+    # Tracks a task list for multi-step work. Each call replaces the whole
+    # list (the standard agent pattern) and renders it back. State lives on
+    # the tool instance, so it persists across calls within a single chat
+    # session (when one instance is registered with the chat). Read-only in
+    # the sense that it never touches the filesystem or network — no
+    # authorization prompt required.
+    #
+    # @example
+    #   tool = SharedTools::Tools::TodoWriteTool.new
+    #   tool.execute(todos: [
+    #     { content: "Write the tool", status: "completed" },
+    #     { content: "Write the tests", status: "in_progress" }
+    #   ])
+    class TodoWriteTool < ::RubyLLM::Tool
+      STATUSES = %w[pending in_progress completed].freeze
+      MARKS = { "pending" => "[ ]", "in_progress" => "[~]", "completed" => "[x]" }.freeze
+
+      def self.tool_name = 'todo_write'
+
+      description "Maintain a task list for multi-step work. Pass the full list of todos; each call " \
+                  "replaces the previous list. Each todo has a content string and a status of " \
+                  "pending, in_progress, or completed."
+
+      parameters do
+        array :todos, description: "The full task list, replacing the previous one." do
+          object do
+            string :content, description: "The task description."
+            string :status,  description: "One of: pending, in_progress, completed."
+          end
+        end
+      end
+
+      # @param logger [Logger] optional logger
+      def initialize(logger: nil)
+        @todos = []
+        @logger = logger || RubyLLM.logger
+      end
+
+      # @param todos [Array<Hash>]
+      #
+      # @return [String, Hash]
+      def execute(todos:)
+        @logger.info("#{self.class.name}#execute todos=#{Array(todos).size}")
+
+        return { error: "todos must be an array" } unless todos.is_a?(Array)
+
+        normalized = todos.map { |todo| normalize(todo) }
+        invalid = normalized.find { |todo| !STATUSES.include?(todo[:status]) }
+        return { error: "invalid status: #{invalid[:status].inspect} (use #{STATUSES.join(', ')})" } if invalid
+
+        @todos = normalized
+        render
+      end
+
+      private
+
+      def normalize(todo)
+        hash = todo.is_a?(Hash) ? todo : {}
+        {
+          content: (hash["content"] || hash[:content]).to_s,
+          status: (hash["status"] || hash[:status] || "pending").to_s.strip.downcase
+        }
+      end
+
+      def render
+        return "Task list is empty." if @todos.empty?
+
+        done = @todos.count { |todo| todo[:status] == "completed" }
+        lines = ["Tasks (#{done}/#{@todos.size} complete):"]
+        @todos.each { |todo| lines << "#{MARKS[todo[:status]]} #{todo[:content]}" }
+        lines.join("\n")
+      end
+    end
+  end
+end

data/lib/shared_tools/tools/toml_query_tool.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'json'
+require_relative '../../shared_tools'
+
+module SharedTools
+  module Tools
+    # Parses TOML (from a file or an inline string) and either pretty-prints
+    # it (as JSON, for readability) or extracts a value with a dot/bracket
+    # path. In-process, read-only, no external gem dependency — handy for
+    # Cargo.toml, pyproject.toml, and similar config.
+    #
+    # Path syntax matches JsonQueryTool / YamlQueryTool: dependencies.serde.version,
+    # products[0].name, products[].name
+    #
+    # @example
+    #   tool = SharedTools::Tools::TomlQueryTool.new
+    #   tool.execute(path: "./Cargo.toml", query: "dependencies.serde.version")
+    class TomlQueryTool < ::RubyLLM::Tool
+      MAX_BYTES = 5 * 1024 * 1024
+
+      def self.tool_name = 'toml_query'
+
+      description "Query TOML with a path expression, or pretty-print it. Provide either a file " \
+                  "path or an inline toml string. Path syntax: keys separated by dots, [n] for " \
+                  "array index, [] to map over an array (e.g. products[].name)."
+
+      parameters do
+        string :path,  description: "TOML file to read. Provide this or toml.", required: false
+        string :toml,  description: "Inline TOML string. Provide this or path.", required: false
+        string :query, description: "Path expression to extract, e.g. 'dependencies.serde.version'. Omit to pretty-print. Optional.", required: false
+      end
+
+      # @param logger [Logger] optional logger
+      def initialize(logger: nil)
+        @logger = logger || RubyLLM.logger
+      end
+
+      # @param path [String, nil]
+      # @param toml [String, nil]
+      # @param query [String, nil]
+      #
+      # @return [String, Hash]
+      def execute(path: nil, toml: nil, query: nil)
+        @logger.info("#{self.class.name}#execute path=#{path.inspect} query=#{query.inspect}")
+
+        source = load_source(path, toml)
+        return source if source.is_a?(Hash) # error
+
+        data = SharedTools::TomlParser.parse(source)
+        result = query.to_s.strip.empty? ? data : SharedTools::DataPath.query(data, query)
+        JSON.pretty_generate(result)
+      rescue SharedTools::TomlParser::ParseError => e
+        @logger.error("#{self.class.name} invalid TOML: #{e.message}")
+        { error: "invalid TOML: #{e.message}" }
+      rescue SharedTools::DataPath::Error => e
+        @logger.error("#{self.class.name} bad query: #{e.message}")
+        { error: e.message }
+      rescue => e
+        @logger.error("#{self.class.name} failed: #{e.message}")
+        { error: e.message }
+      end
+
+      private
+
+      def load_source(path, toml)
+        if path && !path.to_s.empty?
+          return { error: "file not found: #{path}" } unless File.exist?(path)
+          return { error: "not a file: #{path}" } unless File.file?(path)
+          return { error: "file too large (> #{MAX_BYTES} bytes)" } if File.size(path) > MAX_BYTES
+
+          File.read(path).scrub
+        elsif toml && !toml.to_s.empty?
+          toml.to_s
+        else
+          { error: "provide either path or toml" }
+        end
+      end
+    end
+  end
+end

data/lib/shared_tools/tools/toolchain_helpers.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "pathname"
+require_relative "../../shared_tools"
+require_relative "../process_runner"
+
+module SharedTools
+  module Tools
+    # Shared behavior for the Ruby toolchain tools (BundleTool, LintTool,
+    # RunTestsTool, PythonTestsTool). Mixing tools must set @root in
+    # #initialize.
+    #
+    # Unlike BashTool, these run in @root and inherit the full host
+    # environment. That's deliberate: tools like bundler, rbenv/rvm, and the
+    # test/lint binaries rely on the Ruby environment (PATH shims, GEM_HOME,
+    # BUNDLE_*) to resolve correctly, and these are trusted dev commands the
+    # caller opted into (they all require SharedTools.execute? authorization).
+    module ToolchainHelpers
+      class CommandMissing < StandardError; end
+
+      def gemfile?
+        File.file?(File.join(@root, "Gemfile"))
+      end
+
+      # Runs argv in @root. With use_bundle, prefixes `bundle exec` when a
+      # Gemfile is present. Returns [out, err, status]; raises CommandMissing
+      # if the executable can't be found.
+      def run_in_project(argv, use_bundle: false, timeout: 120)
+        command = use_bundle && gemfile? ? ["bundle", "exec", *argv] : argv
+        SharedTools::ProcessRunner.capture(
+          command,
+          env: {}, # inherit the full host environment
+          chdir: @root,
+          timeout: timeout,
+          unsetenv_others: false
+        )
+      rescue Errno::ENOENT
+        raise CommandMissing, command.first
+      end
+
+      # Maps a finished toolchain run onto a return value. Non-zero exit is
+      # NOT treated as a tool error here — failing tests / lint offenses are
+      # results the caller needs to see, with a headline prepended.
+      def toolchain_output(out, err, status, pass_label:, fail_label:, timeout:)
+        return { error: "timed out after #{timeout}s" } if status == :timeout
+
+        combined = [out, err].map(&:to_s).reject(&:empty?).join("\n")
+        headline = status.exitstatus.zero? ? pass_label : fail_label
+        "#{headline}\n\n#{combined}".strip
+      end
+
+      # Resolve a path param to a root-relative path, rejecting escapes.
+      def jail_relative(path)
+        return nil if path.nil? || path.to_s.empty?
+
+        root = Pathname.new(File.expand_path(@root))
+        resolved = (root + path).cleanpath
+        raise SecurityError, "path escapes root: #{path}" unless resolved.ascend.any? { |ancestor| ancestor == root }
+
+        resolved.relative_path_from(root).to_s
+      end
+    end
+  end
+end

data/lib/shared_tools/tools/tree_tool.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require_relative '../../shared_tools'
+
+module SharedTools
+  module Tools
+    # Renders a depth-limited directory tree — a quick way to see project
+    # structure without walking it one level at a time with
+    # Disk::DirectoryListTool. Read-only; ignored directories are skipped,
+    # symlinks are not followed, and the listing is capped.
+    #
+    # @example
+    #   tool = SharedTools::Tools::TreeTool.new
+    #   tool.execute
+    #   tool.execute(path: "lib", max_depth: 2)
+    class TreeTool < ::RubyLLM::Tool
+      DEFAULT_DEPTH = 3
+      MAX_ENTRIES = 500
+      IGNORED_DIRS = %w[.git .hg .svn node_modules .bundle tmp].freeze
+
+      def self.tool_name = 'tree'
+
+      description "Show a directory tree, to a limited depth. Directories are marked with a " \
+                  "trailing slash. Skips ignored directories (node_modules, .git, ...) and hidden " \
+                  "entries unless show_hidden is set."
+
+      parameters do
+        integer :max_depth,   description: "How many levels deep to descend (default #{DEFAULT_DEPTH}).", required: false
+        string  :path,        description: "Directory to start from. Defaults to the current directory.", required: false
+        boolean :show_hidden, description: "Include dot-files and dot-directories. Default false.", required: false
+      end
+
+      # @param logger [Logger] optional logger
+      def initialize(logger: nil)
+        @logger = logger || RubyLLM.logger
+      end
+
+      # @param path [String, nil]
+      # @param max_depth [Integer]
+      # @param show_hidden [Boolean]
+      #
+      # @return [String, Hash]
+      def execute(path: nil, max_depth: DEFAULT_DEPTH, show_hidden: false)
+        @logger.info("#{self.class.name}#execute path=#{path.inspect} max_depth=#{max_depth} show_hidden=#{show_hidden}")
+
+        root = File.expand_path(path.to_s.empty? ? "." : path)
+        return { error: "not a directory: #{path || '.'}" } unless File.directory?(root)
+
+        depth = max_depth.to_i
+        depth = DEFAULT_DEPTH if depth <= 0
+
+        @count = 0
+        @truncated = false
+        lines = ["#{File.basename(root)}/"]
+        walk(root, depth, show_hidden, "", lines)
+        lines << "... (truncated at #{MAX_ENTRIES} entries)" if @truncated
+
+        lines.join("\n")
+      rescue => e
+        @logger.error("#{self.class.name} failed: #{e.message}")
+        { error: e.message }
+      end
+
+      private
+
+      def walk(dir, depth_left, show_hidden, indent, lines)
+        return if depth_left <= 0 || @truncated
+
+        entries = children(dir, show_hidden)
+        entries.each_with_index do |entry, idx|
+          if @count >= MAX_ENTRIES
+            @truncated = true
+            return
+          end
+
+          full = File.join(dir, entry)
+          is_dir = File.directory?(full) && !File.symlink?(full)
+          connector = idx == entries.length - 1 ? "└── " : "├── "
+          lines << "#{indent}#{connector}#{entry}#{is_dir ? '/' : ''}"
+          @count += 1
+
+          next unless is_dir
+
+          child_indent = indent + (idx == entries.length - 1 ? "    " : "│   ")
+          walk(full, depth_left - 1, show_hidden, child_indent, lines)
+        end
+      end
+
+      def children(dir, show_hidden)
+        entries = Dir.children(dir)
+        entries.reject! { |e| e.start_with?(".") } unless show_hidden
+        entries.reject! { |e| File.directory?(File.join(dir, e)) && IGNORED_DIRS.include?(e) }
+        # directories first, then files, each alphabetical
+        entries.sort_by { |e| [File.directory?(File.join(dir, e)) ? 0 : 1, e.downcase] }
+      rescue SystemCallError
+        []
+      end
+    end
+  end
+end

data/lib/shared_tools/tools/weather_tool.rb

@@ -11,7 +11,7 @@ end
 module SharedTools
   module Tools
     class WeatherTool < RubyLLM::Tool
-      def self.name = 'weather_tool'
+      def self.tool_name = 'weather'
 
       def available?
         OPENWEATHERMAP_AVAILABLE
@@ -31,7 +31,7 @@ module SharedTools
           puts "Temperature: #{result[:current][:temperature]}°C"
       DESCRIPTION
 
-      params do
+      parameters do
         string :city, description: <<~DESC.strip
           Name of the city for weather lookup. Can include city name only (e.g., 'London')
           or city with country code for better accuracy (e.g., 'London,UK' or 'Paris,FR').