rails-mcp-server 1.2.3 → 1.4.0

data/exe/rails-mcp-server

@@ -72,17 +72,30 @@ end
 RailsMcpServer.config.log_level = log_level
 RailsMcpServer.log(:info, "Starting Rails MCP Server in #{mode} mode...")
 
-# Create tools configuration for both modes
+# Register only bootstrap tools - other tools are invoked via execute_tool
+# This reduces context token usage by not loading all tool definitions upfront
+#
+# Workflow:
+#   1. switch_project  - Select a Rails project to work with
+#   2. search_tools    - Discover available tools and their parameters
+#   3. execute_tool    - Invoke internal tools by name
+#   4. execute_ruby    - Run custom Ruby code for complex queries
+#
 def setup_mcp_tools(server)
-  server.register_tools(RailsMcpServer::SwitchProject, RailsMcpServer::ProjectInfo,
-    RailsMcpServer::ListFiles, RailsMcpServer::GetFile, RailsMcpServer::GetRoutes, RailsMcpServer::AnalyzeModels,
-    RailsMcpServer::GetSchema, RailsMcpServer::AnalyzeControllerViews, RailsMcpServer::AnalyzeEnvironmentConfig,
-    RailsMcpServer::LoadGuide)
-
-  server.register_resources(RailsMcpServer::RailsGuidesResource, RailsMcpServer::RailsGuidesResources,
-    RailsMcpServer::StimulusGuidesResource, RailsMcpServer::StimulusGuidesResources, RailsMcpServer::TurboGuidesResource,
-    RailsMcpServer::TurboGuidesResources, RailsMcpServer::CustomGuidesResource, RailsMcpServer::CustomGuidesResources,
-    RailsMcpServer::KamalGuidesResource, RailsMcpServer::KamalGuidesResources)
+  server.register_tools(
+    RailsMcpServer::SwitchProject,
+    RailsMcpServer::SearchTools,
+    RailsMcpServer::ExecuteTool,
+    RailsMcpServer::ExecuteRuby
+  )
+
+  server.register_resources(
+    RailsMcpServer::RailsGuidesResource, RailsMcpServer::RailsGuidesResources,
+    RailsMcpServer::StimulusGuidesResource, RailsMcpServer::StimulusGuidesResources,
+    RailsMcpServer::TurboGuidesResource, RailsMcpServer::TurboGuidesResources,
+    RailsMcpServer::CustomGuidesResource, RailsMcpServer::CustomGuidesResources,
+    RailsMcpServer::KamalGuidesResource, RailsMcpServer::KamalGuidesResources
+  )
 end
 
 case mode

data/exe/rails-mcp-setup-claude

@@ -100,7 +100,7 @@ FileUtils.mkdir_p(claude_config_dir)
 server_path = File.join(project_dir, "exe", "rails-mcp-server")
 
 # Ensure the server is executable
-FileUtils.chmod("+x", server_path)
+FileUtils.chmod("+x", server_path) unless File.stat(server_path).executable?
 puts "✓".green + " Made server executable"
 
 # Create or update the Claude Desktop config file

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

