rails-active-mcp 0.1.6 → 2.0.7

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: rails-active-mcp
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 2.0.7
 platform: ruby
 authors:
 - Brandyn Britton
 bindir: exe
 cert_chain: []
-date: 2025-06-26 00:00:00.000000000 Z
+date: 2025-06-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -15,28 +15,48 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.3.5
+        version: '1.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.3.5
+        version: '1.3'
 - !ruby/object:Gem::Dependency
   name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9.0'
+- !ruby/object:Gem::Dependency
+  name: mcp
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '7.0'
+        version: 0.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '7.0'
+        version: 0.1.0
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement
@@ -55,16 +75,22 @@ dependencies:
   name: rack
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '4.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '4.0'
 - !ruby/object:Gem::Dependency
   name: timeout
   requirement: !ruby/object:Gem::Requirement
@@ -207,7 +233,9 @@ files:
 - ".idea/vcs.xml"
 - README.md
 - changelog.md
+- claude_desktop_config.json
 - docs/DEBUGGING.md
+- docs/GENERATOR_TESTING.md
 - docs/README.md
 - exe/rails-active-mcp-server
 - lib/generators/rails_active_mcp/install/install_generator.rb
@@ -218,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/lib/rails_active_mcp/mcp_server.rb

@@ -1,374 +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 => e
-        Rails.logger.error "MCP Server Error: #{e.message}" if defined?(Rails)
-        error_response(500, 'Internal Server Error')
-      end
-    end
-
-    private
-
-    def json_request?(request)
-      request.content_type&.include?('application/json')
-    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)
-      else
-        jsonrpc_error(data['id'], -32601, 'Method not found')
-      end
-    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
-        if tool[:annotations] && !tool[:annotations].empty?
-          tool_def[:annotations] = tool[:annotations]
-        end
-
-        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'], -32602, "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 => e
-        jsonrpc_error(data['id'], -32603, "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
-
-    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: ['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 => 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 => 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 => 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 => 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,48 +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
-    initializer 'rails_active_mcp.logger' do
-      RailsActiveMcp.logger = Rails.logger if defined?(Rails.logger)
-    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