tidewave 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6d4f421f00436367f21d189e0fe49ea8a1ce4f611457b720f62027b4b8f080dc
-  data.tar.gz: 6bb95b976f34b5520b54fb8a0789d1adf18c591cef285bcd5500f591b2c4d1a3
+  metadata.gz: d708afbfcf6d89cc1456bd7bcefdc660952571cda0c6635b8c6b14b8fa31d91e
+  data.tar.gz: da923b2f69608fe95eb11f76795cef1598f9cc24941afe50081afc4b76c66cfa
 SHA512:
-  metadata.gz: 851460abeef4e3d29d0d475a83f1e962bb0a6279708e25cc25ed2b8620782e48f837f8db279fac1da822af3c1d5472208be2340ca691ef5a226ab7bd7f4292f9
-  data.tar.gz: 48f5e731497bf822329c2de6865361c0d31bfe5fa64afed0c213d75d8de4db08ed4f44aa7ef76e889803330c70ba202712f724d569650d2707dccd3debb74d11
+  metadata.gz: 9b0eaa2a77690e4dda1720e5c2c84b02ea93d9b69955e2e430745da483d30014ba3fc5d59dc40c92b0ccdedd4413f4198012813a33f2332fd7ca08a9fac79fc1
+  data.tar.gz: 501103bf39a69932a408ebf9e455640fc8fb97a507163d6b4f42faf27aead8811927ecc249858978c8c5a46213dbe5b1d8635ade60817f546645ec99fa4c203a

data/README.md

