rails-active-mcp 0.1.7 → 2.0.7

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-active-mcp
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 2.0.7
 platform: ruby
 authors:
 - Brandyn Britton
@@ -32,7 +32,7 @@ dependencies:
         version: '6.1'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '8.0'
+        version: '9.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -42,7 +42,21 @@ dependencies:
         version: '6.1'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '8.0'
+        version: '9.0'
+- !ruby/object:Gem::Dependency
+  name: mcp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement
@@ -218,7 +232,6 @@ files:
 - ".idea/rails-active-mcp-gem.iml"
 - ".idea/vcs.xml"
 - README.md
-- app/controllers/rails_active_mcp/mcp_controller.rb
 - changelog.md
 - claude_desktop_config.json
 - docs/DEBUGGING.md
@@ -233,15 +246,13 @@ files:
 - lib/rails_active_mcp/configuration.rb
 - lib/rails_active_mcp/console_executor.rb
 - lib/rails_active_mcp/engine.rb
-- lib/rails_active_mcp/mcp_server.rb
-- lib/rails_active_mcp/railtie.rb
 - lib/rails_active_mcp/safety_checker.rb
-- lib/rails_active_mcp/stdio_server.rb
+- lib/rails_active_mcp/sdk/server.rb
+- lib/rails_active_mcp/sdk/tools/console_execute_tool.rb
+- lib/rails_active_mcp/sdk/tools/dry_run_tool.rb
+- lib/rails_active_mcp/sdk/tools/model_info_tool.rb
+- lib/rails_active_mcp/sdk/tools/safe_query_tool.rb
 - lib/rails_active_mcp/tasks.rake
-- lib/rails_active_mcp/tools/console_execute_tool.rb
-- lib/rails_active_mcp/tools/dry_run_tool.rb
-- lib/rails_active_mcp/tools/model_info_tool.rb
-- lib/rails_active_mcp/tools/safe_query_tool.rb
 - lib/rails_active_mcp/version.rb
 - mcp.ru
 - rails_active_mcp.gemspec

data/app/controllers/rails_active_mcp/mcp_controller.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-module RailsActiveMcp
-  class McpController < ApplicationController
-    protect_from_forgery with: :null_session
-    before_action :check_enabled
-    before_action :set_cors_headers
-
-    def handle
-      return head :method_not_allowed unless request.post?
-      return head :bad_request unless json_request?
-
-      begin
-        body = request.body.read
-        data = JSON.parse(body)
-
-        mcp_server = RailsActiveMcp::McpServer.new
-        response_data = mcp_server.handle_jsonrpc_request(data)
-
-        render json: response_data
-      rescue JSON::ParserError
-        render json: { error: 'Invalid JSON' }, status: :bad_request
-      rescue StandardError => e
-        RailsActiveMcp.logger.error "MCP Controller Error: #{e.message}"
-        render json: { error: 'Internal Server Error' }, status: :internal_server_error
-      end
-    end
-
-    def sse
-      response.headers['Content-Type'] = 'text/event-stream'
-      response.headers['Cache-Control'] = 'no-cache, no-store, must-revalidate'
-      response.headers['Connection'] = 'keep-alive'
-      response.headers['X-Accel-Buffering'] = 'no'
-
-      # Send initial connection established event
-      render plain: ": SSE connection established\n\nevent: endpoint\ndata: #{request.base_url}#{rails_active_mcp.root_path}messages\n\nretry: 100\n\n"
-    end
-
-    def health
-      status = RailsActiveMcp.config.enabled ? 'healthy' : 'disabled'
-      render json: {
-        status: status,
-        version: RailsActiveMcp::VERSION,
-        timestamp: Time.current.iso8601
-      }
-    end
-
-    def info
-      render json: {
-        name: 'Rails Active MCP',
-        version: RailsActiveMcp::VERSION,
-        description: 'Rails Console access via Model Context Protocol (MCP)',
-        endpoints: {
-          mcp: rails_active_mcp.root_path,
-          health: rails_active_mcp.root_path + 'health'
-        },
-        enabled: RailsActiveMcp.config.enabled
-      }
-    end
-
-    private
-
-    def check_enabled
-      return if RailsActiveMcp.config.enabled
-
-      render json: { error: 'Rails Active MCP is disabled' }, status: :service_unavailable
-    end
-
-    def json_request?
-      request.content_type&.include?('application/json')
-    end
-
-    def set_cors_headers
-      response.headers['Access-Control-Allow-Origin'] = '*'
-      response.headers['Access-Control-Allow-Methods'] = 'GET, POST, OPTIONS'
-      response.headers['Access-Control-Allow-Headers'] = 'Content-Type'
-      response.headers['Access-Control-Max-Age'] = '86400'
-    end
-  end
-end

