tidewave 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ee211dd3b35cb2ea32392547b47a98b0f8e990396b2a8380b84ed276e1d31bc2
+  data.tar.gz: 2c93855bf42fc23fc66385b1c9c5cf0ff58279cc63a3bc15b3b85bf291529817
+SHA512:
+  metadata.gz: 7b2d3559b9e38fc4b8f619502d41d90aa23cbdae59446f8d53d84e22be0eb41a6ae8e39223e5ccd0a37ee4a50086c2dbdd460b4dfb4ef8236677d430d6e8f3ff
+  data.tar.gz: a306c3e8fa81bf5b7794d5789aa62c5169eba6a60e36f1e68105d1740e9c5bbe464558c4911b04cb5a6c7560cacb532c2312d4f588192341ed458401d6e345f4

data/README.md

@@ -0,0 +1,61 @@
+# Tidewave
+
+Tidewave speeds up development with an AI assistant that understands your web application,
+how it runs, and what it delivers. Our current release connects your editor's
+assistant to your web framework runtime via [MCP](https://modelcontextprotocol.io/).
+
+[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:
+
+```ruby
+gem "tidewave", group: :development
+```
+
+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).
+
+## Considerations
+
+### 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.
+
+### Web server requirements
+
+Tidewave currently requires a threaded web server like Puma.
+
+## Acknowledgements
+
+A thank you to Yorick Jacquin, for creating [FastMCP](https://github.com/yjacquin/fast_mcp) and implementing the initial version of this project.
+
+## License
+
+Copyright (c) 2025 Dashbit
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at [http://www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0)
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/Rakefile

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+
+load "rails/tasks/engine.rake"
+
+load "rails/tasks/statistics.rake"
+
+require "bundler/gem_tasks"

data/config/database.yml

@@ -0,0 +1,3 @@
+test:
+  adapter: sqlite3
+  database: ":memory:"

data/lib/tidewave/file_tracker.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Tidewave
+  module FileTracker
+    extend self
+
+    def project_files
+      `git --git-dir #{git_root}/.git ls-files --cached --others --exclude-standard`.split("\n")
+    end
+
+    def read_file(path)
+      validate_path_access!(path)
+
+      # Retrieve the full path
+      full_path = file_full_path(path)
+
+      # Record the file as read
+      record_read(path)
+
+      # Read and return the file contents
+      File.read(full_path)
+    end
+
+    def write_file(path, content)
+      validate_path_access!(path, validate_existence: false)
+      # Retrieve the full path
+      full_path = file_full_path(path)
+
+      dirname = File.dirname(full_path)
+
+      # Create the directory if it doesn't exist
+      FileUtils.mkdir_p(dirname)
+
+      # Write the file contents
+      File.write(full_path, content)
+
+      # Read and return the file contents
+      read_file(path)
+    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 start with '..'" if path.start_with?("..")
+
+      # 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}" unless File.exist?(full_path) && validate_existence
+
+      true
+    end
+
+    def validate_path_is_editable!(path)
+      validate_path_access!(path)
+      validate_path_has_been_read_since_last_write!(path)
+
+      true
+    end
+
+    def validate_path_is_writable!(path)
+      validate_path_access!(path, validate_existence: false)
+      validate_path_has_been_read_since_last_write!(path)
+
+      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)
+
+      true
+    end
+
+    # Record when a file was read
+    def record_read(path)
+      file_records[path] = Time.now
+    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 ||= {}
+    end
+  end
+end

data/lib/tidewave/railtie.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "fast_mcp"
+require "logger"
+require "fileutils"
+require "tidewave/tool_resolver"
+
+module Tidewave
+  class Railtie < Rails::Railtie
+    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?
+
+      # 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: Logger.new(STDOUT)
+      ) 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
+        end
+      end
+    end
+
+    # Install generator to set up necessary files in the host application
+    generators do
+      require "generators/tidewave/install/install_generator"
+    end
+  end
+end

data/lib/tidewave/tool_resolver.rb

@@ -0,0 +1,70 @@
+# 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/base.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+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
+
+  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")
+  end
+
+  def call(path:, old_string:, new_string:)
+    # Check if the file exists within the project root and has been read
+    Tidewave::FileTracker.validate_path_is_editable!(path)
+
+    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)
+  end
+end

