rails-active-mcp 0.1.7 → 2.0.8

data/lib/rails_active_mcp/stdio_server.rb

@@ -1,517 +0,0 @@
-# frozen_string_literal: true
-
-require 'json'
-require 'io/console'
-require 'logger'
-
-module RailsActiveMcp
-  class StdioServer
-    JSONRPC_VERSION = '2.0'
-    MCP_VERSION = '2025-06-18'
-
-    def initialize
-      @tools = {}
-      @mcp_server = McpServer.new
-      @running = false
-
-      # Ensure all logging goes to stderr, never stdout
-      setup_logging
-      register_default_tools
-      log_to_stderr "Rails Active MCP Server initialized with #{@tools.size} tools", level: :info
-    end
-
-    def start
-      @running = true
-      log_to_stderr 'Rails Active MCP Server started successfully', level: :info
-
-      # Send initial notification to stderr first, then stdout for MCP
-      send_notification('info', 'Rails Active MCP Server started successfully')
-
-      process_requests
-    end
-
-    def stop
-      @running = false
-      log_to_stderr 'Rails Active MCP Server stopped', level: :info
-    end
-
-    private
-
-    def setup_logging
-      # Configure Rails Active MCP logger to use stderr
-      return unless RailsActiveMcp.respond_to?(:logger=)
-
-      stderr_logger = Logger.new($stderr)
-      stderr_logger.level = ENV['RAILS_MCP_DEBUG'] == '1' ? Logger::DEBUG : Logger::INFO
-      stderr_logger.formatter = proc do |severity, datetime, progname, msg|
-        "[#{datetime.strftime('%Y-%m-%d %H:%M:%S %z')}] [RAILS-MCP] #{severity}: #{msg}\n"
-      end
-      RailsActiveMcp.logger = stderr_logger
-    end
-
-    def process_requests
-      while @running
-        begin
-          line = $stdin.gets
-          break if line.nil?
-
-          line = line.strip
-          next if line.empty?
-
-          log_to_stderr "Received request: #{line}", level: :debug
-
-          request = JSON.parse(line)
-          log_to_stderr "Processing method: #{request['method']}", level: :debug
-
-          response = @mcp_server.handle_jsonrpc_request(request)
-
-          log_to_stderr "Sending response: #{response.to_json}", level: :debug
-
-          # Only JSON responses go to stdout
-          $stdout.puts response.to_json
-          $stdout.flush
-        rescue JSON::ParserError => e
-          log_to_stderr "JSON parse error: #{e.message}", level: :error
-          send_error_response(nil, -32_700, 'Parse error')
-        rescue StandardError => e
-          log_to_stderr "Server error: #{e.message}", level: :error
-          log_to_stderr e.backtrace.join("\n"), level: :debug
-          send_error_response(nil, -32_603, 'Internal error')
-        end
-      end
-    end
-
-    def send_notification(level, message)
-      notification = {
-        jsonrpc: JSONRPC_VERSION,
-        method: 'notifications/message',
-        params: {
-          level: level,
-          data: message
-        }
-      }
-
-      # Notifications go to stdout for MCP protocol
-      $stdout.puts notification.to_json
-      $stdout.flush
-    end
-
-    def send_error_response(id, code, message)
-      error_response = {
-        jsonrpc: JSONRPC_VERSION,
-        id: id,
-        error: {
-          code: code,
-          message: message
-        }
-      }
-
-      $stdout.puts error_response.to_json
-      $stdout.flush
-    end
-
-    def log_to_stderr(message, level: :info)
-      return unless ENV['RAILS_MCP_DEBUG'] == '1' || level == :error || level == :info
-
-      timestamp = Time.now.strftime('%Y-%m-%d %H:%M:%S %z')
-      warn "[#{timestamp}] [RAILS-MCP] #{level.to_s.upcase}: #{message}"
-      $stderr.flush
-    end
-
-    def handle_jsonrpc_request(data)
-      case data['method']
-      when 'initialize'
-        handle_initialize(data)
-      when 'tools/list'
-        handle_tools_list(data)
-      when 'tools/call'
-        handle_tools_call(data)
-      when 'resources/list'
-        handle_resources_list(data)
-      when 'resources/read'
-        handle_resources_read(data)
-      when 'ping'
-        handle_ping(data)
-      else
-        jsonrpc_error(data['id'], -32_601, 'Method not found')
-      end
-    end
-
-    def handle_initialize(data)
-      {
-        jsonrpc: JSONRPC_VERSION,
-        id: data['id'],
-        result: {
-          protocolVersion: MCP_VERSION,
-          capabilities: {
-            tools: {},
-            resources: {}
-          },
-          serverInfo: {
-            name: 'rails-active-mcp',
-            version: RailsActiveMcp::VERSION
-          }
-        }
-      }
-    end
-
-    def handle_tools_list(data)
-      tools_array = @tools.values.map do |tool|
-        tool_def = {
-          name: tool[:name],
-          description: tool[:description],
-          inputSchema: tool[:input_schema]
-        }
-
-        # Add annotations if present
-        tool_def[:annotations] = tool[:annotations] if tool[:annotations] && !tool[:annotations].empty?
-
-        tool_def
-      end
-
-      {
-        jsonrpc: JSONRPC_VERSION,
-        id: data['id'],
-        result: { tools: tools_array }
-      }
-    end
-
-    def handle_tools_call(data)
-      tool_name = data.dig('params', 'name')
-      arguments = data.dig('params', 'arguments') || {}
-
-      tool = @tools[tool_name]
-      return jsonrpc_error(data['id'], -32_602, "Tool '#{tool_name}' not found") unless tool
-
-      log_to_stderr "Executing tool: #{tool_name}", level: :info
-      send_notification('info', "Executing tool: #{tool_name}")
-
-      begin
-        start_time = Time.now
-        result = tool[:handler].call(arguments)
-        execution_time = Time.now - start_time
-
-        log_to_stderr "Tool #{tool_name} completed in #{execution_time}s", level: :info
-        send_notification('info', "Tool #{tool_name} completed successfully")
-
-        {
-          jsonrpc: JSONRPC_VERSION,
-          id: data['id'],
-          result: {
-            content: [{ type: 'text', text: result.to_s }],
-            isError: false
-          }
-        }
-      rescue StandardError => e
-        log_to_stderr "Tool execution error: #{e.message}", level: :error
-        log_to_stderr e.backtrace.first(5).join("\n"), level: :debug if ENV['RAILS_MCP_DEBUG']
-        send_notification('error', "Tool #{tool_name} failed: #{e.message}")
-
-        {
-          jsonrpc: JSONRPC_VERSION,
-          id: data['id'],
-          result: {
-            content: [{ type: 'text', text: "Error: #{e.message}" }],
-            isError: true
-          }
-        }
-      end
-    end
-
-    def handle_resources_list(data)
-      {
-        jsonrpc: JSONRPC_VERSION,
-        id: data['id'],
-        result: { resources: [] }
-      }
-    end
-
-    def handle_resources_read(data)
-      {
-        jsonrpc: JSONRPC_VERSION,
-        id: data['id'],
-        result: { contents: [] }
-      }
-    end
-
-    def handle_ping(data)
-      {
-        jsonrpc: JSONRPC_VERSION,
-        id: data['id'],
-        result: {}
-      }
-    end
-
-    def register_tool(name, description, input_schema, annotations = {}, &handler)
-      @tools[name] = {
-        name: name,
-        description: description,
-        input_schema: input_schema,
-        annotations: annotations,
-        handler: handler
-      }
-    end
-
-    def register_default_tools
-      register_tool(
-        'rails_console_execute',
-        'Execute Ruby code in Rails console context',
-        {
-          type: 'object',
-          properties: {
-            code: { type: 'string', description: 'Ruby code to execute' },
-            timeout: { type: 'number', description: 'Timeout in seconds', default: 30 },
-            safe_mode: { type: 'boolean', description: 'Enable safety checks', default: true },
-            capture_output: { type: 'boolean', description: 'Capture console output', default: true }
-          },
-          required: ['code']
-        },
-        {
-          title: 'Rails Console Executor',
-          readOnlyHint: false,
-          destructiveHint: true,
-          idempotentHint: false,
-          openWorldHint: false
-        }
-      ) do |args|
-        execute_console_code(args)
-      end
-
-      register_tool(
-        'rails_model_info',
-        'Get information about Rails models including columns, associations, and table structure',
-        {
-          type: 'object',
-          properties: {
-            model_name: { type: 'string', description: 'Name of the Rails model class to inspect' }
-          },
-          required: ['model_name']
-        },
-        {
-          title: 'Rails Model Inspector',
-          readOnlyHint: true,
-          destructiveHint: false,
-          idempotentHint: true,
-          openWorldHint: false
-        }
-      ) do |args|
-        get_model_info(args['model_name'])
-      end
-
-      register_tool(
-        'rails_safe_query',
-        'Execute safe read-only database queries using ActiveRecord',
-        {
-          type: 'object',
-          properties: {
-            query: { type: 'string', description: 'ActiveRecord query to execute (read-only methods only)' },
-            model: { type: 'string', description: 'Model class name to query against' }
-          },
-          required: %w[query model]
-        },
-        {
-          title: 'Rails Safe Query Executor',
-          readOnlyHint: true,
-          destructiveHint: false,
-          idempotentHint: true,
-          openWorldHint: false
-        }
-      ) do |args|
-        execute_safe_query(args)
-      end
-
-      register_tool(
-        'rails_dry_run',
-        'Analyze Ruby code for safety without executing it',
-        {
-          type: 'object',
-          properties: {
-            code: { type: 'string', description: 'Ruby code to analyze for safety and potential issues' }
-          },
-          required: ['code']
-        },
-        {
-          title: 'Rails Code Safety Analyzer',
-          readOnlyHint: true,
-          destructiveHint: false,
-          idempotentHint: true,
-          openWorldHint: false
-        }
-      ) do |args|
-        dry_run_analysis(args['code'])
-      end
-    end
-
-    # Tool implementation methods (reused from McpServer)
-    def execute_console_code(args)
-      unless defined?(RailsActiveMcp) && RailsActiveMcp.respond_to?(:config) && RailsActiveMcp.config.enabled
-        return 'Rails Active MCP is disabled. Enable it in your Rails configuration.'
-      end
-
-      executor = RailsActiveMcp::ConsoleExecutor.new(RailsActiveMcp.config)
-
-      begin
-        result = executor.execute(
-          args['code'],
-          timeout: args['timeout'] || 30,
-          safe_mode: args['safe_mode'] != false,
-          capture_output: args['capture_output'] != false
-        )
-
-        if result[:success]
-          format_success_result(result)
-        else
-          "Error: #{result[:error]} (#{result[:error_class]})"
-        end
-      rescue RailsActiveMcp::SafetyError => e
-        "Safety check failed: #{e.message}"
-      rescue RailsActiveMcp::TimeoutError => e
-        "Execution timed out: #{e.message}"
-      rescue StandardError => e
-        "Execution failed: #{e.message}"
-      end
-    end
-
-    def get_model_info(model_name)
-      unless defined?(RailsActiveMcp) && RailsActiveMcp.respond_to?(:config) && RailsActiveMcp.config.enabled
-        return 'Rails Active MCP is disabled. Enable it in your Rails configuration.'
-      end
-
-      begin
-        # Check if Rails environment is available
-        unless defined?(Rails)
-          return 'Rails environment not loaded. Please ensure the MCP server is started from your Rails app directory.'
-        end
-
-        model_class = model_name.constantize
-        unless defined?(ActiveRecord) && model_class < ActiveRecord::Base
-          return "#{model_name} is not an ActiveRecord model"
-        end
-
-        info = []
-        info << "Model: #{model_class.name}"
-        info << "Table: #{model_class.table_name}"
-        info << "Columns: #{model_class.column_names.join(', ')}"
-
-        associations = model_class.reflect_on_all_associations.map(&:name)
-        info << "Associations: #{associations.any? ? associations.join(', ') : 'None'}"
-
-        # Add validation info if available
-        if model_class.respond_to?(:validators) && model_class.validators.any?
-          validations = model_class.validators.map { |v| "#{v.attributes.join(', ')}: #{v.class.name.demodulize}" }.uniq
-          info << "Validations: #{validations.join(', ')}"
-        end
-
-        info.join("\n")
-      rescue NameError
-        "Model '#{model_name}' not found. Make sure the model class exists and is properly defined."
-      rescue StandardError => e
-        "Error getting model info: #{e.message}"
-      end
-    end
-
-    def execute_safe_query(args)
-      unless defined?(RailsActiveMcp) && RailsActiveMcp.respond_to?(:config) && RailsActiveMcp.config.enabled
-        return 'Rails Active MCP is disabled. Enable it in your Rails configuration.'
-      end
-
-      begin
-        # Check if Rails environment is available
-        unless defined?(Rails)
-          return 'Rails environment not loaded. Please ensure the MCP server is started from your Rails app directory.'
-        end
-
-        model_class = args['model'].constantize
-        unless defined?(ActiveRecord) && model_class < ActiveRecord::Base
-          return "#{args['model']} is not an ActiveRecord model"
-        end
-
-        # Only allow safe read-only methods
-        safe_methods = %w[find find_by where select count sum average maximum minimum first last pluck ids exists?
-                          empty? any? many? include? limit offset order group having joins includes references distinct uniq readonly]
-
-        # Extract the first method call to validate it's safe
-        query_parts = args['query'].split('.')
-        query_method = query_parts.first.split('(').first
-
-        unless safe_methods.include?(query_method)
-          return "Unsafe query method: #{query_method}. Only read-only methods are allowed."
-        end
-
-        result = model_class.instance_eval(args['query'])
-
-        # Format result appropriately
-        case result
-        when ActiveRecord::Relation
-          "Query returned #{result.count} records: #{result.limit(10).pluck(:id).join(', ')}#{result.count > 10 ? '...' : ''}"
-        when Array
-          "Array with #{result.length} items: #{result.take(5).inspect}#{result.length > 5 ? '...' : ''}"
-        else
-          result.to_s
-        end
-      rescue NameError
-        "Model '#{args['model']}' not found. Make sure the model class exists and is properly defined."
-      rescue StandardError => e
-        "Error executing query: #{e.message}"
-      end
-    end
-
-    def dry_run_analysis(code)
-      unless defined?(RailsActiveMcp) && RailsActiveMcp.respond_to?(:config) && RailsActiveMcp.config.enabled
-        return 'Rails Active MCP is disabled. Enable it in your Rails configuration.'
-      end
-
-      executor = RailsActiveMcp::ConsoleExecutor.new(RailsActiveMcp.config)
-
-      begin
-        analysis = executor.dry_run(code)
-
-        output = []
-        output << 'Code Analysis Results:'
-        output << "Code: #{analysis[:code]}"
-        output << "Safe: #{analysis[:safety_analysis][:safe] ? 'Yes' : 'No'}"
-        output << "Read-only: #{analysis[:safety_analysis][:read_only] ? 'Yes' : 'No'}"
-        output << "Risk level: #{analysis[:estimated_risk]}"
-        output << "Would execute: #{analysis[:would_execute] ? 'Yes' : 'No'}"
-        output << "Summary: #{analysis[:safety_analysis][:summary]}"
-
-        if analysis[:safety_analysis][:violations] && analysis[:safety_analysis][:violations].any?
-          output << "\nSafety Violations:"
-          analysis[:safety_analysis][:violations].each do |violation|
-            output << "  - #{violation[:description]} (#{violation[:severity]})"
-          end
-        end
-
-        if analysis[:recommendations] && analysis[:recommendations].any?
-          output << "\nRecommendations:"
-          analysis[:recommendations].each do |rec|
-            output << "  - #{rec}"
-          end
-        end
-
-        output.join("\n")
-      rescue StandardError => e
-        "Analysis failed: #{e.message}. Make sure the Rails environment is properly loaded."
-      end
-    end
-
-    def format_success_result(result)
-      output = []
-      output << 'Execution Results:'
-      output << "Code: #{result[:code]}"
-      output << "Result: #{result[:return_value_string] || result[:return_value]}"
-      output << "Output: #{result[:output]}" if result[:output] && !result[:output].empty?
-      output << "Execution time: #{result[:execution_time]}s" if result[:execution_time]
-      output << "Note: #{result[:note]}" if result[:note]
-      output.join("\n")
-    end
-
-    def jsonrpc_error(id, code, message)
-      {
-        jsonrpc: JSONRPC_VERSION,
-        id: id,
-        error: { code: code, message: message }
-      }
-    end
-  end
-end

