rails-mcp-server 1.0.1 → 1.1.0

data/lib/rails-mcp-server/tools/analyze_models.rb

@@ -0,0 +1,116 @@
+module RailsMcpServer
+  class AnalyzeModels < BaseTool
+    tool_name "analize_models"
+
+    description "Retrieve detailed information about Active Record models in the project. When called without parameters, lists all model files. When a specific model is specified, returns its schema, associations (has_many, belongs_to, has_one), and complete source code."
+
+    arguments do
+      optional(:model_name).filled(:string).description("Class name of a specific model to get detailed information for (e.g., 'User', 'Product'). Use CamelCase, not snake_case. If omitted, returns a list of all models.")
+    end
+
+    def call(model_name: nil)
+      unless current_project
+        message = "No active project. Please switch to a project first."
+        log(:warn, message)
+
+        return message
+      end
+
+      if model_name
+        log(:info, "Getting info for specific model: #{model_name}")
+
+        # Check if the model file exists
+        model_file = File.join(active_project_path, "app", "models", "#{underscore(model_name)}.rb")
+        unless File.exist?(model_file)
+          log(:warn, "Model file not found: #{model_name}")
+          message = "Model '#{model_name}' not found."
+          log(:warn, message)
+
+          return message
+        end
+
+        log(:debug, "Reading model file: #{model_file}")
+
+        # Get the model file content
+        model_content = File.read(model_file)
+
+        # Try to get schema information
+        log(:debug, "Executing Rails runner to get schema information")
+        schema_info = execute_rails_command(
+          active_project_path,
+          "runner \"puts #{model_name}.column_names\""
+        )
+
+        # Try to get associations
+        associations = []
+        if model_content.include?("has_many")
+          has_many = model_content.scan(/has_many\s+:(\w+)/).flatten
+          associations << "Has many: #{has_many.join(", ")}" unless has_many.empty?
+        end
+
+        if model_content.include?("belongs_to")
+          belongs_to = model_content.scan(/belongs_to\s+:(\w+)/).flatten
+          associations << "Belongs to: #{belongs_to.join(", ")}" unless belongs_to.empty?
+        end
+
+        if model_content.include?("has_one")
+          has_one = model_content.scan(/has_one\s+:(\w+)/).flatten
+          associations << "Has one: #{has_one.join(", ")}" unless has_one.empty?
+        end
+
+        log(:debug, "Found #{associations.size} associations for model: #{model_name}")
+
+        # Format the output
+        <<~INFO
+          Model: #{model_name}
+          
+          Schema:
+          #{schema_info}
+          
+          Associations:
+          #{associations.empty? ? "None found" : associations.join("\n")}
+          
+          Model Definition:
+          ```ruby
+          #{model_content}
+          ```
+        INFO
+      else
+        log(:info, "Listing all models")
+
+        # List all models
+        models_dir = File.join(active_project_path, "app", "models")
+        unless File.directory?(models_dir)
+          message = "Models directory not found."
+          log(:warn, message)
+
+          return message
+        end
+
+        # Get all .rb files in the models directory and its subdirectories
+        model_files = Dir.glob(File.join(models_dir, "**", "*.rb"))
+          .map { |f| f.sub("#{models_dir}/", "").sub(/\.rb$/, "") }
+          .sort # rubocop:disable Performance/ChainArrayAllocation
+
+        log(:debug, "Found #{model_files.size} model files")
+
+        "Models in the project:\n\n#{model_files.join("\n")}"
+      end
+    end
+
+    private
+
+    def execute_rails_command(project_path, command)
+      full_command = "cd #{project_path} && bin/rails #{command}"
+      `#{full_command}`
+    end
+
+    def underscore(string)
+      string.gsub("::", "/")
+        .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+        .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+        .tr("-", "_")
+        .downcase
+    end
+  end
+end

data/lib/rails-mcp-server/tools/base_tool.rb

