tidewave 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 54751fab877a22eeffd2bd5179bebb1d566b92edf284fb34ffb2499a7ab04d15
-  data.tar.gz: d00206e13b21d3e52e9331cf740cdca113fe574095d6a45444861c3f5c5ce140
+  metadata.gz: 6d4f421f00436367f21d189e0fe49ea8a1ce4f611457b720f62027b4b8f080dc
+  data.tar.gz: 6bb95b976f34b5520b54fb8a0789d1adf18c591cef285bcd5500f591b2c4d1a3
 SHA512:
-  metadata.gz: faff1feb577d5f467f58dbed4b3be691bdf160e991f30406d9812ec275575d448452460ffb0219603294a4021a7f7075bbcded1c5eef3c7bf68693e30a9ca107
-  data.tar.gz: 987ac660e700738721fbd0e919f3d191b8a1a13af23c55a11b958f956aee638ec18326647a63b50099c5ada75885bf6ddcaba0f86577602c9437e074c5bc8857
+  metadata.gz: 851460abeef4e3d29d0d475a83f1e962bb0a6279708e25cc25ed2b8620782e48f837f8db279fac1da822af3c1d5472208be2340ca691ef5a226ab7bd7f4292f9
+  data.tar.gz: 48f5e731497bf822329c2de6865361c0d31bfe5fa64afed0c213d75d8de4db08ed4f44aa7ef76e889803330c70ba202712f724d569650d2707dccd3debb74d11

data/README.md