data/lib/rails_active_mcp/tools/console_execute_tool.rb

@@ -1,61 +0,0 @@
-module RailsActiveMcp
-  module Tools
-    class ConsoleExecuteTool < ApplicationMCPTool
-      tool_name "console_execute"
-      description "Execute Ruby code in Rails console with safety checks"
-
-      property :code, type: "string", description: 'Ruby code to execute in Rails console', required: true
-      property :safe_mode, type: "boolean", description: 'Enable safety checks (default: true)', required: false
-      property :timeout, type: "integer", description: 'Timeout in seconds (default: 30)', required: false
-      property :capture_output, type: "boolean", description: 'Capture console output (default: true)', required: false
-
-      def perform
-        code = properties[:code]
-        safe_mode = properties[:safe_mode]
-        timeout = properties[:timeout]
-        capture_output = properties.fetch(:capture_output, true)
-
-        return render(error: "Rails Active MCP is disabled") unless RailsActiveMcp.config.enabled
-
-        executor = RailsActiveMcp::ConsoleExecutor.new(RailsActiveMcp.config)
-
-        begin
-          result = executor.execute(
-            code,
-            timeout: timeout,
-            safe_mode: safe_mode,
-            capture_output: capture_output
-          )
-
-          if result[:success]
-            render(text: format_success_result(result))
-          else
-            render(error: [format_error_result(result)])
-          end
-        rescue RailsActiveMcp::SafetyError => e
-          render(error: ["Safety check failed: #{e.message}"])
-        rescue RailsActiveMcp::TimeoutError => e
-          render(error: ["Execution timed out: #{e.message}"])
-        rescue => e
-          render(error: ["Execution failed: #{e.message}"])
-        end
-      end
-
-      private
-
-      def format_success_result(result)
-        output = []
-        output << "Code: #{result[:code]}"
-        output << "Result: #{result[:return_value_string] || result[:return_value]}"
-        output << "Output: #{result[:output]}" if result[:output].present?
-        output << "Execution time: #{result[:execution_time]}s" if result[:execution_time]
-        output << "Note: #{result[:note]}" if result[:note]
-        output.join("\n")
-      end
-
-      def format_error_result(result)
-        "Error: #{result[:error]} (#{result[:error_class]})"
-      end
-    end
-  end
-end