data/lib/tidewave/tools/execute_sql_query.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+class Tidewave::Tools::ExecuteSqlQuery < Tidewave::Tools::Base
+  tool_name "execute_sql_query"
+  description <<~DESCRIPTION
+    Executes the given SQL query against the ActiveRecord 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
+    using LIMIT and OFFSET in the query. If you know that only specific columns are relevant,
+    only include those in the SELECT clause.
+
+    You can use this tool to select user data, manipulate entries, and introspect the application data domain.
+    Always ensure to use the correct SQL commands for the database you are using.
+
+    For PostgreSQL, use $1, $2, etc. for parameter placeholders.
+    For MySQL, use ? for parameter placeholders.
+  DESCRIPTION
+
+  arguments do
+    required(:query).filled(:string).description("The SQL query to execute. For PostgreSQL, use $1, $2 placeholders. For MySQL, use ? placeholders.")
+    optional(:arguments).value(:array).description("The arguments to pass to the query. The query must contain corresponding parameter placeholders.")
+  end
+
+  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")
+    }
+  end
+end

data/lib/tidewave/tools/get_logs.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+class Tidewave::Tools::GetLogs < Tidewave::Tools::Base
+  tool_name "get_logs"
+  description <<~DESCRIPTION
+    Returns all log output, excluding logs that were caused by other tool calls.
+
+    Use this tool to check for request logs or potentially logged errors.
+  DESCRIPTION
+
+  arguments do
+    required(:tail).filled(:integer).description("The number of log entries to return from the end of the log")
+  end
+
+  def call(tail:)
+    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
+  end
+end

data/lib/tidewave/tools/get_models.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+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.
+  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
+  end
+
+  private
+
+  def get_relationships(model)
+    model.reflect_on_all_associations.map do |association|
+      { name: association.name, type: association.macro }
+    end.compact_blank
+  end
+end

data/lib/tidewave/tools/get_source_location.rb

@@ -0,0 +1,58 @@
+# 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).
+
+    This works for modules 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.
+    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.")
+  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
+  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
+
+    return get_method_definition(module_ref, function_name) if function_name.present?
+
+    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}"
+  end
+end

data/lib/tidewave/tools/glob_project_files.rb

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

data/lib/tidewave/tools/grep_project_files.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+class Tidewave::Tools::GrepProjectFiles < Tidewave::Tools::Base
+  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)
+    files = Tidewave::Tools::GlobProjectFiles.new.call(pattern: glob)
+    results = []
+    files.each do |file|
+      next unless File.file?(file)
+
+      begin
+        file_matches = 0
+        line_number = 0
+
+        File.foreach(file) 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/list_project_files.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "tidewave/file_tracker"
+
+class Tidewave::Tools::ListProjectFiles < Tidewave::Tools::Base
+  file_system_tool
+
+  tool_name "list_project_files"
+  description "Returns a list of all files in the project that are not ignored by .gitignore."
+
+  def call
+    Tidewave::FileTracker.project_files
+  end
+end

data/lib/tidewave/tools/package_search.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "faraday"
+
+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)
+    response = rubygems_client.get("/api/v1/search.json?query=#{search}&page=#{page}")
+
+    response.body
+  end
+
+  private
+
+  def rubygems_client
+    @rubygems_client ||= Faraday.new(url: "https://rubygems.org") do |faraday|
+      faraday.response :raise_error
+
+      faraday.adapter Faraday.default_adapter
+    end
+  end
+end