@@ -0,0 +1,9 @@
+module RailsMcpServer
+  class BaseTool < FastMcp::Tool
+    extend Forwardable
+
+    def_delegators :RailsMcpServer, :log, :projects
+    def_delegators :RailsMcpServer, :current_project=, :current_project
+    def_delegators :RailsMcpServer, :active_project_path=, :active_project_path
+  end
+end

data/lib/rails-mcp-server/tools/get_file.rb

@@ -0,0 +1,55 @@
+module RailsMcpServer
+  class GetFile < BaseTool
+    tool_name "get_file"
+
+    description "Retrieve the complete content of a specific file with syntax highlighting. Use this to examine implementation details, configurations, or any text file in the project."
+
+    arguments do
+      required(:path).filled(:string).description("File path relative to the project root (e.g., 'app/models/user.rb', 'config/routes.rb'). Use list_files first if you're not sure about the exact path.")
+    end
+
+    def call(path:)
+      unless current_project
+        message = "No active project. Please switch to a project first."
+        log(:warn, message)
+
+        return message
+      end
+
+      full_path = File.join(active_project_path, path)
+
+      unless File.exist?(full_path)
+        message = "File '#{path}' not found in the project."
+        log(:warn, message)
+
+        return message
+      end
+
+      content = File.read(full_path)
+      log(:debug, "Read file: #{path} (#{content.size} bytes)")
+
+      "File: #{path}\n\n```#{get_file_extension(path)}\n#{content}\n```"
+    end
+
+    private
+
+    def get_file_extension(path)
+      case File.extname(path).downcase
+      when ".rb"
+        "ruby"
+      when ".js"
+        "javascript"
+      when ".html", ".erb"
+        "html"
+      when ".css"
+        "css"
+      when ".json"
+        "json"
+      when ".yml", ".yaml"
+        "yaml"
+      else
+        ""
+      end
+    end
+  end
+end

data/lib/rails-mcp-server/tools/get_model.rb

@@ -0,0 +1,116 @@
+module RailsMcpServer
+  class GetModels < BaseTool
+    tool_name "get_models"
+
+    description "Retrieve detailed information about Active Record models in the project. When called without parameters, lists all model files. When a specific model is specified, returns its schema, associations (has_many, belongs_to, has_one), and complete source code."
+
+    arguments do
+      optional(:model_name).filled(:string).description("Class name of a specific model to get detailed information for (e.g., 'User', 'Product'). Use CamelCase, not snake_case. If omitted, returns a list of all models.")
+    end
+
+    def call(model_name: nil)
+      unless current_project
+        message = "No active project. Please switch to a project first."
+        log(:warn, message)
+
+        return message
+      end
+
+      if model_name
+        log(:info, "Getting info for specific model: #{model_name}")
+
+        # Check if the model file exists
+        model_file = File.join(active_project_path, "app", "models", "#{underscore(model_name)}.rb")
+        unless File.exist?(model_file)
+          log(:warn, "Model file not found: #{model_name}")
+          message = "Model '#{model_name}' not found."
+          log(:warn, message)
+
+          return message
+        end
+
+        log(:debug, "Reading model file: #{model_file}")
+
+        # Get the model file content
+        model_content = File.read(model_file)
+
+        # Try to get schema information
+        log(:debug, "Executing Rails runner to get schema information")
+        schema_info = execute_rails_command(
+          active_project_path,
+          "runner \"puts #{model_name}.column_names\""
+        )
+
+        # Try to get associations
+        associations = []
+        if model_content.include?("has_many")
+          has_many = model_content.scan(/has_many\s+:(\w+)/).flatten
+          associations << "Has many: #{has_many.join(", ")}" unless has_many.empty?
+        end
+
+        if model_content.include?("belongs_to")
+          belongs_to = model_content.scan(/belongs_to\s+:(\w+)/).flatten
+          associations << "Belongs to: #{belongs_to.join(", ")}" unless belongs_to.empty?
+        end
+
+        if model_content.include?("has_one")
+          has_one = model_content.scan(/has_one\s+:(\w+)/).flatten
+          associations << "Has one: #{has_one.join(", ")}" unless has_one.empty?
+        end
+
+        log(:debug, "Found #{associations.size} associations for model: #{model_name}")
+
+        # Format the output
+        <<~INFO
+          Model: #{model_name}
+          
+          Schema:
+          #{schema_info}
+          
+          Associations:
+          #{associations.empty? ? "None found" : associations.join("\n")}
+          
+          Model Definition:
+          ```ruby
+          #{model_content}
+          ```
+        INFO
+      else
+        log(:info, "Listing all models")
+
+        # List all models
+        models_dir = File.join(active_project_path, "app", "models")
+        unless File.directory?(models_dir)
+          message = "Models directory not found."
+          log(:warn, message)
+
+          return message
+        end
+
+        # Get all .rb files in the models directory and its subdirectories
+        model_files = Dir.glob(File.join(models_dir, "**", "*.rb"))
+          .map { |f| f.sub("#{models_dir}/", "").sub(/\.rb$/, "") }
+          .sort # rubocop:disable Performance/ChainArrayAllocation
+
+        log(:debug, "Found #{model_files.size} model files")
+
+        "Models in the project:\n\n#{model_files.join("\n")}"
+      end
+    end
+
+    private
+
+    def execute_rails_command(project_path, command)
+      full_command = "cd #{project_path} && bin/rails #{command}"
+      `#{full_command}`
+    end
+
+    def underscore(string)
+      string.gsub("::", "/")
+        .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+        .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+        .tr("-", "_")
+        .downcase
+    end
+  end
+end