@@ -29,6 +29,24 @@ Tidewave will now run on the same port as your regular Rails application.
 In particular, the MCP is located by default at http://localhost:3000/tidewave/mcp.
 [You must configure your editor and AI assistants accordingly](https://hexdocs.pm/tidewave/mcp.html).
 
+## Configuration
+
+You may configure the `tidewave` using the following syntax:
+
+```ruby
+  config.tidewave.allowed_ips = [IPAddr.new("192.168.97.1")]
+```
+
+The following options are available:
+
+  * `:allowed_origins`
+
+  * `:localhost_only`
+
+  * `:allowed_ips`
+
+You can read more about this options in [FastMCP](https://github.com/yjacquin/fast_mcp) README.
+
 ## Considerations
 
 ### Production Environment

data/lib/tidewave/configuration.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Tidewave
+  class Configuration
+    attr_accessor :logger, :allowed_origins, :localhost_only, :allowed_ips
+
+    def initialize
+      @logger = Logger.new(STDOUT)
+      @allowed_origins = nil
+      @localhost_only = true
+      @allowed_ips = nil
+    end
+  end
+end

data/lib/tidewave/file_tracker.rb

@@ -4,38 +4,40 @@ module Tidewave
   module FileTracker
     extend self
 
-    def project_files
-      `git --git-dir #{git_root}/.git ls-files --cached --others --exclude-standard`.split("\n")
+    def project_files(glob_pattern: nil)
+      args = %w[--git-dir] + [ "#{git_root}/.git", "ls-files", "--cached", "--others" ]
+      args += glob_pattern ? [ glob_pattern ] : [ "--exclude-standard" ]
+      `git #{args.join(" ")}`.split("\n")
     end
 
-    def read_file(path)
-      validate_path_access!(path)
-
-      # Retrieve the full path
+    def read_file(path, line_offset: 0, count: nil)
       full_path = file_full_path(path)
+      # Explicitly read the mtime first to avoid race conditions
+      mtime = File.mtime(full_path).to_i
+      content = File.read(full_path)
 
-      # Record the file as read
-      record_read(path)
+      if line_offset > 0 || count
+        lines = content.lines
+        start_idx = [ line_offset, 0 ].max
+        count = (count || lines.length)
+        selected_lines = lines[start_idx, count]
+        content = selected_lines ? selected_lines.join : ""
+      end
 
-      # Read and return the file contents
-      File.read(full_path)
+      [ mtime, content ]
     end
 
     def write_file(path, content)
-      validate_path_access!(path, validate_existence: false)
-      # Retrieve the full path
+      validate_ruby_syntax!(content) if ruby_file?(path)
       full_path = file_full_path(path)
 
-      dirname = File.dirname(full_path)
-
       # Create the directory if it doesn't exist
+      dirname = File.dirname(full_path)
       FileUtils.mkdir_p(dirname)
 
-      # Write the file contents
+      # Write and return the file contents
       File.write(full_path, content)
-
-      # Read and return the file contents
-      read_file(path)
+      content
     end
 
     def file_full_path(path)
@@ -47,7 +49,7 @@ module Tidewave
     end
 
     def validate_path_access!(path, validate_existence: true)
-      raise ArgumentError, "File path must not start with '..'" if path.start_with?("..")
+      raise ArgumentError, "File path must not contain '..'" if path.include?("..")
 
       # Ensure the path is within the project
       full_path = file_full_path(path)
@@ -56,68 +58,44 @@ module Tidewave
       raise ArgumentError, "File path must be within the project directory" unless full_path.start_with?(git_root)
 
       # Verify the file exists
-      raise ArgumentError, "File not found: #{path}" unless File.exist?(full_path) && validate_existence
+      raise ArgumentError, "File not found: #{path}" if validate_existence && !File.exist?(full_path)
 
       true
     end
 
-    def validate_path_is_editable!(path)
+    def validate_path_is_editable!(path, atime)
       validate_path_access!(path)
-      validate_path_has_been_read_since_last_write!(path)
+      validate_path_has_been_read_since_last_write!(path, atime)
 
       true
     end
 
-    def validate_path_is_writable!(path)
+    def validate_path_is_writable!(path, atime)
       validate_path_access!(path, validate_existence: false)
-      validate_path_has_been_read_since_last_write!(path)
+      validate_path_has_been_read_since_last_write!(path, atime)
 
       true
     end
 
-    def validate_path_has_been_read_since_last_write!(path)
-      raise ArgumentError, "File has been modified since last read, please read the file again" unless file_was_read_since_last_write?(path)
+    private
 
-      true
+    def ruby_file?(path)
+      [ ".rb", ".rake", ".gemspec" ].include?(File.extname(path)) ||
+        [ "Gemfile" ].include?(File.basename(path))
     end
 
-    # Record when a file was read
-    def record_read(path)
-      file_records[path] = Time.now
+    def validate_ruby_syntax!(content)
+      RubyVM::AbstractSyntaxTree.parse(content)
+    rescue SyntaxError => e
+      raise "Invalid Ruby syntax: #{e.message}"
     end
 
+    def validate_path_has_been_read_since_last_write!(path, atime)
+      if atime && File.mtime(file_full_path(path)).to_i > atime
+        raise ArgumentError, "File has been modified since last read, please read the file again"
+      end
 
-    def file_was_read_since_last_write?(path)
-      file_was_read?(path) && last_read_at(path) >= last_modified_at(path)
-    end
-
-    # Check if a file has been read
-    def file_was_read?(path)
-      file_records.key?(path)
-    end
-
-    # Check if a file exists
-    def file_exists?(path)
-      File.exist?(file_full_path(path))
-    end
-
-    # Get the timestamp when a file was last read
-    def last_read_at(path)
-      file_records[path]
-    end
-
-    def last_modified_at(path)
-      File.mtime(file_full_path(path))
-    end
-
-    # Reset all tracked files (useful for testing)
-    def reset
-      @file_records = {}
-    end
-
-    # Hash mapping file paths to their read records
-    def file_records
-      @file_records ||= {}
+      true
     end
   end
 end

data/lib/tidewave/railtie.rb

@@ -3,14 +3,22 @@
 require "fast_mcp"
 require "logger"
 require "fileutils"
-require "tidewave/tool_resolver"
+require "tidewave/configuration"
+require "active_support/core_ext/class"
+
+gem_tools_path = File.expand_path("tools/**/*.rb", __dir__)
+Dir[gem_tools_path].each { |f| require f }
 
 module Tidewave
   class Railtie < Rails::Railtie
+    config.tidewave = Tidewave::Configuration.new
+
     initializer "tidewave.setup_mcp" do |app|
       # Prevent MCP server from being mounted if Rails is not running in development mode
       raise "For security reasons, Tidewave is only supported in development mode" unless Rails.env.development?
 
+      config = app.config.tidewave
+
       # Set up MCP server with the host application
       FastMcp.mount_in_rails(
         app,
@@ -19,12 +27,21 @@ module Tidewave
         path_prefix: Tidewave::PATH_PREFIX,
         messages_route: Tidewave::MESSAGES_ROUTE,
         sse_route: Tidewave::SSE_ROUTE,
-        logger: Logger.new(STDOUT)
+        logger: config.logger,
+        allowed_origins: config.allowed_origins,
+        localhost_only: config.localhost_only,
+        allowed_ips: config.allowed_ips
       ) do |server|
         app.config.before_initialize do
-          # Register a custom middleware to register tools depending on `include_fs_tools` query parameter
-          server.register_tools(*Tidewave::ToolResolver::ALL_TOOLS)
-          app.middleware.use Tidewave::ToolResolver, server
+          server.filter_tools do |request, tools|
+            if request.params["include_fs_tools"] != "true"
+              tools.reject { |tool| tool.tags.include?(:file_system_tool) }
+            else
+              tools
+            end
+          end
+
+          server.register_tools(*Tidewave::Tools::Base.descendants)
         end
       end
     end

data/lib/tidewave/tools/base.rb

@@ -3,13 +3,6 @@
 module Tidewave
   module Tools
     class Base < FastMcp::Tool
-      def self.file_system_tool
-        @file_system_tool = true
-      end
-
-      def self.file_system_tool?
-        @file_system_tool
-      end
     end
   end
 end

data/lib/tidewave/tools/edit_project_file.rb

@@ -2,10 +2,8 @@
 
 require "tidewave/file_tracker"
 
-# TODO: This tool is not yet implemented, it does not track the latest file read.
-# Also, it does not raise an error if the file contains the substring multiple times.
 class Tidewave::Tools::EditProjectFile < Tidewave::Tools::Base
-  file_system_tool
+  tags :file_system_tool
 
   tool_name "edit_project_file"
   description <<~DESCRIPTION
@@ -28,11 +26,12 @@ class Tidewave::Tools::EditProjectFile < Tidewave::Tools::Base
     required(:path).filled(:string).description("The path to the file to edit. It is relative to the project root.")
     required(:old_string).filled(:string).description("The string to search for")
     required(:new_string).filled(:string).description("The string to replace the old_string with")
+    optional(:atime).filled(:integer).hidden.description("The Unix timestamp this file was last accessed. Not to be used.")
   end
 
-  def call(path:, old_string:, new_string:)
+  def call(path:, old_string:, new_string:, atime: nil)
     # Check if the file exists within the project root and has been read
-    Tidewave::FileTracker.validate_path_is_editable!(path)
+    Tidewave::FileTracker.validate_path_is_editable!(path, atime)
 
     old_content = Tidewave::FileTracker.read_file(path)
 
@@ -42,7 +41,7 @@ class Tidewave::Tools::EditProjectFile < Tidewave::Tools::Base
     raise ArgumentError, "old_string is not unique" if scan_result.size > 1
 
     new_content = old_content.sub(old_string, new_string)
-
     Tidewave::FileTracker.write_file(path, new_content)
+    "OK"
   end
 end

data/lib/tidewave/tools/get_package_location.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+class Tidewave::Tools::GetPackageLocation < Tidewave::Tools::Base
+  tool_name "get_package_location"
+
+  description <<~DESCRIPTION
+    Returns the location of dependency packages.
+    You can use this tool to get the location of any project dependency. Optionally,
+    a specific dependency name can be provided to only return the location of that dependency.
+    Use the result in combination with shell tools like grep to look for specific
+    code inside dependencies.
+  DESCRIPTION
+
+  arguments do
+    optional(:package).maybe(:string).description(
+      "The name of the package to get the location of. If not provided, the location of all packages will be returned."
+    )
+  end
+
+  def call(package: nil)
+    raise "get_package_location only works with projects using Bundler" unless defined?(Bundler)
+    specs = Bundler.load.specs
+
+    if package
+      spec = specs.find { |s| s.name == package }
+      if spec
+        spec.full_gem_path
+      else
+        raise "Package #{package} not found. Check your Gemfile for available packages."
+      end
+    else
+      # For all packages, return a formatted string with package names and locations
+      specs.map do |spec|
+        relative_path = Pathname.new(spec.full_gem_path).relative_path_from(Pathname.new(Dir.pwd))
+        "#{spec.name}: #{relative_path}"
+      end.join("\n")
+    end
+  end
+end

data/lib/tidewave/tools/get_source_location.rb

@@ -1,58 +1,60 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/string/inflections"
-require "active_support/core_ext/object/blank"
-
 class Tidewave::Tools::GetSourceLocation < Tidewave::Tools::Base
   tool_name "get_source_location"
 
   description <<~DESCRIPTION
-    Returns the source location for the given module (or function).
+    Returns the source location for the given reference.
+
+    The reference may be a constant, most commonly classes and modules
+    such as `String`, an instance method, such as `String#gsub`, or class
+    method, such as `File.executable?`
 
-    This works for modules in the current project, as well as dependencies.
+    This works for methods in the current project, as well as dependencies.
 
-    This tool only works if you know the specific module (and optionally function) that is being targeted.
+    This tool only works if you know the specific constant/method being targeted.
     If that is the case, prefer this tool over grepping the file system.
   DESCRIPTION
 
   arguments do
-    required(:module_name).filled(:string).description("The module to get source location for. When this is the single argument passed, the entire module source is returned.")
-    optional(:function_name).filled(:string).description("The function to get source location for. When used, a module must also be passed.")
+    required(:reference).filled(:string).description("The constant/method to lookup, such String, String#gsub or File.executable?")
   end
 
+  def call(reference:)
+    file_path, line_number = get_source_location(reference)
 
-  def call(module_name:, function_name: nil)
-    file_path, line_number = get_source_location(module_name, function_name)
-
+    if file_path
     {
       file_path: file_path,
       line_number: line_number
     }.to_json
+    else
+      raise NameError, "could not find source location for #{reference}"
+    end
   end
 
   private
 
-  def get_source_location(module_name, function_name)
-    begin
-      module_ref = module_name.constantize
-    rescue NameError
-      raise NameError, "Module #{module_name} not found"
-    end
+  def get_source_location(reference)
+    constant_path, selector, method_name = reference.rpartition(/\.|#/)
 
-    return get_method_definition(module_ref, function_name) if function_name.present?
+    # There are no selectors, so the method_name is a constant path
+    return Object.const_source_location(method_name) if selector.empty?
 
-    module_ref.const_source_location(module_name)
-  end
+    begin
+      mod = Object.const_get(constant_path)
+    rescue NameError => e
+      raise e
+    rescue
+      raise "wrong or invalid reference #{reference}"
+    end
 
-  def get_method_definition(module_ref, function_name)
-    module_ref.method(function_name).source_location
-  rescue NameError
-    get_instance_method_definition(module_ref, function_name)
-  end
+    raise "reference #{constant_path} does not point a class/module" unless mod.is_a?(Module)
 
-  def get_instance_method_definition(module_ref, function_name)
-    module_ref.instance_method(function_name).source_location
-  rescue NameError
-    raise NameError, "Method #{function_name} not found in module #{module_ref.name}"
+    if selector == "#"
+      mod.instance_method(method_name).source_location
+    else
+      mod.method(method_name).source_location
+    end
   end
 end

data/lib/tidewave/tools/grep_project_files.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 class Tidewave::Tools::GrepProjectFiles < Tidewave::Tools::Base
-  file_system_tool
+  tags :file_system_tool
 
   def self.ripgrep_executable
     @ripgrep_executable ||= `which rg`.strip
@@ -52,16 +52,18 @@ class Tidewave::Tools::GrepProjectFiles < Tidewave::Tools::Base
   end
 
   def execute_grep(pattern, glob, case_sensitive, max_results)
-    files = Tidewave::Tools::GlobProjectFiles.new.call(pattern: glob)
+    glob = "**/*" if glob.blank?
+    files = Dir.glob(glob, base: Tidewave::FileTracker.git_root)
     results = []
     files.each do |file|
-      next unless File.file?(file)
+      full_path = File.join(Tidewave::FileTracker.git_root, file)
+      next unless File.file?(full_path)
 
       begin
         file_matches = 0
         line_number = 0
 
-        File.foreach(file) do |line|
+        File.foreach(full_path) do |line|
           line_number += 1
 
           # Check if line matches pattern with proper case sensitivity

data/lib/tidewave/tools/list_project_files.rb

@@ -3,12 +3,24 @@
 require "tidewave/file_tracker"
 
 class Tidewave::Tools::ListProjectFiles < Tidewave::Tools::Base
-  file_system_tool
+  tags :file_system_tool
 
   tool_name "list_project_files"
-  description "Returns a list of all files in the project that are not ignored by .gitignore."
+  description <<~DESC
+    Returns a list of files in the project.
 
-  def call
-    Tidewave::FileTracker.project_files
+    By default, when no arguments are passed, it returns all files in the project that
+    are not ignored by .gitignore.
+
+    Optionally, a glob_pattern can be passed to filter this list. When a pattern is passed,
+    the gitignore check will be skipped.
+  DESC
+
+  arguments do
+    optional(:glob_pattern).maybe(:string).description("Optional: a glob pattern to filter the listed files. If a pattern is passed, the .gitignore check will be skipped.")
+  end
+
+  def call(glob_pattern: nil)
+    Tidewave::FileTracker.project_files(glob_pattern: glob_pattern)
   end
 end

data/lib/tidewave/tools/package_search.rb

@@ -28,7 +28,14 @@ class Tidewave::Tools::PackageSearch < Tidewave::Tools::Base
     response = Net::HTTP.get_response(uri)
 
     if response.is_a?(Net::HTTPSuccess)
-      JSON.parse(response.body)
+      JSON.parse(response.body).map do |package|
+        {
+          name: package["name"],
+          version: package["version"],
+          downloads: package["downloads"],
+          documentation_uri: package["documentation_uri"]
+        }
+      end
     else
       raise "RubyGems API request failed with status code: #{response.code}"
     end

data/lib/tidewave/tools/read_project_file.rb

@@ -3,18 +3,23 @@
 require "tidewave/file_tracker"
 
 class Tidewave::Tools::ReadProjectFile < Tidewave::Tools::Base
-  file_system_tool
+  tags :file_system_tool
 
   tool_name "read_project_file"
   description <<~DESCRIPTION
-    Returns the contents of the given file. Matches the `resources/read` MCP method.
+    Returns the contents of the given file.
+    Supports an optional line_offset and count. To read the full file, only the path needs to be passed.
   DESCRIPTION
 
   arguments do
     required(:path).filled(:string).description("The path to the file to read. It is relative to the project root.")
+    optional(:line_offset).filled(:integer).description("Optional: the starting line offset from which to read. Defaults to 0.")
+    optional(:count).filled(:integer).description("Optional: the number of lines to read. Defaults to all.")
   end
 
-  def call(path:)
-    Tidewave::FileTracker.read_file(path)
+  def call(path:, **keywords)
+    Tidewave::FileTracker.validate_path_access!(path)
+    _meta[:mtime], contents = Tidewave::FileTracker.read_file(path, **keywords)
+    contents
   end
 end

data/lib/tidewave/tools/shell_eval.rb

@@ -3,7 +3,7 @@
 require "open3"
 
 class Tidewave::Tools::ShellEval < Tidewave::Tools::Base
-  file_system_tool
+  tags :file_system_tool
   class CommandFailedError < StandardError; end
 
   tool_name "shell_eval"

data/lib/tidewave/tools/write_project_file.rb

@@ -3,7 +3,7 @@
 require "tidewave/file_tracker"
 
 class Tidewave::Tools::WriteProjectFile < Tidewave::Tools::Base
-  file_system_tool
+  tags :file_system_tool
 
   tool_name "write_project_file"
   description <<~DESCRIPTION
@@ -15,11 +15,14 @@ class Tidewave::Tools::WriteProjectFile < Tidewave::Tools::Base
   arguments do
     required(:path).filled(:string).description("The path to the file to write. It is relative to the project root.")
     required(:content).filled(:string).description("The content to write to the file")
+    optional(:atime).filled(:integer).hidden.description("The Unix timestamp this file was last accessed. Not to be used.")
   end
 
-  def call(path:, content:)
-    Tidewave::FileTracker.validate_path_is_writable!(path)
-
+  def call(path:, content:, atime: nil)
+    Tidewave::FileTracker.validate_path_is_writable!(path, atime)
     Tidewave::FileTracker.write_file(path, content)
+    _meta[:mtime] = Time.now.to_i
+
+    "OK"
   end
 end

data/lib/tidewave/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Tidewave
-  VERSION = "0.1.1"
+  VERSION = "0.1.3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tidewave
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - Yorick Jacquin
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-05-01 00:00:00.000000000 Z
+date: 2025-06-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 7.2.0
+        version: 7.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 7.2.0
+        version: 7.1.0
 - !ruby/object:Gem::Dependency
   name: fast-mcp
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.3.0
+        version: 1.5.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.3.0
+        version: 1.5.0
 - !ruby/object:Gem::Dependency
   name: rack
   requirement: !ruby/object:Gem::Requirement
@@ -63,16 +63,16 @@ files:
 - README.md
 - config/database.yml
 - lib/tidewave.rb
+- lib/tidewave/configuration.rb
 - lib/tidewave/file_tracker.rb
 - lib/tidewave/railtie.rb
-- lib/tidewave/tool_resolver.rb
 - lib/tidewave/tools/base.rb
 - lib/tidewave/tools/edit_project_file.rb
 - lib/tidewave/tools/execute_sql_query.rb
 - lib/tidewave/tools/get_logs.rb
 - lib/tidewave/tools/get_models.rb
+- lib/tidewave/tools/get_package_location.rb
 - lib/tidewave/tools/get_source_location.rb
-- lib/tidewave/tools/glob_project_files.rb
 - lib/tidewave/tools/grep_project_files.rb
 - lib/tidewave/tools/list_project_files.rb
 - lib/tidewave/tools/package_search.rb

data/lib/tidewave/tool_resolver.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-require "rack"
-
-gem_tools_path = File.expand_path("../../lib/tidewave/tools/**/*.rb", __dir__)
-Dir[gem_tools_path].each { |f| require f }
-
-module Tidewave
-  class ToolResolver
-    ALL_TOOLS = Tidewave::Tools::Base.descendants
-    NON_FILE_SYSTEM_TOOLS = ALL_TOOLS.reject(&:file_system_tool?)
-    MESSAGES_PATH = "/tidewave/messages".freeze
-    TOOLS_LIST_METHOD = "tools/list".freeze
-    INCLUDE_FS_TOOLS_PARAM = "include_fs_tools".freeze
-
-    def initialize(app, server)
-      @app = app
-      @server = server
-    end
-
-    def call(env)
-      request = Rack::Request.new(env)
-      request_path = request.path
-      request_body = extract_request_body(request)
-      request_params = request.params
-
-      # Override tools list response if requested
-      return override_tools_list_response(env) if overriding_tools_list_request?(request_path, request_params, request_body)
-
-      # Forward the request to the underlying app (RackTransport)
-      @app.call(env)
-    end
-
-    private
-
-    def extract_request_body(request)
-      JSON.parse(request.body.read)
-    rescue JSON::ParserError => e
-      {}
-    ensure
-      request.body.rewind
-    end
-
-    # When we want to exclude file system tools, we need to handle the request differently to prevent from listing them
-    def overriding_tools_list_request?(request_path, request_params, request_body)
-      request_path == MESSAGES_PATH && request_body["method"] == TOOLS_LIST_METHOD && request_params[INCLUDE_FS_TOOLS_PARAM] != "true"
-    end
-
-    RESPONSE_HEADERS = { "Content-Type" => "application/json" }
-
-    def override_tools_list_response(env)
-      register_non_file_system_tools
-      @app.call(env).tap { register_all_tools }
-    end
-
-    def register_non_file_system_tools
-      reset_server_tools
-      @server.register_tools(*NON_FILE_SYSTEM_TOOLS)
-    end
-
-    def register_all_tools
-      reset_server_tools
-      @server.register_tools(*ALL_TOOLS)
-    end
-
-    def reset_server_tools
-      @server.instance_variable_set(:@tools, {})
-    end
-  end
-end

data/lib/tidewave/tools/glob_project_files.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-require "tidewave/file_tracker"
-
-class Tidewave::Tools::GlobProjectFiles < Tidewave::Tools::Base
-  file_system_tool
-
-  tool_name "glob_project_files"
-  description "Searches for files matching the given glob pattern."
-
-  arguments do
-    required(:pattern).filled(:string).description('The glob pattern to match files against, e.g., \"**/*.ex\"')
-  end
-
-  def call(pattern:)
-    Dir.glob(pattern, base: Tidewave::FileTracker.git_root)
-  end
-end