data/lib/tidewave/tools/project_eval.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+class Tidewave::Tools::ProjectEval < Tidewave::Tools::Base
+  tool_name "project_eval"
+  description <<~DESCRIPTION
+    Evaluates Ruby code in the context of the project.
+
+    The current Ruby version is: #{RUBY_VERSION}
+
+    The code is executed in the context of the user's project, therefore use this tool any
+    time you need to evaluate code, for example to test the behavior of a function or to debug
+    something. The tool also returns anything written to standard output.
+  DESCRIPTION
+
+  arguments do
+    required(:code).filled(:string).description("The Ruby code to evaluate")
+  end
+
+  def call(code:)
+    original_stdout = $stdout
+    original_stderr = $stderr
+
+    stdout_capture = StringIO.new
+    stderr_capture = StringIO.new
+    $stdout = stdout_capture
+    $stderr = stderr_capture
+
+    begin
+      result = eval(code)
+      stdout = stdout_capture.string
+      stderr = stderr_capture.string
+
+      if stdout.empty? && stderr.empty?
+        result
+      else
+        {
+          stdout: stdout,
+          stderr: stderr,
+          result: result
+        }
+      end
+    ensure
+      $stdout = original_stdout
+      $stderr = original_stderr
+    end
+  end
+end

data/lib/tidewave/tools/read_project_file.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "tidewave/file_tracker"
+
+class Tidewave::Tools::ReadProjectFile < Tidewave::Tools::Base
+  file_system_tool
+
+  tool_name "read_project_file"
+  description <<~DESCRIPTION
+    Returns the contents of the given file. Matches the `resources/read` MCP method.
+  DESCRIPTION
+
+  arguments do
+    required(:path).filled(:string).description("The path to the file to read. It is relative to the project root.")
+  end
+
+  def call(path:)
+    Tidewave::FileTracker.read_file(path)
+  end
+end

data/lib/tidewave/tools/shell_eval.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "open3"
+
+class Tidewave::Tools::ShellEval < Tidewave::Tools::Base
+  file_system_tool
+  class CommandFailedError < StandardError; end
+
+  tool_name "shell_eval"
+  description <<~DESCRIPTION
+    Executes a shell command in the project root directory.
+
+    Avoid using this tool for file operations. Instead, rely on dedicated file system tools, if available.
+
+    The operating system is of flavor #{RUBY_PLATFORM}.
+
+    Only use this tool if other means are not available.
+  DESCRIPTION
+
+  arguments do
+    required(:command).filled(:string).description("The shell command to execute. Avoid using this for file operations; use dedicated file system tools instead.")
+  end
+
+  def call(command:)
+    stdout, status = Open3.capture2e(command)
+    raise CommandFailedError, "Command failed with status #{status.exitstatus}:\n\n#{stdout}" unless status.exitstatus.zero?
+
+    stdout.strip
+  end
+end

data/lib/tidewave/tools/write_project_file.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "tidewave/file_tracker"
+
+class Tidewave::Tools::WriteProjectFile < Tidewave::Tools::Base
+  file_system_tool
+
+  tool_name "write_project_file"
+  description <<~DESCRIPTION
+    Writes a file to the file system. If the file already exists, it will be overwritten.
+
+    Note that this tool will fail if the file wasn't previously read with the `read_project_file` tool.
+  DESCRIPTION
+
+  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")
+  end
+
+  def call(path:, content:)
+    Tidewave::FileTracker.validate_path_is_writable!(path)
+
+    Tidewave::FileTracker.write_file(path, content)
+  end
+end

data/lib/tidewave/version.rb

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

data/lib/tidewave.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "tidewave/version"
+require "tidewave/railtie"
+
+module Tidewave
+  PATH_PREFIX = "/tidewave"
+  MESSAGES_ROUTE = "messages"
+  SSE_ROUTE = "mcp"
+end

metadata

@@ -0,0 +1,124 @@
+--- !ruby/object:Gem::Specification
+name: tidewave
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Yorick Jacquin
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-04-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.2.0
+- !ruby/object:Gem::Dependency
+  name: fast-mcp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.13.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.13.0
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: Tidewave for Rails
+email:
+- support@tidewave.ai
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- config/database.yml
+- lib/tidewave.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_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
+- 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:
+- Apache-2.0
+metadata:
+  homepage_uri: https://tidewave.ai/
+  source_code_uri: https://github.com/tidewave-ai/tidewave_rails
+  changelog_uri: https://github.com/tidewave-ai/tidewave_rails/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.1
+signing_key:
+specification_version: 4
+summary: Tidewave for Rails
+test_files: []