data/lib/rails-mcp-server/tools/get_routes.rb

@@ -0,0 +1,24 @@
+module RailsMcpServer
+  class GetRoutes < BaseTool
+    tool_name "get_routes"
+
+    description "Retrieve all HTTP routes defined in the Rails application with their associated controllers and actions. Equivalent to running 'rails routes' command. This helps understand the API endpoints or page URLs available in the application."
+
+    def call
+      unless current_project
+        message = "No active project. Please switch to a project first."
+        log(:warn, message)
+
+        return message
+      end
+
+      # Execute the Rails routes command
+      routes_output = RailsMcpServer::RunProcess.execute_rails_command(
+        active_project_path, "bin/rails routes"
+      )
+      log(:debug, "Routes command completed, output size: #{routes_output.size} bytes")
+
+      "Rails Routes:\n\n```\n#{routes_output}\n```"
+    end
+  end
+end

data/lib/rails-mcp-server/tools/get_schema.rb

@@ -0,0 +1,141 @@
+module RailsMcpServer
+  class GetSchema < BaseTool
+    tool_name "get_schema"
+
+    description "Retrieve database schema information for the Rails application. Without parameters, returns all tables and the complete schema.rb. With a table name, returns detailed column information including data types, constraints, and foreign keys for that specific table."
+
+    arguments do
+      optional(:table_name).filled(:string).description("Database table name to get detailed schema information for (e.g., 'users', 'products'). Use snake_case, plural form. If omitted, returns complete database schema.")
+    end
+
+    def call(table_name: nil)
+      unless current_project
+        message = "No active project. Please switch to a project first."
+        log(:warn, message)
+
+        return message
+      end
+
+      if table_name
+        log(:info, "Getting schema for table: #{table_name}")
+
+        # Execute the Rails schema command for a specific table
+        schema_output = RailsMcpServer::RunProcess.execute_rails_command(
+          active_project_path,
+          "bin/rails runner \"require 'active_record'; puts ActiveRecord::Base.connection.columns('#{table_name}').map{|c| [c.name, c.type, c.null, c.default].inspect}.join('\n')\""
+        )
+
+        if schema_output.strip.empty?
+          message = "Table '#{table_name}' not found or has no columns."
+          log(:warn, message)
+
+          return message
+        end
+
+        # Parse the column information
+        columns = schema_output.strip.split("\n").map do |column_info|
+          eval(column_info) # This is safe because we're generating the string ourselves # rubocop:disable Security/Eval
+        end
+
+        # Format the output
+        formatted_columns = columns.map do |name, type, nullable, default|
+          "#{name} (#{type})#{nullable ? ", nullable" : ""}#{default ? ", default: #{default}" : ""}"
+        end
+
+        output = <<~SCHEMA
+          Table: #{table_name}
+
+          Columns:
+          #{formatted_columns.join("\n")}
+        SCHEMA
+
+        # Try to get foreign keys
+        begin
+          fk_output = RailsMcpServer::RunProcess.execute_rails_command(
+            active_project_path,
+            "bin/rails runner \"require 'active_record'; puts ActiveRecord::Base.connection.foreign_keys('#{table_name}').map{|fk| [fk.from_table, fk.to_table, fk.column, fk.primary_key].inspect}.join('\n')\""
+          )
+
+          unless fk_output.strip.empty?
+            foreign_keys = fk_output.strip.split("\n").map do |fk_info|
+              eval(fk_info) # This is safe because we're generating the string ourselves # rubocop:disable Security/Eval
+            end
+
+            formatted_fks = foreign_keys.map do |from_table, to_table, column, primary_key|
+              "#{column} -> #{to_table}.#{primary_key}"
+            end
+
+            output += <<~FK
+
+              Foreign Keys:
+              #{formatted_fks.join("\n")}
+            FK
+          end
+        rescue => e
+          log(:warn, "Error fetching foreign keys: #{e.message}")
+        end
+
+        output
+      else
+        log(:info, "Getting full schema")
+
+        # Execute the Rails schema:dump command
+        # First, check if we need to create the schema file
+        schema_file = File.join(active_project_path, "db", "schema.rb")
+        unless File.exist?(schema_file)
+          log(:info, "Schema file not found, attempting to generate it")
+          RailsMcpServer::RunProcess.execute_rails_command(active_project_path, "db:schema:dump")
+        end
+
+        if File.exist?(schema_file)
+          # Read the schema file
+          schema_content = File.read(schema_file)
+
+          # Try to get table list
+          tables_output = RailsMcpServer::RunProcess.execute_rails_command(
+            active_project_path,
+            "bin/rails runner \"require 'active_record'; puts ActiveRecord::Base.connection.tables.sort.join('\n')\""
+          )
+
+          tables = tables_output.strip.split("\n")
+
+          <<~SCHEMA
+            Database Schema
+
+            Tables:
+            #{tables.join("\n")}
+
+            Schema Definition:
+            ```ruby
+            #{schema_content}
+            ```
+          SCHEMA
+        else
+          # If we can't get the schema file, try to get the table list
+          tables_output = RailsMcpServer::RunProcess.execute_rails_command(
+            active_project_path,
+            "bin/rails runner \"require 'active_record'; puts ActiveRecord::Base.connection.tables.sort.join('\n')\""
+          )
+
+          if tables_output.strip.empty?
+            message = "Could not retrieve schema information. Try running 'rails db:schema:dump' in your project first."
+            log(:warn, message)
+
+            return message
+          end
+
+          tables = tables_output.strip.split("\n")
+
+          <<~SCHEMA
+            Database Schema
+
+            Tables:
+            #{tables.join("\n")}
+
+            Note: Full schema definition is not available. Run 'rails db:schema:dump' to generate the schema.rb file.
+          SCHEMA
+        end
+      end
+    end
+  end
+end

