tidewave 0.1.3 → 0.3.0

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_logs.rb

@@ -10,13 +10,20 @@ class Tidewave::Tools::GetLogs < Tidewave::Tools::Base
 
   arguments do
     required(:tail).filled(:integer).description("The number of log entries to return from the end of the log")
+    optional(:grep).filled(:string).description("Filter logs with the given regular expression (case insensitive). E.g. \"error\" when you want to capture errors in particular")
   end
 
-  def call(tail:)
+  def call(tail:, grep: nil)
     log_file = Rails.root.join("log", "#{Rails.env}.log")
     return "Log file not found" unless File.exist?(log_file)
 
-    logs = File.readlines(log_file).last(tail)
-    logs.join
+    logs = File.readlines(log_file)
+
+    if grep
+      regex = Regexp.new(grep, Regexp::IGNORECASE)
+      logs = logs.select { |line| line.match?(regex) }
+    end
+
+    logs.last(tail).join
   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 database-backed 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

@@ -10,10 +10,11 @@ class Tidewave::Tools::GetSourceLocation < Tidewave::Tools::Base
     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.
+    This tool only works if you know the specific constant/method being targeted,
+    and it works across the current project and all dependencies.
     If that is the case, prefer this tool over grepping the file system.
+
+    You may also get the root location of a gem, you can use "dep:PACKAGE_NAME".
   DESCRIPTION
 
   arguments do
@@ -21,21 +22,40 @@ class Tidewave::Tools::GetSourceLocation < Tidewave::Tools::Base
   end
 
   def call(reference:)
-    file_path, line_number = get_source_location(reference)
+    # Check if this is a package location request
+    if reference.start_with?("dep:")
+      package_name = reference.gsub("dep:", "")
+      return get_package_location(package_name)
+    end
+
+    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_package_location(package)
+    raise "dep: prefix only works with projects using Bundler" unless defined?(Bundler)
+    specs = Bundler.load.specs
+
+    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
+  end
 
-  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/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).hidden().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.3.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,15 @@
 --- !ruby/object:Gem::Specification
 name: tidewave
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.3.0
 platform: ruby
 authors:
 - Yorick Jacquin
+- José Valim
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-06-04 00:00:00.000000000 Z
+date: 2025-09-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -64,22 +65,20 @@ files:
 - config/database.yml
 - lib/tidewave.rb
 - lib/tidewave/configuration.rb
-- lib/tidewave/file_tracker.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/middleware.rb
+- lib/tidewave/quiet_requests_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
-- lib/tidewave/tools/write_project_file.rb
 - lib/tidewave/version.rb
 homepage: https://tidewave.ai/
 licenses:

data/lib/tidewave/file_tracker.rb

@@ -1,101 +0,0 @@
-# frozen_string_literal: true
-
-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" ]
-      `git #{args.join(" ")}`.split("\n")
-    end
-
-    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)
-
-      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
-
-      [ mtime, content ]
-    end
-
-    def write_file(path, content)
-      validate_ruby_syntax!(content) if ruby_file?(path)
-      full_path = file_full_path(path)
-
-      # Create the directory if it doesn't exist
-      dirname = File.dirname(full_path)
-      FileUtils.mkdir_p(dirname)
-
-      # Write and return the file contents
-      File.write(full_path, content)
-      content
-    end
-
-    def file_full_path(path)
-      File.join(git_root, path)
-    end
-
-    def git_root
-      @git_root ||= `git rev-parse --show-toplevel`.strip
-    end
-
-    def validate_path_access!(path, validate_existence: true)
-      raise ArgumentError, "File path must not contain '..'" if path.include?("..")
-
-      # Ensure the path is within the project
-      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)
-
-      # Verify the file exists
-      raise ArgumentError, "File not found: #{path}" if validate_existence && !File.exist?(full_path)
-
-      true
-    end
-
-    def validate_path_is_editable!(path, atime)
-      validate_path_access!(path)
-      validate_path_has_been_read_since_last_write!(path, atime)
-
-      true
-    end
-
-    def validate_path_is_writable!(path, atime)
-      validate_path_access!(path, validate_existence: false)
-      validate_path_has_been_read_since_last_write!(path, atime)
-
-      true
-    end
-
-    private
-
-    def ruby_file?(path)
-      [ ".rb", ".rake", ".gemspec" ].include?(File.extname(path)) ||
-        [ "Gemfile" ].include?(File.basename(path))
-    end
-
-    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
-
-      true
-    end
-  end
-end

data/lib/tidewave/tools/edit_project_file.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-require "tidewave/file_tracker"
-
-class Tidewave::Tools::EditProjectFile < Tidewave::Tools::Base
-  tags :file_system_tool
-
-  tool_name "edit_project_file"
-  description <<~DESCRIPTION
-    A tool for editing parts of a file. It can find and replace text inside a file.
-    For moving or deleting files, use the shell_eval tool with 'mv' or 'rm' instead.
-
-    For large edits, use the write_project_file tool instead and overwrite the entire file.
-
-    Before editing, ensure to read the source file using the read_project_file tool.
-
-    To use this tool, provide the path to the file, the old_string to search for, and the new_string to replace it with.
-    If the old_string is found multiple times, an error will be returned. To ensure uniqueness, include a couple of lines
-    before and after the edit. All whitespace must be preserved as in the original file.
-
-    This tool can only do a single edit at a time. If you need to make multiple edits, you can create a message with
-    multiple tool calls to this tool, ensuring that each one contains enough context to uniquely identify the edit.
-  DESCRIPTION
-
-  arguments do
-    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:, atime: nil)
-    # 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)
-
-    # Ensure old_string is unique within the file
-    scan_result = old_content.scan(old_string)
-    raise ArgumentError, "old_string is not found" if scan_result.empty?
-    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

@@ -1,41 +0,0 @@
-# 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/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