data/lib/rails_active_mcp/mcp_server.rb

@@ -1,383 +0,0 @@
-# frozen_string_literal: true
-
-require 'json'
-require 'rack'
-
-module RailsActiveMcp
-  class McpServer
-    JSONRPC_VERSION = '2.0'
-    MCP_VERSION = '2025-06-18'
-
-    def initialize(app = nil)
-      @app = app
-      @tools = {}
-      @resources = {}
-      register_default_tools
-    end
-
-    def call(env)
-      request = Rack::Request.new(env)
-
-      return [405, {}, ['Method Not Allowed']] unless request.post?
-      return [400, {}, ['Invalid Content-Type']] unless json_request?(request)
-
-      begin
-        body = request.body.read
-        data = JSON.parse(body)
-        response = handle_jsonrpc_request(data)
-
-        [200, { 'Content-Type' => 'application/json' }, [response.to_json]]
-      rescue JSON::ParserError
-        error_response(400, 'Invalid JSON')
-      rescue StandardError => e
-        RailsActiveMcp.logger.error "MCP Server Error: #{e.message}"
-        error_response(500, 'Internal Server Error')
-      end
-    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_ping(data)
-      {
-        jsonrpc: JSONRPC_VERSION,
-        id: data['id'],
-        result: {}
-      }
-    end
-
-    def handle_initialize(data)
-      {
-        jsonrpc: JSONRPC_VERSION,
-        id: data['id'],
-        result: {
-          protocolVersion: MCP_VERSION,
-          capabilities: {
-            tools: {
-              list: true,
-              call: true
-            },
-            resources: {
-              read: true,
-              list: true
-            }
-          },
-          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
-
-      begin
-        result = tool[:handler].call(arguments)
-        {
-          jsonrpc: JSONRPC_VERSION,
-          id: data['id'],
-          result: { content: [{ type: 'text', text: result.to_s }] }
-        }
-      rescue StandardError => e
-        jsonrpc_error(data['id'], -32_603, "Tool execution failed: #{e.message}")
-      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 register_tool(name, description, input_schema, annotations = {}, &handler)
-      @tools[name] = {
-        name: name,
-        description: description,
-        input_schema: input_schema,
-        annotations: annotations,
-        handler: handler
-      }
-    end
-
-    private
-
-    def json_request?(request)
-      request.content_type&.include?('application/json')
-    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']
-        },
-        # Add MCP tool annotations
-        {
-          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',
-        {
-          type: 'object',
-          properties: {
-            model_name: { type: 'string', description: 'Name of the model to inspect' }
-          },
-          required: ['model_name']
-        },
-        # Safe read-only tool
-        {
-          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',
-        {
-          type: 'object',
-          properties: {
-            query: { type: 'string', description: 'Safe query to execute' },
-            model: { type: 'string', description: 'Model class name' }
-          },
-          required: %w[query model]
-        },
-        # Safe read-only query tool
-        {
-          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 safety without execution',
-        {
-          type: 'object',
-          properties: {
-            code: { type: 'string', description: 'Ruby code to analyze' }
-          },
-          required: ['code']
-        },
-        {
-          title: 'Rails Code Safety Analyzer',
-          readOnlyHint: true,
-          destructiveHint: false,
-          idempotentHint: true,
-          openWorldHint: false
-        }
-      ) do |args|
-        dry_run_analysis(args['code'])
-      end
-    end
-
-    def execute_console_code(args)
-      return 'Rails Active MCP is disabled' unless RailsActiveMcp.config.enabled
-
-      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)
-      return 'Rails Active MCP is disabled' unless RailsActiveMcp.config.enabled
-
-      begin
-        model_class = model_name.constantize
-        return "#{model_name} is not an ActiveRecord model" unless model_class < ActiveRecord::Base
-
-        info = []
-        info << "Model: #{model_class.name}"
-        info << "Table: #{model_class.table_name}"
-        info << "Columns: #{model_class.column_names.join(', ')}"
-        info << "Associations: #{model_class.reflect_on_all_associations.map(&:name).join(', ')}"
-        info.join("\n")
-      rescue NameError
-        "Model '#{model_name}' not found"
-      rescue StandardError => e
-        "Error getting model info: #{e.message}"
-      end
-    end
-
-    def execute_safe_query(args)
-      return 'Rails Active MCP is disabled' unless RailsActiveMcp.config.enabled
-
-      begin
-        model_class = args['model'].constantize
-        return "#{args['model']} is not an ActiveRecord model" unless model_class < ActiveRecord::Base
-
-        # 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?]
-        query_method = args['query'].split('.').first
-
-        return "Unsafe query method: #{query_method}" unless safe_methods.include?(query_method)
-
-        result = model_class.instance_eval(args['query'])
-        result.to_s
-      rescue NameError
-        "Model '#{args['model']}' not found"
-      rescue StandardError => e
-        "Error executing query: #{e.message}"
-      end
-    end
-
-    def dry_run_analysis(code)
-      return 'Rails Active MCP is disabled' unless RailsActiveMcp.config.enabled
-
-      executor = RailsActiveMcp::ConsoleExecutor.new(RailsActiveMcp.config)
-
-      begin
-        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 << "Would execute: #{analysis[:would_execute] ? 'Yes' : 'No'}"
-        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
-
-        output.join("\n")
-      rescue StandardError => e
-        "Analysis failed: #{e.message}"
-      end
-    end
-
-    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 jsonrpc_error(id, code, message)
-      {
-        jsonrpc: JSONRPC_VERSION,
-        id: id,
-        error: { code: code, message: message }
-      }
-    end
-
-    def error_response(status, message)
-      [status, { 'Content-Type' => 'application/json' },
-       [{ error: message }.to_json]]
-    end
-  end
-end

data/lib/rails_active_mcp/railtie.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-module RailsActiveMcp
-  class Railtie < ::Rails::Railtie
-    railtie_name :rails_active_mcp
-
-    # Ensure configuration is available very early
-    config.before_initialize do
-      RailsActiveMcp.configure unless RailsActiveMcp.configuration
-    end
-
-    # Add rake tasks
-    rake_tasks do
-      load 'rails_active_mcp/tasks.rake'
-    end
-
-    # Add generators
-    generators do
-      # Generators are auto-discovered from lib/generators following Rails conventions
-    end
-
-    # Console hook for easier access
-    console do
-      # Add convenience methods to console
-      Rails::ConsoleMethods.include(RailsActiveMcp::ConsoleMethods) if defined?(Rails::ConsoleMethods)
-    end
-
-    # Configure logging - Fixed for Rails 7.1 compatibility
-    initializer 'rails_active_mcp.logger', after: :initialize_logger, before: :set_clear_dependencies_hook do
-      # Only set logger if Rails logger is available and responds to logging methods
-      RailsActiveMcp.logger = if defined?(Rails.logger) && Rails.logger.respond_to?(:info)
-                                # Check if Rails logger is using semantic logger or other custom loggers
-                                if Rails.logger.class.name.include?('SemanticLogger')
-                                  # For semantic logger, we need to create a tagged logger
-                                  Rails.logger.tagged('RailsActiveMcp')
-                                else
-                                  # For standard Rails logger, use it directly
-                                  Rails.logger
-                                end
-                              else
-                                # Fallback to our own logger if Rails logger is not available
-                                # This should not happen in normal Rails apps but provides safety
-                                Logger.new(STDERR).tap do |logger|
-                                  logger.level = Rails.env.production? ? Logger::WARN : Logger::INFO
-                                  logger.formatter = proc do |severity, datetime, progname, msg|
-                                    "[#{datetime}] #{severity} -- RailsActiveMcp: #{msg}\n"
-                                  end
-                                end
-                              end
-
-      # Log that the logger has been initialized
-      RailsActiveMcp.logger.info "Rails Active MCP logger initialized (#{RailsActiveMcp.logger.class.name})"
-    end
-  end
-
-  # Console convenience methods
-  module ConsoleMethods
-    def mcp_execute(code, **options)
-      RailsActiveMcp.execute(code, **options)
-    end
-
-    def mcp_safe?(code)
-      RailsActiveMcp.safe?(code)
-    end
-
-    def mcp_config
-      RailsActiveMcp.config
-    end
-  end
-end