data/lib/rails-mcp-server/tools/list_files.rb

@@ -0,0 +1,54 @@
+module RailsMcpServer
+  class ListFiles < BaseTool
+    tool_name "list_files"
+
+    description "List files in the Rails project matching specific criteria. Use this to explore project directories or locate specific file types. If no parameters are provided, lists files in the project root."
+
+    arguments do
+      optional(:directory).filled(:string).description("Directory path relative to the project root (e.g., 'app/models', 'config'). Leave empty to list files at the root.")
+      optional(:pattern).filled(:string).description("File pattern using glob syntax (e.g., '*.rb' for Ruby files, '*.erb' for ERB templates, '*_controller.rb' for controllers)")
+    end
+
+    def call(directory: "", pattern: "*.rb")
+      unless current_project
+        message = "No active project. Please switch to a project first."
+        log(:warn, message)
+
+        return message
+      end
+
+      full_path = File.join(active_project_path, directory)
+      unless File.directory?(full_path)
+        message = "Directory '#{directory}' not found in the project."
+        log(:warn, message)
+
+        return message
+      end
+
+      # Check if this is a git repository
+      is_git_repo = system("cd #{active_project_path} && git rev-parse --is-inside-work-tree > /dev/null 2>&1")
+
+      if is_git_repo
+        log(:debug, "Project is a git repository, using git ls-files")
+
+        # Use git ls-files for tracked files
+        relative_dir = directory.empty? ? "" : "#{directory}/"
+        git_cmd = "cd #{active_project_path} && git ls-files --cached --others --exclude-standard #{relative_dir}#{pattern}"
+
+        files = `#{git_cmd}`.split("\n").map(&:strip).sort # rubocop:disable Performance/ChainArrayAllocation
+      else
+        log(:debug, "Project is not a git repository or git not available, using Dir.glob")
+
+        # Use Dir.glob as fallback
+        files = Dir.glob(File.join(full_path, pattern))
+          .map { |f| f.sub("#{active_project_path}/", "") }
+          .reject { |file| file.start_with?(".git/", ".ruby-lsp/", "node_modules/", "storage/", "public/assets/", "public/packs/", ".bundle/", "vendor/bundle/", "vendor/cache/", "tmp/", "log/") } # rubocop:disable Performance/ChainArrayAllocation
+          .sort # rubocop:disable Performance/ChainArrayAllocation
+      end
+
+      log(:debug, "Found #{files.size} files matching pattern (respecting .gitignore and ignoring node_modules)")
+
+      "Files in #{directory.empty? ? "project root" : directory} matching '#{pattern}':\n\n#{files.join("\n")}"
+    end
+  end
+end