data/lib/rails_active_mcp/tools/dry_run_tool.rb

@@ -1,41 +0,0 @@
-module RailsActiveMcp
-  module Tools
-    class DryRunTool < ApplicationMCPTool
-      tool_name "dry_run"
-      description "Analyze Ruby code for safety without executing it"
-
-      property :code, type: "string", description: 'Ruby code to analyze for safety', required: true
-
-      def perform
-        return render(error: "Rails Active MCP is disabled") unless RailsActiveMcp.config.enabled
-
-        code = properties[:code]
-        executor = RailsActiveMcp::ConsoleExecutor.new(RailsActiveMcp.config)
-        analysis = executor.dry_run(code)
-
-        output = []
-        output << "Code: #{analysis[:code]}"
-        output << "Safe: #{analysis[:safety_analysis][:safe] ? 'Yes' : 'No'}"
-        output << "Read-only: #{analysis[:safety_analysis][:read_only] ? 'Yes' : 'No'}"
-        output << "Risk level: #{analysis[:estimated_risk]}"
-        output << "Summary: #{analysis[:safety_analysis][:summary]}"
-
-        if analysis[:safety_analysis][:violations].any?
-          output << "\nViolations:"
-          analysis[:safety_analysis][:violations].each do |violation|
-            output << "  - #{violation[:description]} (#{violation[:severity]})"
-          end
-        end
-
-        if analysis[:recommendations].any?
-          output << "\nRecommendations:"
-          analysis[:recommendations].each do |rec|
-            output << "  - #{rec}"
-          end
-        end
-
-        render(text: output.join("\n"))
-      end
-    end
-  end
-end

