rails-mcp-server 1.2.3 → 1.4.0

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

@@ -0,0 +1,40 @@
+module RailsMcpServer
+  module Analyzers
+    class GetFile < BaseAnalyzer
+      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
+
+        if File.directory?(full_path)
+          message = "'#{path}' is a directory, not a file. Use list_files instead."
+          log(:warn, message)
+          return message
+        end
+
+        log(:info, "Reading file: #{path}")
+
+        content = File.read(full_path)
+        extension = File.extname(path).delete(".")
+
+        <<~FILE
+          File: #{path}
+
+          ```#{extension}
+          #{content}
+          ```
+        FILE
+      end
+    end
+  end
+end

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

@@ -0,0 +1,212 @@
+module RailsMcpServer
+  module Analyzers
+    class GetRoutes < BaseAnalyzer
+      def call(controller: nil, verb: nil, path_contains: nil, named_only: false, detail_level: "full")
+        unless current_project
+          message = "No active project. Please switch to a project first."
+          log(:warn, message)
+          return message
+        end
+
+        detail_level = "full" unless %w[names summary full].include?(detail_level)
+
+        routes_data = fetch_routes_via_introspection
+
+        if routes_data[:error]
+          log(:warn, "Error fetching routes: #{routes_data[:error]}")
+          return "Error fetching routes: #{routes_data[:error]}"
+        end
+
+        routes = routes_data[:routes] || []
+
+        routes = filter_routes(routes, controller: controller, verb: verb, path_contains: path_contains, named_only: named_only)
+
+        if routes.empty?
+          message = "No routes found"
+          message += " matching filters" if controller || verb || path_contains || named_only
+          return message
+        end
+
+        log(:debug, "Found #{routes.size} matching routes")
+
+        format_routes(routes, detail_level)
+      end
+
+      private
+
+      def fetch_routes_via_introspection
+        script = <<~RUBY
+          require 'json'
+          
+          def extract_constraints(route)
+            constraints = {}
+            
+            if route.constraints.is_a?(Hash)
+              route.constraints.each do |key, value|
+                constraints[key.to_s] = value.is_a?(Regexp) ? value.source : value.to_s
+              end
+            end
+            
+            if route.respond_to?(:requirements)
+              route.requirements.each do |key, value|
+                next if [:controller, :action].include?(key)
+                constraints[key.to_s] = value.is_a?(Regexp) ? value.source : value.to_s
+              end
+            end
+            
+            constraints
+          end
+          
+          begin
+            Rails.application.eager_load! unless Rails.application.config.eager_load
+            
+            routes = Rails.application.routes.routes.map do |route|
+              next if route.internal
+              
+              path = route.path.spec.to_s
+              next if path == '(.):format'
+              
+              path = path.gsub('(.:format)', '').gsub('(:format)', '')
+              
+              verb = route.verb.to_s
+              verb = verb.empty? ? 'ANY' : verb
+              verb = verb.gsub(/[\\^$\\/]/, '') if verb.include?('^')
+              
+              controller = route.defaults[:controller].to_s
+              action = route.defaults[:action].to_s
+              
+              next if controller.empty?
+              
+              {
+                name: route.name.to_s,
+                verb: verb,
+                path: path,
+                controller: controller,
+                action: action,
+                controller_action: controller.empty? ? '' : "\#{controller}#\#{action}",
+                constraints: extract_constraints(route),
+                defaults: route.defaults.except(:controller, :action).transform_keys(&:to_s),
+                required_parts: route.required_parts.map(&:to_s),
+                optional_parts: route.parts.map(&:to_s) - route.required_parts.map(&:to_s)
+              }
+            end.compact
+            
+            by_controller = routes.group_by { |r| r[:controller] }
+            
+            puts({
+              routes: routes,
+              total_count: routes.size,
+              controllers: by_controller.transform_values(&:size)
+            }.to_json)
+            
+          rescue => e
+            puts({ error: e.message, backtrace: e.backtrace.first(5) }.to_json)
+          end
+        RUBY
+
+        json_output = execute_rails_runner(script)
+
+        begin
+          JSON.parse(json_output, symbolize_names: true)
+        rescue JSON::ParserError => e
+          {error: "Failed to parse routes: #{e.message}", raw: json_output}
+        end
+      end
+
+      def filter_routes(routes, controller:, verb:, path_contains:, named_only:)
+        filtered = routes
+
+        if controller && !controller.empty?
+          controller_pattern = controller.downcase
+          filtered = filtered.select do |r|
+            r[:controller].to_s.downcase.include?(controller_pattern)
+          end
+        end
+
+        if verb && !verb.empty?
+          verb_upper = verb.upcase
+          filtered = filtered.select do |r|
+            r[:verb].to_s.upcase.include?(verb_upper)
+          end
+        end
+
+        if path_contains && !path_contains.empty?
+          filtered = filtered.select do |r|
+            r[:path].to_s.include?(path_contains)
+          end
+        end
+
+        if named_only
+          filtered = filtered.select do |r|
+            r[:name] && !r[:name].empty?
+          end
+        end
+
+        filtered
+      end
+
+      def format_routes(routes, detail_level)
+        case detail_level
+        when "names"
+          paths = routes.map { |r| r[:path] }.uniq.sort # rubocop:disable Performance/ChainArrayAllocation
+          "Route paths (#{paths.size} unique):\n\n#{paths.join("\n")}"
+
+        when "summary"
+          output = +"Rails Routes (#{routes.size} routes):\n"
+
+          by_controller = routes.group_by { |r| r[:controller] }
+
+          by_controller.sort.each do |controller, controller_routes|
+            output << "#{controller}:\n"
+            controller_routes.each do |r|
+              verb_padded = r[:verb].to_s.ljust(7)
+              name_str = r[:name].to_s.empty? ? "" : " (#{r[:name]})"
+              output << "  #{verb_padded} #{r[:path].ljust(40)} #{r[:action]}#{name_str}\n"
+            end
+            output << "\n"
+          end
+
+          output
+
+        when "full"
+          output = +"Rails Routes (#{routes.size} routes):\n"
+          output << "=" * 70 << "\n"
+
+          routes.each do |r|
+            output << "\n"
+            output << "#{r[:verb]} #{r[:path]}\n"
+            output << "  Name: #{r[:name]}\n" unless r[:name].to_s.empty?
+            output << "  Controller: #{r[:controller_action]}\n"
+
+            if r[:constraints]&.any?
+              output << "  Constraints: #{r[:constraints].map { |k, v| "#{k}: #{v}" }.join(", ")}\n"
+            end
+
+            if r[:defaults]&.any?
+              output << "  Defaults: #{r[:defaults].map { |k, v| "#{k}: #{v}" }.join(", ")}\n"
+            end
+
+            if r[:required_parts]&.any?
+              output << "  Required params: #{r[:required_parts].join(", ")}\n"
+            end
+
+            if r[:optional_parts]&.any?
+              output << "  Optional params: #{r[:optional_parts].join(", ")}\n"
+            end
+          end
+
+          output << "\n"
+          output << "=" * 70 << "\n"
+          output << "Summary by controller:\n"
+
+          by_controller = routes.group_by { |r| r[:controller] }
+          by_controller.sort.each do |controller, controller_routes|
+            output << "  #{controller}: #{controller_routes.size} routes\n"
+          end
+
+          output
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,216 @@
+module RailsMcpServer
+  module Analyzers
+    class GetSchema < BaseAnalyzer
+      def call(table_name: nil, table_names: nil, detail_level: "full")
+        unless current_project
+          message = "No active project. Please switch to a project first."
+          log(:warn, message)
+          return message
+        end
+
+        detail_level = "full" unless %w[tables summary full].include?(detail_level)
+
+        if table_names && table_names.is_a?(Array) && table_names.any?
+          return batch_table_info(table_names)
+        end
+
+        if table_name
+          log(:info, "Getting schema for table: #{table_name}")
+          return single_table_info(table_name)
+        end
+
+        case detail_level
+        when "tables"
+          tables_list_only
+        when "summary"
+          tables_with_summary
+        when "full"
+          full_schema
+        end
+      end
+
+      private
+
+      def tables_list_only
+        tables = get_table_names
+        return "Could not retrieve table list." if tables.empty?
+
+        "Database tables (#{tables.size}):\n\n#{tables.join("\n")}"
+      end
+
+      def tables_with_summary
+        tables = get_table_names
+        return "Could not retrieve table list." if tables.empty?
+
+        output = ["Database schema summary (#{tables.size} tables):\n"]
+
+        tables.each do |table|
+          column_count = get_column_count(table)
+          output << "  #{table} (#{column_count} columns)"
+        end
+
+        output.join("\n")
+      end
+
+      def full_schema
+        log(:info, "Getting full schema")
+
+        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)
+          schema_content = File.read(schema_file)
+          tables = get_table_names
+
+          <<~SCHEMA
+            Database Schema (#{tables.size} tables)
+
+            Tables:
+            #{tables.join("\n")}
+
+            Schema Definition:
+            ```ruby
+            #{schema_content}
+            ```
+          SCHEMA
+        else
+          tables = get_table_names
+          if tables.empty?
+            "Could not retrieve schema information. Try running 'rails db:schema:dump' in your project first."
+          else
+            <<~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
+
+      def single_table_info(table_name)
+        schema_output = execute_rails_runner(<<~RUBY)
+          require 'active_record'
+          puts ActiveRecord::Base.connection.columns('#{table_name}').map{|c| [c.name, c.type, c.null, c.default].inspect}.join('\\n')
+        RUBY
+
+        if schema_output.strip.empty?
+          message = "Table '#{table_name}' not found or has no columns."
+          log(:warn, message)
+          return message
+        end
+
+        columns = schema_output.strip.split("\\n").map do |column_info|
+          eval(column_info) # rubocop:disable Security/Eval
+        end
+
+        formatted_columns = columns.map do |name, type, nullable, default|
+          "  #{name} (#{type})#{nullable ? ", nullable" : ""}#{default ? ", default: #{default}" : ""}"
+        end
+
+        output = <<~SCHEMA
+          Table: #{table_name} (#{columns.size} columns)
+
+          Columns:
+          #{formatted_columns.join("\n")}
+        SCHEMA
+
+        fk_output = get_foreign_keys(table_name)
+        output += fk_output if fk_output
+
+        idx_output = get_indexes(table_name)
+        output += idx_output if idx_output
+
+        output
+      end
+
+      def batch_table_info(table_names)
+        output = ["Schema for #{table_names.size} tables:\n"]
+
+        table_names.each do |table|
+          output << "=" * 50
+          output << single_table_info(table)
+          output << ""
+        end
+
+        output.join("\n")
+      end
+
+      def get_table_names
+        tables_output = execute_rails_runner(<<~RUBY)
+          require 'active_record'
+          puts ActiveRecord::Base.connection.tables.sort.join('\\n')
+        RUBY
+        tables_output.strip.split("\n").reject(&:empty?)
+      end
+
+      def get_column_count(table_name)
+        count_output = execute_rails_runner(<<~RUBY)
+          require 'active_record'
+          puts ActiveRecord::Base.connection.columns('#{table_name}').size
+        RUBY
+        count_output.strip.to_i
+      rescue
+        "?"
+      end
+
+      def get_foreign_keys(table_name)
+        fk_output = execute_rails_runner(<<~RUBY)
+          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')
+        RUBY
+
+        return nil if fk_output.strip.empty?
+
+        foreign_keys = fk_output.strip.split("\n").map do |fk_info|
+          eval(fk_info) # rubocop:disable Security/Eval
+        end
+
+        formatted_fks = foreign_keys.map do |from_table, to_table, column, primary_key|
+          "  #{column} -> #{to_table}.#{primary_key}"
+        end
+
+        <<~FK
+
+          Foreign Keys:
+          #{formatted_fks.join("\n")}
+        FK
+      rescue => e
+        log(:warn, "Error fetching foreign keys: #{e.message}")
+        nil
+      end
+
+      def get_indexes(table_name)
+        idx_output = execute_rails_runner(<<~RUBY)
+          require 'active_record'
+          puts ActiveRecord::Base.connection.indexes('#{table_name}').map{|i| [i.name, i.columns, i.unique].inspect}.join('\\n')
+        RUBY
+
+        return nil if idx_output.strip.empty?
+
+        indexes = idx_output.strip.split("\n").map do |idx_info|
+          eval(idx_info) # rubocop:disable Security/Eval
+        end
+
+        formatted_indexes = indexes.map do |name, columns, unique|
+          cols = columns.is_a?(Array) ? columns.join(", ") : columns
+          "  #{name} (#{cols})#{unique ? " UNIQUE" : ""}"
+        end
+
+        <<~IDX
+
+          Indexes:
+          #{formatted_indexes.join("\n")}
+        IDX
+      rescue => e
+        log(:warn, "Error fetching indexes: #{e.message}")
+        nil
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+module RailsMcpServer
+  module Analyzers
+    class ListFiles < BaseAnalyzer
+      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")
+
+          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
+        else
+          log(:debug, "Project is not a git repository or git not available, using Dir.glob")
+
+          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/") }
+            .sort
+        end
+
+        log(:debug, "Found #{files.size} files matching pattern")
+
+        "Files in #{directory.empty? ? "project root" : directory} matching '#{pattern}':\n\n#{files.join("\n")}"
+      end
+    end
+  end
+end

data/lib/rails-mcp-server/analyzers/load_guide.rb

@@ -0,0 +1,84 @@
+module RailsMcpServer
+  module Analyzers
+    class LoadGuide < BaseAnalyzer
+      GUIDE_LIBRARIES = %w[rails turbo stimulus kamal custom].freeze
+
+      def call(guides:, guide: nil)
+        unless GUIDE_LIBRARIES.include?(guides.to_s.downcase)
+          return "Unknown guide library '#{guides}'. Available: #{GUIDE_LIBRARIES.join(", ")}"
+        end
+
+        guides_path = get_guides_path(guides.to_s.downcase)
+
+        unless guides_path && File.directory?(guides_path)
+          return "Guides for '#{guides}' not found. Run: rails-mcp-server-download-resources"
+        end
+
+        if guide
+          load_specific_guide(guides_path, guide)
+        else
+          list_available_guides(guides, guides_path)
+        end
+      end
+
+      private
+
+      def get_guides_path(library)
+        base_path = File.join(RailsMcpServer.config_dir, "resources", library)
+        File.directory?(base_path) ? base_path : nil
+      end
+
+      def list_available_guides(library, guides_path)
+        guide_files = Dir.glob(File.join(guides_path, "**", "*.md"))
+          .map { |f| f.sub("#{guides_path}/", "").sub(/\.md$/, "") }
+          .sort # rubocop:disable Performance/ChainArrayAllocation
+
+        if guide_files.empty?
+          return "No guides found for '#{library}'."
+        end
+
+        output = ["Available #{library.capitalize} Guides (#{guide_files.size}):", ""]
+        guide_files.each { |g| output << "  #{g}" }
+        output << ""
+        output << "Load a guide with: load_guide(guides: '#{library}', guide: '<guide_name>')"
+        output.join("\n")
+      end
+
+      def load_specific_guide(guides_path, guide_name)
+        # Try exact match first
+        guide_file = File.join(guides_path, "#{guide_name}.md")
+
+        # Try finding in subdirectories
+        unless File.exist?(guide_file)
+          matches = Dir.glob(File.join(guides_path, "**", "#{guide_name}.md"))
+          guide_file = matches.first if matches.any?
+        end
+
+        # Try partial match
+        unless guide_file && File.exist?(guide_file)
+          all_guides = Dir.glob(File.join(guides_path, "**", "*.md"))
+          matches = all_guides.select { |f| File.basename(f, ".md").include?(guide_name) }
+          guide_file = matches.first if matches.size == 1
+
+          if matches.size > 1
+            names = matches.map { |f| File.basename(f, ".md") }
+            return "Multiple guides match '#{guide_name}': #{names.join(", ")}"
+          end
+        end
+
+        unless guide_file && File.exist?(guide_file)
+          return "Guide '#{guide_name}' not found."
+        end
+
+        content = File.read(guide_file)
+        guide_title = File.basename(guide_file, ".md")
+
+        <<~GUIDE
+          # #{guide_title}
+
+          #{content}
+        GUIDE
+      end
+    end
+  end
+end