@@ -0,0 +1,253 @@
+module RailsMcpServer
+  module Analyzers
+    class AnalyzeControllerViews < BaseAnalyzer
+      def call(controller_name: nil, detail_level: "full", analysis_type: "introspection")
+        unless current_project
+          return "No active project. Please switch to a project first."
+        end
+
+        detail_level = "full" unless %w[names summary full].include?(detail_level)
+        analysis_type = "introspection" unless %w[introspection static full].include?(analysis_type)
+
+        controllers_dir = File.join(active_project_path, "app", "controllers")
+        return "Controllers directory not found." unless File.directory?(controllers_dir)
+
+        controller_files = Dir.glob(File.join(controllers_dir, "**", "*_controller.rb"))
+          .reject { |f| f.include?("application_controller") }
+
+        return "No controllers found." if controller_files.empty?
+
+        if controller_name
+          normalized = normalize_controller_name(controller_name)
+          controller_files = controller_files.select { |f| File.basename(f).downcase == "#{normalized}_controller.rb" }
+          return "Controller '#{controller_name}' not found." if controller_files.empty?
+        end
+
+        analyze_controllers(controller_files, detail_level, analysis_type)
+      end
+
+      private
+
+      def normalize_controller_name(name)
+        name.sub(/_?controller$/i, "").downcase
+      end
+
+      def analyze_controllers(controller_files, detail_level, analysis_type)
+        output = []
+        controller_files.each do |file_path|
+          controller_class = derive_controller_class(file_path)
+          relative_path = file_path.sub(active_project_path + "/", "")
+
+          case detail_level
+          when "names"
+            actions = get_actions_via_introspection(controller_class)
+            output << "#{controller_class} (#{actions.size} actions)"
+            output << "  Actions: #{actions.join(", ")}" << ""
+          when "summary"
+            output << format_summary(controller_class, file_path, relative_path)
+          else
+            output << format_full_analysis(controller_class, file_path, relative_path, analysis_type)
+          end
+        end
+        output.join("\n")
+      end
+
+      def get_actions_via_introspection(controller_class)
+        script = "require 'json'; puts (#{controller_class}.action_methods.to_a.sort rescue []).to_json"
+        begin
+          JSON.parse(execute_rails_runner(script))
+        rescue
+          []
+        end
+      end
+
+      def format_summary(controller_class, file_path, relative_path)
+        data = get_controller_summary(controller_class)
+        output = ["#{controller_class}", "  File: #{relative_path}", "  Actions: #{data[:actions].size}"]
+        data[:actions].each do |action|
+          route = data[:routes].find { |r| r[:action] == action }
+          output << if route
+            "    #{action}: [#{route[:verb].empty? ? "ANY" : route[:verb]}] #{route[:path]}"
+          else
+            "    #{action}: (no route)"
+          end
+        end
+        output << ""
+        output.join("\n")
+      end
+
+      def get_controller_summary(controller_class)
+        script = <<~RUBY
+          require 'json'
+          begin
+            c = #{controller_class}
+            actions = c.action_methods.to_a.sort
+            routes = Rails.application.routes.routes.select { |r| r.defaults[:controller] == '#{controller_class.sub("Controller", "").underscore}' }
+              .map { |r| { verb: r.verb.to_s.gsub(/[\\^$\\/]/, ''), path: r.path.spec.to_s.gsub('(.:format)', ''), action: r.defaults[:action].to_s } }
+            puts({ actions: actions, routes: routes }.to_json)
+          rescue => e
+            puts({ actions: [], routes: [], error: e.message }.to_json)
+          end
+        RUBY
+        begin
+          JSON.parse(execute_rails_runner(script), symbolize_names: true)
+        rescue
+          {actions: [], routes: []}
+        end
+      end
+
+      def format_full_analysis(controller_class, file_path, relative_path, analysis_type)
+        output = ["=" * 70, "Controller: #{controller_class}", "File: #{relative_path}", "=" * 70]
+
+        if %w[introspection full].include?(analysis_type)
+          output << "" << introspection_analysis(controller_class)
+        end
+
+        if %w[static full].include?(analysis_type)
+          output << "" << static_analysis(file_path)
+        end
+
+        output << "" << view_analysis(file_path)
+        output.join("\n")
+      end
+
+      def introspection_analysis(controller_class)
+        script = <<~RUBY
+          require 'json'
+          begin
+            c = #{controller_class}
+            result = {
+              actions: c.action_methods.to_a.sort,
+              parent: c.superclass.name,
+              callbacks: c._process_action_callbacks.map { |cb| { kind: cb.kind.to_s, filter: cb.filter.to_s, only: Array(cb.options[:only]).map(&:to_s), except: Array(cb.options[:except]).map(&:to_s) } },
+              routes: Rails.application.routes.routes.select { |r| r.defaults[:controller] == '#{controller_class.sub("Controller", "").underscore}' }
+                .map { |r| { name: r.name.to_s, verb: r.verb.to_s.gsub(/[\\^$\\/]/, ''), path: r.path.spec.to_s.gsub('(.:format)', ''), action: r.defaults[:action].to_s } }
+            }
+            puts result.to_json
+          rescue => e
+            puts({ error: e.message }.to_json)
+          end
+        RUBY
+        data = begin
+          JSON.parse(execute_rails_runner(script), symbolize_names: true)
+        rescue
+          nil
+        end
+        return "Introspection Error" unless data
+        return "Error: #{data[:error]}" if data[:error]
+        format_introspection_result(data)
+      end
+
+      def format_introspection_result(data)
+        output = ["RAILS INTROSPECTION:", "-" * 40, "Parent: #{data[:parent]}", "", "Actions (#{data[:actions].size}):"]
+        data[:actions].each { |a| output << "  #{a}" }
+
+        if data[:callbacks]&.any?
+          output << "" << "Callbacks:"
+          data[:callbacks].each do |cb|
+            opts = []
+            opts << "only: [#{cb[:only].join(", ")}]" if cb[:only]&.any?
+            opts << "except: [#{cb[:except].join(", ")}]" if cb[:except]&.any?
+            output << "  #{cb[:kind]}_action :#{cb[:filter]}#{opts.any? ? ", #{opts.join(", ")}" : ""}"
+          end
+        end
+
+        if data[:routes]&.any?
+          output << "" << "Routes (#{data[:routes].size}):"
+          data[:routes].each do |r|
+            verb = r[:verb].empty? ? "ANY" : r[:verb]
+            output << "  #{verb.ljust(7)} #{r[:path].ljust(35)} -> #{r[:action]}"
+          end
+        end
+
+        output.join("\n")
+      end
+
+      def static_analysis(file_path)
+        script = <<~RUBY
+          require 'json'
+          begin
+            require 'prism'
+            source = File.read('#{file_path}')
+            result = Prism.parse(source)
+            before_actions, strong_params, instance_vars = [], [], {}
+            
+            visit = ->(node, ctx = {}) {
+              case node
+              when Prism::CallNode
+                name = node.name.to_s
+                args = node.arguments&.arguments&.map { |a| a.is_a?(Prism::SymbolNode) ? a.value.to_s : nil }&.compact || []
+                before_actions << { method: args.first, name: name } if %w[before_action after_action skip_before_action].include?(name)
+                strong_params << args if name == 'permit'
+              when Prism::DefNode
+                mname = node.name.to_s
+                instance_vars[mname] = []
+                node.child_nodes.compact.each { |c| visit.call(c, { method: mname }) }
+                return
+              when Prism::InstanceVariableWriteNode
+                instance_vars[ctx[:method]] << node.name.to_s if ctx[:method]
+              end
+              node.child_nodes.compact.each { |c| visit.call(c, ctx) }
+            }
+            result.value.statements.body.each { |n| visit.call(n) }
+            puts({ before_actions: before_actions, strong_params: strong_params, instance_vars: instance_vars }.to_json)
+          rescue LoadError
+            puts({ error: "Prism not available" }.to_json)
+          rescue => e
+            puts({ error: e.message }.to_json)
+          end
+        RUBY
+        data = begin
+          JSON.parse(execute_rails_runner(script), symbolize_names: true)
+        rescue
+          nil
+        end
+        return "Static Analysis Error" unless data
+        return "Error: #{data[:error]}" if data[:error]
+        format_static_result(data)
+      end
+
+      def format_static_result(data)
+        output = ["PRISM STATIC ANALYSIS:", "-" * 40]
+        if data[:before_actions]&.any?
+          output << "Filters:"
+          data[:before_actions].each { |ba| output << "  #{ba[:name]} :#{ba[:method]}" }
+        end
+        if data[:strong_params]&.any?
+          output << "Strong Parameters:"
+          data[:strong_params].each { |sp| output << "  permit(#{sp.join(", ")})" }
+        end
+        if data[:instance_vars]&.any?
+          output << "Instance Variables by Action:"
+          data[:instance_vars].each { |action, vars| output << "  #{action}: #{vars.uniq.join(", ")}" if vars.any? }
+        end
+        output.join("\n")
+      end
+
+      def view_analysis(file_path)
+        controller_name = File.basename(file_path, "_controller.rb")
+        views_dir = File.join(active_project_path, "app", "views", controller_name)
+        output = ["VIEW TEMPLATES:", "-" * 40]
+
+        unless File.directory?(views_dir)
+          output << "  No views directory found"
+          return output.join("\n")
+        end
+
+        view_files = Dir.glob(File.join(views_dir, "*")).reject { |f| File.directory?(f) }
+        if view_files.empty?
+          output << "  No view templates found"
+        else
+          by_action = view_files.group_by { |f| File.basename(f).split(".").first }
+          by_action.sort.each { |action, files| output << "  #{action}: #{files.map { |f| File.basename(f) }.join(", ")}" }
+        end
+        output.join("\n")
+      end
+
+      def derive_controller_class(file_path)
+        relative = file_path.sub(File.join(active_project_path, "app", "controllers") + "/", "").sub(/_controller\.rb$/, "")
+        relative.split("/").map { |part| camelize(part) }.join("::") + "Controller"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+module RailsMcpServer
+  module Analyzers
+    class AnalyzeEnvironmentConfig < BaseAnalyzer
+      def call
+        unless current_project
+          return "No active project. Please switch to a project first."
+        end
+
+        environments_dir = File.join(active_project_path, "config", "environments")
+        unless File.directory?(environments_dir)
+          return "Environments directory not found at config/environments."
+        end
+
+        env_files = Dir.glob(File.join(environments_dir, "*.rb"))
+        return "No environment files found." if env_files.empty?
+
+        analyze_environments(env_files)
+      end
+
+      private
+
+      def analyze_environments(env_files)
+        configs = {}
+
+        env_files.each do |file|
+          env_name = File.basename(file, ".rb")
+          content = File.read(file)
+          configs[env_name] = extract_config_settings(content)
+        end
+
+        output = ["Environment Configuration Analysis", "=" * 50, ""]
+
+        # List each environment's settings
+        configs.each do |env, settings|
+          output << "#{env.capitalize}:"
+          settings.each do |key, value|
+            output << "  #{key} = #{value}"
+          end
+          output << ""
+        end
+
+        # Find inconsistencies
+        all_keys = configs.values.flat_map(&:keys).uniq.sort
+        inconsistencies = []
+
+        all_keys.each do |key|
+          values_by_env = configs.map { |env, settings| [env, settings[key]] }.to_h
+          present_in = values_by_env.select { |_, v| !v.nil? }.keys
+
+          if present_in.size < configs.size && present_in.size > 0
+            missing = configs.keys - present_in
+            inconsistencies << "#{key}: missing in #{missing.join(", ")}"
+          end
+        end
+
+        if inconsistencies.any?
+          output << "Potential Issues:"
+          output << "-" * 30
+          inconsistencies.each { |i| output << "  ⚠ #{i}" }
+        else
+          output << "No inconsistencies found between environments."
+        end
+
+        output.join("\n")
+      end
+
+      def extract_config_settings(content)
+        settings = {}
+
+        # Match config.setting = value patterns
+        content.scan(/config\.(\w+(?:\.\w+)*)\s*=\s*(.+?)(?:\n|$)/).each do |key, value|
+          settings[key] = value.strip
+        end
+
+        settings
+      end
+    end
+  end
+end

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