@@ -6,17 +6,6 @@ assistant to your web framework runtime via [MCP](https://modelcontextprotocol.i
 
 [See our website](https://tidewave.ai) for more information.
 
-## Key Features
-
-Tidewave provides tools that allow your LLM of choice to:
-
-- inspect your application logs to help debugging errors
-- execute SQL queries and inspect your database
-- evaluate custom Ruby code in the context of your project
-- find Rubygems packages and source code locations
-
-and more.
-
 ## Installation
 
 You can install Tidewave by adding the `tidewave` gem to the development group in your Gemfile:
@@ -29,37 +18,47 @@ 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
+## Troubleshooting
 
-You may configure the `tidewave` using the following syntax:
+### Localhost requirement
+
+Tidewave expects your web application to be running on `localhost`. If you are not running on localhost, you may need to set some additional configuration. In particular, you must configure Tidewave to allow `allow_remote_access` and [optionally configure your Rails hosts](https://guides.rubyonrails.org/configuring.html#actiondispatch-hostauthorization). For example, in your `config/environments/development.rb`:
 
 ```ruby
-  config.tidewave.allowed_ips = [IPAddr.new("192.168.97.1")]
+config.hosts << "company.local"
+config.tidewave.allow_remote_access = true
 ```
 
-The following options are available:
-
-  * `:allowed_origins`
-
-  * `:localhost_only`
-
-  * `:allowed_ips`
+If you want to use Docker for development, you either need to enable the configuration above or automatically redirect the relevant ports, as done by [devcontainers](https://code.visualstudio.com/docs/devcontainers/containers). See our [containars](https://hexdocs.pm/tidewave/containers.html) guide for more information.
 
-You can read more about this options in [FastMCP](https://github.com/yjacquin/fast_mcp) README.
+### Content security policy
 
-## Considerations
+If you have enabled Content-Security-Policy, Tidewave will automatically enable "unsafe-eval" under `script-src` in order for contextual browser testing to work correctly.
 
 ### Production Environment
 
-Tidewave is a powerful tool that can help you develop your web application faster and more efficiently.
-However, it is important to note that Tidewave is not meant to be used in a production environment.
+Tidewave is a powerful tool that can help you develop your web application faster and more efficiently. However, it is important to note that Tidewave is not meant to be used in a production environment.
 
-Tidewave will raise an error if it is used in a production environment.
+Tidewave will raise an error if it is used in any environment where code reloading is disabled (which typically includes production).
 
 ### Web server requirements
 
 Tidewave currently requires a threaded web server like Puma.
 
+## Configuration
+
+You may configure `tidewave` using the following syntax:
+
+```ruby
+  config.tidewave.allow_remote_access = true
+```
+
+The following options are available:
+
+  * `:allow_remote_access` - Tidewave only allows requests from localhost by default, even if your server listens on other interfaces as well. If you trust your network and need to access Tidewave from a different machine, this configuration can be set to `true`
+
+  * `:preferred_orm` - which ORM to use, either `:active_record` (default) or `:sequel`
+
 ## Acknowledgements
 
 A thank you to Yorick Jacquin, for creating [FastMCP](https://github.com/yjacquin/fast_mcp) and implementing the initial version of this project.

data/lib/tidewave/configuration.rb

@@ -2,13 +2,14 @@
 
 module Tidewave
   class Configuration
-    attr_accessor :logger, :allowed_origins, :localhost_only, :allowed_ips
+    attr_accessor :logger, :allow_remote_access, :preferred_orm, :credentials, :client_url
 
     def initialize
-      @logger = Logger.new(STDOUT)
-      @allowed_origins = nil
-      @localhost_only = true
-      @allowed_ips = nil
+      @logger = nil
+      @allow_remote_access = true
+      @preferred_orm = :active_record
+      @credentials = {}
+      @client_url = "https://tidewave.ai"
     end
   end
 end

data/lib/tidewave/database_adapter.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Tidewave
+  class DatabaseAdapter
+    class << self
+      def current
+        @current ||= create_adapter
+      end
+
+      def create_adapter
+        orm_type = Rails.application.config.tidewave.preferred_orm
+        case orm_type
+        when :active_record
+          require_relative "database_adapters/active_record"
+          DatabaseAdapters::ActiveRecord.new
+        when :sequel
+          require_relative "database_adapters/sequel"
+          DatabaseAdapters::Sequel.new
+        else
+          raise "Unknown preferred ORM: #{orm_type}"
+        end
+      end
+    end
+
+    def execute_query(query, arguments = [])
+      raise NotImplementedError, "Subclasses must implement execute_query"
+    end
+
+    def get_base_class
+      raise NotImplementedError, "Subclasses must implement get_base_class"
+    end
+  end
+end

data/lib/tidewave/database_adapters/active_record.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Tidewave
+  module DatabaseAdapters
+    class ActiveRecord < DatabaseAdapter
+      RESULT_LIMIT = 50
+
+      def execute_query(query, arguments = [])
+        conn = ::ActiveRecord::Base.connection
+
+        # Execute the query with prepared statement and arguments
+        if arguments.any?
+          result = conn.exec_query(query, "SQL", arguments)
+        else
+          result = conn.exec_query(query)
+        end
+
+        # Format the result
+        {
+          columns: result.columns,
+          rows: result.rows.first(RESULT_LIMIT),
+          row_count: result.rows.length,
+          adapter: conn.adapter_name,
+          database: database_name
+        }
+      end
+
+      def get_base_class
+        ::ActiveRecord::Base
+      end
+
+      private
+
+      def database_name
+        Rails.configuration.database_configuration.dig(Rails.env, "database")
+      end
+    end
+  end
+end

data/lib/tidewave/database_adapters/sequel.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Tidewave
+  module DatabaseAdapters
+    class Sequel < DatabaseAdapter
+      RESULT_LIMIT = 50
+
+      def execute_query(query, arguments = [])
+        db = ::Sequel::Model.db
+
+        # Execute the query with arguments
+        result = if arguments.any?
+          db.fetch(query, *arguments)
+        else
+          db.fetch(query)
+        end
+
+        # Convert to array of hashes and extract metadata
+        rows = result.all
+        columns = rows.first&.keys || []
+
+        # Format the result similar to ActiveRecord
+        {
+          columns: columns.map(&:to_s),
+          rows: rows.first(RESULT_LIMIT).map(&:values),
+          row_count: rows.length,
+          adapter: db.adapter_scheme.to_s.upcase,
+          database: db.opts[:database]
+        }
+      end
+
+      def get_base_class
+        ::Sequel::Model
+      end
+    end
+  end
+end

data/lib/tidewave/exceptions_middleware.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+class Tidewave::ExceptionsMiddleware
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    request = ActionDispatch::Request.new(env)
+    status, headers, body = @app.call(env)
+
+    exception = request.get_header("tidewave.exception")
+
+    if exception
+      formatted = format_exception_html(exception, request)
+      body, headers = append_body(body, headers, formatted)
+    end
+
+    [ status, headers, body ]
+  rescue => error
+    Rails.logger.error("Failure in Tidewave::ExceptionsMiddleware, message: #{error.message}")
+    raise error
+  end
+
+  private
+
+  def format_exception_html(exception, request)
+    backtrace = Rails.backtrace_cleaner.clean(exception.backtrace)
+
+    parameters = request_parameters(request)
+
+    text = exception.class.name.dup
+
+    if parameters["controller"]
+      text << " in #{parameters["controller"].camelize}Controller"
+
+      if parameters["action"]
+        text << "##{parameters["action"]}"
+      end
+    end
+
+    text << "\n\n## Message\n\n#{exception.message}"
+
+    if backtrace.any?
+      text << "\n\n## Backtrace\n\n#{backtrace.join("\n")}"
+    end
+
+    text << "\n\n"
+
+    text << <<~TEXT.chomp
+      ## Request info
+
+        * URI: #{request.base_url + request.path}
+        * Query string: #{request.query_string}
+
+      ## Session
+
+          #{request.session.to_hash.inspect}
+    TEXT
+
+    %Q(<textarea style="display: none;" data-tidewave-exception-info>#{ERB::Util.html_escape(text)}</textarea>)
+  end
+
+  def request_parameters(request)
+    request.parameters
+  rescue ActionController::BadRequest
+    {}
+  end
+
+  def append_body(body, headers, content)
+    new_body = "".dup
+
+    body.each { |part| new_body << part }
+    body.close if body.respond_to?(:close)
+
+    if position = new_body.rindex("</body>")
+      new_body.insert(position, content)
+    else
+      new_body << content
+    end
+
+    if headers[Rack::CONTENT_LENGTH]
+      headers[Rack::CONTENT_LENGTH] = new_body.bytesize.to_s
+    end
+
+    [ [ new_body ], headers ]
+  end
+end

data/lib/tidewave/file_tracker.rb

@@ -4,9 +4,10 @@ module Tidewave
   module FileTracker
     extend self
 
-    def project_files(glob_pattern: nil)
-      args = %w[--git-dir] + [ "#{git_root}/.git", "ls-files", "--cached", "--others" ]
-      args += glob_pattern ? [ glob_pattern ] : [ "--exclude-standard" ]
+    def project_files(glob_pattern: nil, include_ignored: false)
+      args = [ "ls-files", "--cached", "--others" ]
+      args << "--exclude-standard" unless include_ignored
+      args << glob_pattern if glob_pattern
       `git #{args.join(" ")}`.split("\n")
     end
 
@@ -41,11 +42,7 @@ module Tidewave
     end
 
     def file_full_path(path)
-      File.join(git_root, path)
-    end
-
-    def git_root
-      @git_root ||= `git rev-parse --show-toplevel`.strip
+      File.expand_path(path, Rails.root)
     end
 
     def validate_path_access!(path, validate_existence: true)
@@ -55,10 +52,14 @@ module Tidewave
       full_path = file_full_path(path)
 
       # Verify the file is within the project directory
-      raise ArgumentError, "File path must be within the project directory" unless full_path.start_with?(git_root)
+      unless full_path.start_with?(Rails.root.to_s + File::SEPARATOR)
+        raise ArgumentError, "File path must be within the project directory"
+      end
 
       # Verify the file exists
-      raise ArgumentError, "File not found: #{path}" if validate_existence && !File.exist?(full_path)
+      if validate_existence && !File.exist?(full_path)
+        raise ArgumentError, "File not found: #{path}"
+      end
 
       true
     end

data/lib/tidewave/middleware.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+require "open3"
+require "ipaddr"
+require "fast_mcp"
+require "rack/request"
+require "active_support/core_ext/class"
+require "active_support/core_ext/object/blank"
+require "json"
+require "erb"
+
+class Tidewave::Middleware
+  TIDEWAVE_ROUTE = "tidewave".freeze
+  EMPTY_ROUTE = "empty".freeze
+  SSE_ROUTE = "mcp".freeze
+  MESSAGES_ROUTE = "mcp/message".freeze
+  SHELL_ROUTE = "shell".freeze
+
+  INVALID_IP = <<~TEXT.freeze
+    For security reasons, Tidewave does not accept remote connections by default.
+
+    If you really want to allow remote connections, set `config.tidewave.allow_remote_access = true`.
+  TEXT
+
+  def initialize(app, config)
+    @allow_remote_access = config.allow_remote_access
+    @client_url = config.client_url
+    @project_name = Rails.application.class.module_parent.name
+
+    @app = FastMcp.rack_middleware(app,
+      name: "tidewave",
+      version: Tidewave::VERSION,
+      path_prefix: "/" + TIDEWAVE_ROUTE,
+      messages_route: MESSAGES_ROUTE,
+      sse_route: SSE_ROUTE,
+      logger: config.logger || Logger.new(Rails.root.join("log", "tidewave.log")),
+      # Rails runs the HostAuthorization in dev, so we skip this
+      allowed_origins: [],
+      # We validate this one in Tidewave::Middleware
+      localhost_only: false
+    ) do |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
+
+  def call(env)
+    request = Rack::Request.new(env)
+    path = request.path.split("/").reject(&:empty?)
+
+    if path[0] == TIDEWAVE_ROUTE
+      return forbidden(INVALID_IP) unless valid_client_ip?(request)
+
+      # The MCP routes are handled downstream by FastMCP
+      case [ request.request_method, path ]
+      when [ "GET", [ TIDEWAVE_ROUTE ] ]
+        return home(request)
+      when [ "GET", [ TIDEWAVE_ROUTE, EMPTY_ROUTE ] ]
+        return empty(request)
+      when [ "POST", [ TIDEWAVE_ROUTE, SHELL_ROUTE ] ]
+        return shell(request)
+      end
+    end
+
+    @app.call(env)
+  end
+
+  private
+
+  def home(request)
+    config = {
+      "project_name" => @project_name,
+      "framework_type" => "rails",
+      "tidewave_version" => Tidewave::VERSION
+    }
+
+    html = <<~HTML
+      <html>
+        <head>
+          <meta charset="UTF-8" />
+          <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+          <meta name="tidewave:config" content="#{ERB::Util.html_escape(JSON.generate(config))}" />
+          <script type="module" src="#{@client_url}/tc/tc.js"></script>
+        </head>
+        <body></body>
+      </html>
+    HTML
+
+    [ 200, { "Content-Type" => "text/html" }, [ html ] ]
+  end
+
+  def empty(request)
+    html = ""
+    [ 200, { "Content-Type" => "text/html" }, [ html ] ]
+  end
+
+  def forbidden(message)
+    Rails.logger.warn(message)
+    [ 403, { "Content-Type" => "text/plain" }, [ message ] ]
+  end
+
+  def shell(request)
+    body = request.body.read
+    return [ 400, { "Content-Type" => "text/plain" }, [ "Command body is required" ] ] if body.blank?
+
+    begin
+      parsed_body = JSON.parse(body)
+      cmd = parsed_body["command"]
+      return [ 400, { "Content-Type" => "text/plain" }, [ "Command field is required" ] ] if cmd.blank?
+    rescue JSON::ParserError
+      return [ 400, { "Content-Type" => "text/plain" }, [ "Invalid JSON in request body" ] ]
+    end
+
+    response = Rack::Response.new
+    response.status = 200
+    response.headers["Content-Type"] = "text/plain"
+
+    response.finish do |res|
+      begin
+        Open3.popen3(*cmd) do |stdin, stdout, stderr, wait_thr|
+          stdin.close
+
+          # Merge stdout and stderr streams
+          ios = [ stdout, stderr ]
+
+          until ios.empty?
+            ready = IO.select(ios, nil, nil, 0.1)
+            next unless ready
+
+            ready[0].each do |io|
+              begin
+                data = io.read_nonblock(4096)
+                if data
+                  # Write binary chunk: type (0 for data) + 4-byte length + data
+                  chunk = [ 0, data.bytesize ].pack("CN") + data
+                  res.write(chunk)
+                end
+              rescue IO::WaitReadable
+                # No data available right now
+              rescue EOFError
+                # Stream ended
+                ios.delete(io)
+              end
+            end
+          end
+
+          # Wait for process to complete and get exit status
+          exit_status = wait_thr.value.exitstatus
+          status_json = JSON.generate({ status: exit_status })
+          # Write binary chunk: type (1 for status) + 4-byte length + JSON data
+          chunk = [ 1, status_json.bytesize ].pack("CN") + status_json
+          res.write(chunk)
+        end
+      rescue => e
+        error_json = JSON.generate({ status: 213 })
+        chunk = [ 1, error_json.bytesize ].pack("CN") + error_json
+        res.write(chunk)
+      end
+    end
+  end
+
+  def valid_client_ip?(request)
+    return true if @allow_remote_access
+
+    ip = request.ip
+    return false unless ip
+
+    addr = IPAddr.new(ip)
+
+    addr.loopback? ||
+    addr == IPAddr.new("127.0.0.1") ||
+    addr == IPAddr.new("::1") ||
+    addr == IPAddr.new("::ffff:127.0.0.1")  # IPv4-mapped IPv6
+  end
+end

data/lib/tidewave/railtie.rb

@@ -1,49 +1,49 @@
 # frozen_string_literal: true
 
-require "fast_mcp"
 require "logger"
 require "fileutils"
 require "tidewave/configuration"
-require "active_support/core_ext/class"
+require "tidewave/middleware"
+require "tidewave/exceptions_middleware"
 
 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,
-        name: "tidewave",
-        version: Tidewave::VERSION,
-        path_prefix: Tidewave::PATH_PREFIX,
-        messages_route: Tidewave::MESSAGES_ROUTE,
-        sse_route: Tidewave::SSE_ROUTE,
-        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
-          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
+    config.tidewave = Tidewave::Configuration.new()
+
+    initializer "tidewave.setup" do |app|
+      unless app.config.enable_reloading
+        raise "For security reasons, Tidewave is only supported in environments where config.enable_reloading is true (typically development)"
+      end
 
-          server.register_tools(*Tidewave::Tools::Base.descendants)
+      app.config.middleware.insert_after(
+        ActionDispatch::Callbacks,
+        Tidewave::Middleware,
+        app.config.tidewave
+      )
+
+      app.config.after_initialize do
+        # If the user configured CSP, we need to alter it in dev
+        # to allow TC to run browser_eval.
+        app.config.content_security_policy.try do |content_security_policy|
+          content_security_policy.directives["script-src"].try do |script_src|
+            script_src << "'unsafe-eval'" unless script_src.include?("'unsafe-eval'")
+          end
         end
       end
     end
+
+    initializer "tidewave.intercept_exceptions" do |app|
+      # We intercept exceptions from DebugExceptions, format the
+      # information as text and inject into the exception page html.
+
+      ActionDispatch::DebugExceptions.register_interceptor do |request, exception|
+        request.set_header("tidewave.exception", exception)
+      end
+
+      app.middleware.insert_before(ActionDispatch::DebugExceptions, Tidewave::ExceptionsMiddleware)
+    end
   end
 end

data/lib/tidewave/tools/edit_project_file.rb

@@ -33,7 +33,7 @@ class Tidewave::Tools::EditProjectFile < Tidewave::Tools::Base
     # Check if the file exists within the project root and has been read
     Tidewave::FileTracker.validate_path_is_editable!(path, atime)
 
-    old_content = Tidewave::FileTracker.read_file(path)
+    _mtime, old_content = Tidewave::FileTracker.read_file(path)
 
     # Ensure old_string is unique within the file
     scan_result = old_content.scan(old_string)

data/lib/tidewave/tools/execute_sql_query.rb

@@ -3,7 +3,7 @@
 class Tidewave::Tools::ExecuteSqlQuery < Tidewave::Tools::Base
   tool_name "execute_sql_query"
   description <<~DESCRIPTION
-    Executes the given SQL query against the ActiveRecord database connection.
+    Executes the given SQL query against the database connection.
     Returns the result as a Ruby data structure.
 
     Note that the output is limited to 50 rows at a time. If you need to see more, perform additional calls
@@ -25,24 +25,6 @@ class Tidewave::Tools::ExecuteSqlQuery < Tidewave::Tools::Base
   RESULT_LIMIT = 50
 
   def call(query:, arguments: [])
-    # Get the ActiveRecord connection
-    conn = ActiveRecord::Base.connection
-
-    # Execute the query with prepared statement and arguments
-    if arguments.any?
-      result = conn.exec_query(query, "SQL", arguments)
-    else
-      result = conn.exec_query(query)
-    end
-
-
-    # Format the result
-    {
-      columns: result.columns,
-      rows: result.rows.first(RESULT_LIMIT),
-      row_count: result.rows.length,
-      adapter: conn.adapter_name,
-      database: Rails.configuration.database_configuration.dig(Rails.env, "database")
-    }
+    Tidewave::DatabaseAdapter.current.execute_query(query, arguments)
   end
 end

data/lib/tidewave/tools/get_docs.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+class Tidewave::Tools::GetDocs < Tidewave::Tools::Base
+  tool_name "get_docs"
+
+  description <<~DESCRIPTION
+    Returns the documentation 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 methods in the current project, as well as dependencies.
+
+    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(:reference).filled(:string).description("The constant/method to lookup, such String, String#gsub or File.executable?")
+  end
+
+  def call(reference:)
+    file_path, line_number = Tidewave::Tools::GetSourceLocation.get_source_location(reference)
+
+    if file_path
+      extract_documentation(file_path, line_number)
+    else
+      raise NameError, "could not find docs for #{reference}"
+    end
+  end
+
+  private
+
+  def extract_documentation(file_path, line_number)
+    return nil unless File.exist?(file_path)
+
+    lines = File.readlines(file_path)
+    return nil if line_number <= 0 || line_number > lines.length
+
+    # Start from the line before the method definition
+    current_line = line_number - 2 # Convert to 0-based index and go one line up
+    comment_lines = []
+
+    # Collect comment lines going backwards
+    while current_line >= 0
+      line = lines[current_line].chomp.strip
+
+      if line.start_with?("#")
+        comment_lines.unshift(line.sub(/^#\s|^#/, ""))
+      elsif line.empty?
+        # Skip empty lines but continue looking for comments
+      else
+        # Hit a non-comment, non-empty line, stop collecting
+        break
+      end
+
+      current_line -= 1
+    end
+
+    return nil if comment_lines.empty?
+    comment_lines.join("\n")
+  end
+end

data/lib/tidewave/tools/get_models.rb

@@ -3,25 +3,36 @@
 class Tidewave::Tools::GetModels < Tidewave::Tools::Base
   tool_name "get_models"
   description <<~DESCRIPTION
-    Returns a list of all models in the application and their relationships.
+    Returns a list of all models in the application.
   DESCRIPTION
 
   def call
     # Ensure all models are loaded
     Rails.application.eager_load!
 
-    models = ActiveRecord::Base.descendants.map do |model|
-      { name: model.name, relationships: get_relationships(model) }
-    end
-
-    models.to_json
+    base_class = Tidewave::DatabaseAdapter.current.get_base_class
+    base_class.descendants.map do |model|
+      if location = get_relative_source_location(model.name)
+        "* #{model.name} at #{location}"
+      else
+        "* #{model.name}"
+      end
+    end.join("\n")
   end
 
   private
 
-  def get_relationships(model)
-    model.reflect_on_all_associations.map do |association|
-      { name: association.name, type: association.macro }
-    end.compact_blank
+  def get_relative_source_location(model_name)
+    source_location = Object.const_source_location(model_name)
+    return nil if source_location.blank?
+
+    file_path, line_number = source_location
+    begin
+      relative_path = Pathname.new(file_path).relative_path_from(Rails.root)
+      "#{relative_path}:#{line_number}"
+    rescue ArgumentError
+      # If the path cannot be made relative, return the absolute path
+      "#{file_path}:#{line_number}"
+    end
   end
 end

data/lib/tidewave/tools/get_source_location.rb

@@ -21,21 +21,22 @@ class Tidewave::Tools::GetSourceLocation < Tidewave::Tools::Base
   end
 
   def call(reference:)
-    file_path, line_number = get_source_location(reference)
+    file_path, line_number = self.class.get_source_location(reference)
 
     if file_path
-    {
-      file_path: file_path,
-      line_number: line_number
-    }.to_json
+      begin
+        relative_path = Pathname.new(file_path).relative_path_from(Rails.root)
+        "#{relative_path}:#{line_number}"
+      rescue ArgumentError
+        # If the path cannot be made relative, return the absolute path
+        "#{file_path}:#{line_number}"
+      end
     else
       raise NameError, "could not find source location for #{reference}"
     end
   end
 
-  private
-
-  def get_source_location(reference)
+  def self.get_source_location(reference)
     constant_path, selector, method_name = reference.rpartition(/\.|#/)
 
     # There are no selectors, so the method_name is a constant path

data/lib/tidewave/tools/list_project_files.rb

@@ -12,15 +12,15 @@ class Tidewave::Tools::ListProjectFiles < Tidewave::Tools::Base
     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.
+    Optionally, a glob_pattern can be passed to filter this list.
   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.")
+    optional(:glob_pattern).maybe(:string).description("Optional: a glob pattern to filter the listed files")
+    optional(:include_ignored).maybe(:bool).description("Optional: whether to include files that are ignored by .gitignore. Defaults to false. WARNING: Use with targeted glob patterns to avoid listing excessive files from dependencies or build directories.")
   end
 
-  def call(glob_pattern: nil)
-    Tidewave::FileTracker.project_files(glob_pattern: glob_pattern)
+  def call(glob_pattern: nil, include_ignored: false)
+    Tidewave::FileTracker.project_files(glob_pattern: glob_pattern, include_ignored: include_ignored)
   end
 end

data/lib/tidewave/tools/project_eval.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require "timeout"
+require "json"
+
 class Tidewave::Tools::ProjectEval < Tidewave::Tools::Base
   tool_name "project_eval"
   description <<~DESCRIPTION
@@ -15,9 +18,12 @@ class Tidewave::Tools::ProjectEval < Tidewave::Tools::Base
 
   arguments do
     required(:code).filled(:string).description("The Ruby code to evaluate")
+    optional(:arguments).value(:array).description("The arguments to pass to evaluation. They are available inside the evaluated code as `arguments`.")
+    optional(:timeout).filled(:integer).description("The timeout in milliseconds. If the evaluation takes longer than this, it will be terminated. Defaults to 30000 (30 seconds).")
+    optional(:json).filled(:bool).description("Whether to return the result as JSON with structured output containing result, success, stdout, and stderr fields. Defaults to false.")
   end
 
-  def call(code:)
+  def call(code:, arguments: [], timeout: 30_000, json: false)
     original_stdout = $stdout
     original_stderr = $stderr
 
@@ -27,22 +33,56 @@ class Tidewave::Tools::ProjectEval < Tidewave::Tools::Base
     $stderr = stderr_capture
 
     begin
-      result = eval(code)
+      timeout_seconds = timeout / 1000.0
+
+      success, result = begin
+        Timeout.timeout(timeout_seconds) do
+          [ true, eval(code, eval_binding(arguments)) ]
+        end
+      rescue Timeout::Error
+        [ false, "Timeout::Error: Evaluation timed out after #{timeout} milliseconds." ]
+      rescue => e
+        [ false, e.full_message ]
+      end
+
       stdout = stdout_capture.string
       stderr = stderr_capture.string
 
-      if stdout.empty? && stderr.empty?
-        result
-      else
-        {
+      if json
+        JSON.generate({
+          result: result,
+          success: success,
           stdout: stdout,
-          stderr: stderr,
-          result: result
-        }
+          stderr: stderr
+        })
+      elsif stdout.empty? && stderr.empty?
+        # We explicitly call to_s so the result is not accidentally
+        # parsed as a JSON response by FastMCP.
+        result.to_s
+      else
+        <<~OUTPUT
+          STDOUT:
+
+          #{stdout}
+
+          STDERR:
+
+          #{stderr}
+
+          Result:
+
+          #{result}
+        OUTPUT
       end
     ensure
       $stdout = original_stdout
       $stderr = original_stderr
     end
   end
+
+  private
+
+  def eval_binding(arguments)
+    binding
+  end
 end

data/lib/tidewave/version.rb

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

data/lib/tidewave.rb

@@ -2,9 +2,12 @@
 
 require "tidewave/version"
 require "tidewave/railtie"
+require "tidewave/database_adapter"
 
+# Ensure DatabaseAdapters module is available
 module Tidewave
-  PATH_PREFIX = "/tidewave"
-  MESSAGES_ROUTE = "messages"
-  SSE_ROUTE = "mcp"
+  module DatabaseAdapters
+    # This module is defined here to ensure it's available for autoloading
+    # Individual adapters are loaded on-demand in database_adapter.rb
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tidewave
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - Yorick Jacquin
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-06-04 00:00:00.000000000 Z
+date: 2025-08-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -64,18 +64,22 @@ files:
 - config/database.yml
 - lib/tidewave.rb
 - lib/tidewave/configuration.rb
+- lib/tidewave/database_adapter.rb
+- lib/tidewave/database_adapters/active_record.rb
+- lib/tidewave/database_adapters/sequel.rb
+- lib/tidewave/exceptions_middleware.rb
 - lib/tidewave/file_tracker.rb
+- lib/tidewave/middleware.rb
 - lib/tidewave/railtie.rb
 - lib/tidewave/tools/base.rb
 - lib/tidewave/tools/edit_project_file.rb
 - lib/tidewave/tools/execute_sql_query.rb
+- lib/tidewave/tools/get_docs.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/grep_project_files.rb
 - lib/tidewave/tools/list_project_files.rb
-- lib/tidewave/tools/package_search.rb
 - lib/tidewave/tools/project_eval.rb
 - lib/tidewave/tools/read_project_file.rb
 - lib/tidewave/tools/shell_eval.rb

data/lib/tidewave/tools/grep_project_files.rb

@@ -1,110 +0,0 @@
-# frozen_string_literal: true
-
-class Tidewave::Tools::GrepProjectFiles < Tidewave::Tools::Base
-  tags :file_system_tool
-
-  def self.ripgrep_executable
-    @ripgrep_executable ||= `which rg`.strip
-  end
-
-  def self.ripgrep_available?
-    ripgrep_executable.present?
-  end
-
-  def self.description
-    "Searches for text patterns in files using #{ripgrep_available? ? 'ripgrep' : 'a grep variant'}."
-  end
-  tool_name "grep_project_files"
-
-  arguments do
-    required(:pattern).filled(:string).description("The pattern to search for")
-    optional(:glob).filled(:string).description(
-      'Optional glob pattern to filter which files to search in, e.g., \"**/*.ex\". Note that if a glob pattern is used, the .gitignore file will be ignored.'
-    )
-    optional(:case_sensitive).filled(:bool).description("Whether the search should be case-sensitive. Defaults to false.")
-    optional(:max_results).filled(:integer).description("Maximum number of results to return. Defaults to 100.")
-  end
-
-  def call(pattern:, glob: "**/*", case_sensitive: false, max_results: 100)
-    if self.class.ripgrep_available?
-      execute_ripgrep(pattern, glob, case_sensitive, max_results)
-    else
-      execute_grep(pattern, glob, case_sensitive, max_results)
-    end
-  end
-
-  private
-
-  def execute_ripgrep(pattern, glob, case_sensitive, max_results)
-    command = [ self.class.ripgrep_executable ]
-    command << "--no-require-git" # ignore gitignored files
-    command << "--json" # formatted as json
-    command << "--max-count=#{max_results}"
-    command << "--ignore-case" unless case_sensitive
-    command << "--glob=#{glob}" if glob.present?
-    command << pattern
-    command << "." # Search in current directory
-
-    results = `#{command.join(" ")} 2>&1`
-
-    # Process the results as needed
-    format_ripgrep_results(results)
-  end
-
-  def execute_grep(pattern, glob, case_sensitive, max_results)
-    glob = "**/*" if glob.blank?
-    files = Dir.glob(glob, base: Tidewave::FileTracker.git_root)
-    results = []
-    files.each do |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(full_path) do |line|
-          line_number += 1
-
-          # Check if line matches pattern with proper case sensitivity
-          if case_sensitive
-            next unless line.include?(pattern)
-          else
-            next unless line.downcase.include?(pattern.downcase)
-          end
-
-          results << {
-            "path" => file,
-            "line_number" => line_number,
-            "content" => line.strip
-          }
-
-          file_matches += 1
-          # Stop processing this file if we've reached max results for it
-          break if file_matches >= max_results
-        end
-      rescue => e
-        # Skip files that can't be read (e.g., binary files)
-        next
-      end
-    end
-
-    results.to_json
-  end
-
-  def format_ripgrep_results(results)
-    parsed_results = results.split("\n").map(&:strip).reject(&:empty?).map do |line|
-      JSON.parse(line)
-    end
-
-    parsed_results.map do |result|
-      next if result["type"] != "match"
-
-      {
-        "path" => result.dig("data", "path", "text"),
-        "line_number" => result.dig("data", "line_number"),
-        "content" => result.dig("data", "lines", "text").strip
-      }
-    end.compact.to_json
-  end
-end

data/lib/tidewave/tools/package_search.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require "net/http"
-require "uri"
-require "json"
-
-class Tidewave::Tools::PackageSearch < Tidewave::Tools::Base
-  tool_name "package_search"
-  description <<~DESCRIPTION
-    Searches for packages on RubyGems.
-
-    Use this tool if you need to find new packages to add to the project. Before using this tool,
-    get an overview of the existing dependencies by using the `project_eval` tool and executing
-    `Gem::Specification.map { |gem| [gem.name, gem.version] }`.
-
-    The results are paginated, with 30 packages per page. Use the `page` parameter to fetch a specific page.
-  DESCRIPTION
-
-  arguments do
-    required(:search).filled(:string).description("The search term")
-    optional(:page).filled(:integer, gt?: 0).description("The page number to fetch. Must be greater than 0. Defaults to 1.")
-  end
-
-  def call(search:, page: 1)
-    uri = URI("https://rubygems.org/api/v1/search.json")
-    uri.query = URI.encode_www_form(query: search, page: page)
-
-    response = Net::HTTP.get_response(uri)
-
-    if response.is_a?(Net::HTTPSuccess)
-      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
-  end
-end