data/lib/rails-mcp-server/tools/project_info.rb

@@ -0,0 +1,86 @@
+module RailsMcpServer
+  class ProjectInfo < BaseTool
+    tool_name "project_info"
+
+    description "Retrieve comprehensive information about the current Rails project, including Rails version, directory structure, API-only status, and overall project organization. Useful for initial project exploration and understanding the codebase structure."
+
+    def call
+      unless current_project
+        message = "No active project. Please switch to a project first."
+        log(:warn, message)
+
+        return message
+      end
+
+      # Get additional project information
+      gemfile_path = File.join(active_project_path, "Gemfile")
+      gemfile_content = File.exist?(gemfile_path) ? File.read(gemfile_path) : "Gemfile not found"
+
+      # Get Rails version
+      rails_version = gemfile_content.match(/gem ['"]rails['"],\s*['"](.+?)['"]/)&.captures&.first || "Unknown"
+
+      # Check if it's an API-only app
+      config_application_path = File.join(active_project_path, "config", "application.rb")
+      is_api_only = File.exist?(config_application_path) &&
+        File.read(config_application_path).include?("config.api_only = true")
+
+      log(:info, "Project info: Rails v#{rails_version}, API-only: #{is_api_only}")
+
+      <<~INFO
+        Current project: #{current_project}
+        Path: #{active_project_path}
+        Rails version: #{rails_version}
+        API only: #{is_api_only ? "Yes" : "No"}
+        
+        Project structure:
+        #{get_directory_structure(active_project_path, max_depth: 2)}
+      INFO
+    end
+
+    private
+
+    # Utility functions for Rails operations
+    def get_directory_structure(path, max_depth: 3, current_depth: 0, prefix: "")
+      return "" if current_depth > max_depth || !File.directory?(path)
+
+      # Define ignored directories
+      ignored_dirs = [
+        ".git", "node_modules", "tmp", "log",
+        "storage", "coverage", "public/assets",
+        "public/packs", ".bundle", "vendor/bundle",
+        "vendor/cache", ".ruby-lsp"
+      ]
+
+      output = ""
+      directories = []
+      files = []
+
+      Dir.foreach(path) do |entry|
+        next if entry == "." || entry == ".."
+        next if ignored_dirs.include?(entry) # Skip ignored directories
+
+        full_path = File.join(path, entry)
+
+        if File.directory?(full_path)
+          directories << entry
+        else
+          files << entry
+        end
+      end
+
+      directories.sort.each do |dir|
+        output << "#{prefix}└── #{dir}/\n"
+        full_path = File.join(path, dir)
+        output << get_directory_structure(full_path, max_depth: max_depth,
+          current_depth: current_depth + 1,
+          prefix: "#{prefix}    ")
+      end
+
+      files.sort.each do |file|
+        output << "#{prefix}└── #{file}\n"
+      end
+
+      output
+    end
+  end
+end

data/lib/rails-mcp-server/tools/switch_project.rb

@@ -0,0 +1,25 @@
+module RailsMcpServer
+  class SwitchProject < BaseTool
+    tool_name "switch_project"
+
+    description "Change the active Rails project to interact with a different codebase. Must be called before using other tools. Available projects are defined in the projects.yml configuration file."
+
+    arguments do
+      required(:project_name).filled(:string).description("Name of the project as defined in the projects.yml file (case-sensitive)")
+    end
+
+    def call(project_name:)
+      if projects.key?(project_name)
+        self.current_project = project_name
+        self.active_project_path = File.expand_path(projects[project_name])
+        log(:info, "Switched to project: #{project_name} at path: #{active_project_path}")
+
+        "Switched to project: #{project_name} at path: #{active_project_path}"
+      else
+        log(:warn, "Project not found: #{project_name}")
+
+        "Project '#{project_name}' not found. Available projects: #{projects.keys.join(", ")}"
+      end
+    end
+  end
+end

data/lib/rails-mcp-server/utilities/run_process.rb

@@ -0,0 +1,29 @@
+module RailsMcpServer
+  class RunProcess
+    def self.execute_rails_command(project_path, command)
+      subprocess_env = ENV.to_h.merge(Bundler.original_env).merge(
+        "BUNDLE_GEMFILE" => File.join(project_path, "Gemfile")
+      )
+
+      RailsMcpServer.log(:debug, "Executing: #{command}")
+
+      # Execute the command and capture stdout, stderr, and status
+      stdout_str, stderr_str, status = Open3.capture3(subprocess_env, command, chdir: project_path)
+
+      if status.success?
+        RailsMcpServer.log(:debug, "Command succeeded")
+        stdout_str
+      else
+        # Log error details
+        RailsMcpServer.log(:error, "Command failed with status: #{status.exitstatus}")
+        RailsMcpServer.log(:error, "stderr: #{stderr_str}")
+
+        # Return error message
+        "Error executing Rails command: #{command}\n\n#{stderr_str}"
+      end
+    rescue => e
+      RailsMcpServer.log(:error, "Exception executing Rails command: #{e.message}")
+      "Exception executing command: #{e.message}"
+    end
+  end
+end

data/lib/rails-mcp-server/version.rb

@@ -1,3 +1,3 @@
 module RailsMcpServer
-  VERSION = "1.0.1"
+  VERSION = "1.1.0"
 end