@@ -0,0 +1,251 @@
+module RailsMcpServer
+  module Analyzers
+    class AnalyzeModels < BaseAnalyzer
+      def call(model_name: nil, model_names: nil, detail_level: "full", analysis_type: "introspection")
+        unless current_project
+          return "No active project. Please switch to a project first."
+        end
+
+        detail_level = "full" unless %w[names associations full].include?(detail_level)
+        analysis_type = "introspection" unless %w[introspection static full].include?(analysis_type)
+
+        if model_names && model_names.is_a?(Array) && model_names.any?
+          return batch_model_info(model_names, detail_level, analysis_type)
+        end
+
+        if model_name
+          return single_model_info(model_name, detail_level, analysis_type)
+        end
+
+        list_all_models(detail_level)
+      end
+
+      private
+
+      def list_all_models(detail_level)
+        models_dir = File.join(active_project_path, "app", "models")
+        return "Models directory not found." unless File.directory?(models_dir)
+
+        model_files = Dir.glob(File.join(models_dir, "**", "*.rb"))
+          .map { |f| f.sub("#{models_dir}/", "").sub(/\.rb$/, "") }
+          .reject { |f| f.include?("concern") || f.include?("application_record") }
+          .sort
+
+        case detail_level
+        when "names"
+          "Models in project (#{model_files.size}):\n\n#{model_files.join("\n")}"
+        when "associations"
+          output = ["Models with associations (#{model_files.size} models):\n"]
+          model_files.each do |model_file|
+            model_name = classify_model_name(model_file)
+            associations = get_associations_via_introspection(model_name)
+            if associations&.any?
+              output << "  #{model_name}:"
+              associations.each { |a| output << "    #{a[:type]} :#{a[:name]}" }
+            else
+              output << "  #{model_name}: (no associations)"
+            end
+          end
+          output.join("\n")
+        else
+          "Models in the project (#{model_files.size}):\n\n#{model_files.join("\n")}\n\nUse model_name parameter for details."
+        end
+      end
+
+      def single_model_info(model_name, detail_level, analysis_type)
+        model_file = find_model_file(model_name)
+        return "Model '#{model_name}' not found." unless model_file && File.exist?(model_file)
+
+        case detail_level
+        when "names"
+          "Model: #{model_name}\nFile: #{model_file.sub(active_project_path + "/", "")}"
+        when "associations"
+          format_associations_only(model_name, model_file)
+        else
+          build_full_analysis(model_name, model_file, analysis_type)
+        end
+      end
+
+      def format_associations_only(model_name, model_file)
+        associations = get_associations_via_introspection(model_name)
+        output = ["Model: #{model_name}", "File: #{model_file.sub(active_project_path + "/", "")}", "", "Associations:"]
+        if associations&.any?
+          associations.each { |a| output << "  #{a[:type]} :#{a[:name]}" }
+        else
+          output << "  None found"
+        end
+        output.join("\n")
+      end
+
+      def build_full_analysis(model_name, model_file, analysis_type)
+        output = ["=" * 60, "Model: #{model_name}", "File: #{model_file.sub(active_project_path + "/", "")}", "=" * 60]
+
+        if %w[introspection full].include?(analysis_type)
+          output << "" << introspection_analysis(model_name)
+        end
+
+        if %w[static full].include?(analysis_type)
+          output << "" << static_analysis(model_file)
+        end
+
+        output << "" << "Source Code:" << "```ruby" << File.read(model_file) << "```"
+        output.join("\n")
+      end
+
+      def introspection_analysis(model_name)
+        script = build_introspection_script(model_name)
+        json_output = execute_rails_runner(script)
+        data = begin
+          JSON.parse(json_output)
+        rescue
+          nil
+        end
+        return "Introspection Error: Could not parse output" unless data
+        format_introspection_result(data)
+      end
+
+      def build_introspection_script(model_name)
+        <<~RUBY
+          require 'json'
+          begin
+            model = #{model_name}
+            result = {}
+            if model.respond_to?(:table_name) && model.table_exists?
+              result[:table_name] = model.table_name
+              result[:primary_key] = model.primary_key
+              result[:columns] = model.columns.map { |c| { name: c.name, type: c.type.to_s, null: c.null, default: c.default } }
+              result[:associations] = model.reflect_on_all_associations.map { |a| { name: a.name.to_s, type: a.macro.to_s, class_name: a.class_name, options: a.options.transform_keys(&:to_s) } }
+              result[:validations] = model.validators.map { |v| { type: v.class.name.demodulize.underscore.sub('_validator', ''), attributes: v.attributes.map(&:to_s) } }
+              result[:enums] = model.defined_enums.transform_values { |v| v.keys } if model.respond_to?(:defined_enums)
+            else
+              result[:error] = "Not an ActiveRecord model or table doesn't exist"
+            end
+            puts result.to_json
+          rescue => e
+            puts({ error: e.message }.to_json)
+          end
+        RUBY
+      end
+
+      def format_introspection_result(data)
+        return "Introspection Error: #{data["error"]}" if data["error"]
+        output = ["RAILS INTROSPECTION:", "-" * 40]
+        output << "Table: #{data["table_name"]} (PK: #{data["primary_key"]})" << ""
+
+        if data["columns"]&.any?
+          output << "Columns (#{data["columns"].size}):"
+          data["columns"].each { |c| output << "  #{c["name"]}: #{c["type"]} #{c["null"] ? "NULL" : "NOT NULL"}" }
+          output << ""
+        end
+
+        if data["associations"]&.any?
+          output << "Associations (#{data["associations"].size}):"
+          data["associations"].each { |a| output << "  #{a["type"]} :#{a["name"]} -> #{a["class_name"]}" }
+          output << ""
+        end
+
+        if data["validations"]&.any?
+          output << "Validations:"
+          grouped = data["validations"].group_by { |v| v["attributes"].join(", ") }
+          grouped.each { |attrs, vals| output << "  #{attrs}: #{vals.map { |v| v["type"] }.join(", ")}" }
+          output << ""
+        end
+
+        if data["enums"]&.any?
+          output << "Enums:"
+          data["enums"].each { |name, values| output << "  #{name}: #{values.join(", ")}" }
+        end
+
+        output.join("\n")
+      end
+
+      def static_analysis(model_file)
+        script = build_static_analysis_script(model_file)
+        json_output = execute_rails_runner(script)
+        data = begin
+          JSON.parse(json_output)
+        rescue
+          nil
+        end
+        return "Static Analysis Error: Could not parse output" unless data
+        return "Static Analysis Error: #{data["error"]}" if data["error"]
+        format_static_result(data)
+      end
+
+      def build_static_analysis_script(model_file)
+        <<~RUBY
+          require 'json'
+          begin
+            require 'prism'
+            source = File.read('#{model_file}')
+            result = Prism.parse(source)
+            callbacks, scopes, concerns, methods = [], [], [], []
+            
+            visit = ->(node) {
+              case node
+              when Prism::CallNode
+                name = node.name.to_s
+                args = node.arguments&.arguments&.map { |a| a.is_a?(Prism::SymbolNode) ? a.value.to_s : nil }&.compact || []
+                if %w[before_save after_save before_create after_create before_update after_update before_destroy after_destroy after_commit before_validation after_validation].include?(name)
+                  callbacks << { name: name, args: args }
+                elsif name == 'scope'
+                  scopes << args.first
+                elsif %w[include extend].include?(name)
+                  concerns.concat(args)
+                end
+              when Prism::DefNode
+                methods << { name: node.name.to_s, line: node.location.start_line }
+              end
+              node.child_nodes.compact.each { |c| visit.call(c) }
+            }
+            result.value.statements.body.each { |n| visit.call(n) }
+            puts({ callbacks: callbacks, scopes: scopes, concerns: concerns, methods: methods }.to_json)
+          rescue LoadError
+            puts({ error: "Prism not available" }.to_json)
+          rescue => e
+            puts({ error: e.message }.to_json)
+          end
+        RUBY
+      end
+
+      def format_static_result(data)
+        output = ["PRISM STATIC ANALYSIS:", "-" * 40]
+        output << "Concerns: #{data["concerns"].join(", ")}" if data["concerns"]&.any?
+        if data["callbacks"]&.any?
+          output << "Callbacks:"
+          data["callbacks"].each { |c| output << "  #{c["name"]} :#{c["args"].join(", :")}" }
+        end
+        output << "Scopes: #{data["scopes"].join(", ")}" if data["scopes"]&.any?
+        if data["methods"]&.any?
+          output << "Methods:"
+          data["methods"].each { |m| output << "  #{m["name"]} (line #{m["line"]})" }
+        end
+        output.join("\n")
+      end
+
+      def batch_model_info(model_names, detail_level, analysis_type)
+        output = ["Analysis for #{model_names.size} models:\n"]
+        model_names.each { |m| output << single_model_info(m, detail_level, analysis_type) << "" }
+        output.join("\n")
+      end
+
+      def get_associations_via_introspection(model_name)
+        script = "require 'json'; puts (#{model_name}.reflect_on_all_associations.map { |a| { name: a.name.to_s, type: a.macro.to_s } } rescue []).to_json"
+        begin
+          JSON.parse(execute_rails_runner(script)).map { |a| a.transform_keys(&:to_sym) }
+        rescue
+          []
+        end
+      end
+
+      def find_model_file(model_name)
+        path = File.join(active_project_path, "app", "models", "#{underscore(model_name)}.rb")
+        File.exist?(path) ? path : Dir.glob(File.join(active_project_path, "app", "models", "**", "#{underscore(model_name).split("/").last}.rb")).first
+      end
+
+      def classify_model_name(model_file)
+        model_file.split("/").map { |part| camelize(part) }.join("::")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+module RailsMcpServer
+  module Analyzers
+    class BaseAnalyzer
+      extend Forwardable
+
+      def_delegators :RailsMcpServer, :log, :projects
+      def_delegators :RailsMcpServer, :current_project, :active_project_path
+
+      def call(**params)
+        raise NotImplementedError, "Subclasses must implement #call"
+      end
+
+      protected
+
+      def execute_rails_runner(script)
+        require "tempfile"
+
+        Tempfile.create(["analyzer", ".rb"]) do |f|
+          f.write(script)
+          f.flush
+
+          RailsMcpServer::RunProcess.execute_rails_command(
+            active_project_path,
+            "bin/rails runner #{f.path} 2>/dev/null"
+          )
+        end
+      end
+
+      def camelize(string)
+        string.split("_").map(&:capitalize).join
+      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
+end