data/lib/rails_active_mcp/tools/model_info_tool.rb

@@ -1,70 +0,0 @@
-module RailsActiveMcp
-  module Tools
-    class ModelInfoTool < ApplicationMCPTool
-      tool_name "model_info"
-      description "Get information about Rails models including schema and associations"
-
-      property :model, type: "string", description: 'Model class name', required: true
-      property :include_schema, type: "boolean", description: 'Include database schema information', required: false
-      property :include_associations, type: "boolean", description: 'Include model associations', required: false
-      property :include_validations, type: "boolean", description: 'Include model validations', required: false
-
-      def perform
-        return render(error: "Rails Active MCP is disabled") unless RailsActiveMcp.config.enabled
-
-        model = properties[:model]
-        include_schema = properties.fetch(:include_schema, true)
-        include_associations = properties.fetch(:include_associations, true)
-        include_validations = properties.fetch(:include_validations, true)
-
-        begin
-          model_class = model.constantize
-
-          output = []
-          output << "Model: #{model}"
-          output << "Table: #{model_class.table_name}"
-          output << "Primary Key: #{model_class.primary_key}"
-
-          if include_schema
-            output << "\nSchema:"
-            model_class.columns.each do |column|
-              output << "  #{column.name}: #{column.type} (#{column.sql_type})"
-              output << "    - Null: #{column.null}"
-              output << "    - Default: #{column.default}" if column.default
-            end
-          end
-
-          if include_associations
-            output << "\nAssociations:"
-            model_class.reflections.each do |name, reflection|
-              output << "  #{name}: #{reflection.class.name.split('::').last} -> #{reflection.class_name}"
-            end
-          end
-
-          if include_validations
-            validations = {}
-            model_class.validators.each do |validator|
-              validator.attributes.each do |attribute|
-                validations[attribute] ||= []
-                validations[attribute] << validator.class.name.split('::').last
-              end
-            end
-
-            if validations.any?
-              output << "\nValidations:"
-              validations.each do |attr, validators|
-                output << "  #{attr}: #{validators.join(', ')}"
-              end
-            end
-          end
-
-          render(text: output.join("\n"))
-        rescue NameError
-          render(error: ["Model '#{model}' not found"])
-        rescue => e
-          render(error: ["Error analyzing model: #{e.message}"])
-        end
-      end
-    end
-  end
-end