tidewave 0.1.2 → 0.2.0

data/lib/tidewave/railtie.rb

@@ -1,40 +1,49 @@
 # frozen_string_literal: true
 
-require "fast_mcp"
 require "logger"
 require "fileutils"
-require "tidewave/tool_resolver"
 require "tidewave/configuration"
+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
-          # 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
+    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
+
+      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/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

@@ -3,7 +3,7 @@
 require "tidewave/file_tracker"
 
 class Tidewave::Tools::EditProjectFile < Tidewave::Tools::Base
-  file_system_tool
+  tags :file_system_tool
 
   tool_name "edit_project_file"
   description <<~DESCRIPTION
@@ -26,13 +26,14 @@ 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)
+    _mtime, old_content = Tidewave::FileTracker.read_file(path)
 
     # Ensure old_string is unique within the file
     scan_result = old_content.scan(old_string)
@@ -40,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/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_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,61 @@
 # 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(module_name:, function_name: nil)
-    file_path, line_number = get_source_location(module_name, function_name)
-
-    {
-      file_path: file_path,
-      line_number: line_number
-    }.to_json
+  def call(reference:)
+    file_path, line_number = self.class.get_source_location(reference)
+
+    if file_path
+      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 self.get_source_location(reference)
+    constant_path, selector, method_name = reference.rpartition(/\.|#/)
+
+    # There are no selectors, so the method_name is a constant path
+    return Object.const_source_location(method_name) if selector.empty?
 
-  def get_source_location(module_name, function_name)
     begin
-      module_ref = module_name.constantize
-    rescue NameError
-      raise NameError, "Module #{module_name} not found"
+      mod = Object.const_get(constant_path)
+    rescue NameError => e
+      raise e
+    rescue
+      raise "wrong or invalid reference #{reference}"
     end
 
-    return get_method_definition(module_ref, function_name) if function_name.present?
+    raise "reference #{constant_path} does not point a class/module" unless mod.is_a?(Module)
 
-    module_ref.const_source_location(module_name)
-  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
-
-  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/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.
+  DESC
+
+  arguments do
+    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, 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/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.2"
+  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