rails-active-mcp 0.1.7 → 2.0.8

data/lib/rails_active_mcp/sdk/tools/model_info_tool.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require 'mcp'
+
+module RailsActiveMcp
+  module Sdk
+    module Tools
+      class ModelInfoTool < MCP::Tool
+        description 'Get information about Rails models including schema and associations'
+
+        input_schema(
+          properties: {
+            model: {
+              type: 'string',
+              description: 'Model class name'
+            },
+            include_schema: {
+              type: 'boolean',
+              description: 'Include database schema information'
+            },
+            include_associations: {
+              type: 'boolean',
+              description: 'Include model associations'
+            },
+            include_validations: {
+              type: 'boolean',
+              description: 'Include model validations'
+            }
+          },
+          required: ['model']
+        )
+
+        annotations(
+          title: 'Rails Model Inspector',
+          destructive_hint: false,
+          read_only_hint: true,
+          idempotent_hint: true,
+          open_world_hint: false
+        )
+
+        def self.call(model:, server_context:, include_schema: true, include_associations: true,
+                      include_validations: true)
+          config = RailsActiveMcp.config
+
+          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
+
+            MCP::Tool::Response.new([
+                                      { type: 'text', text: output.join("\n") }
+                                    ])
+          rescue NameError
+            error_response("Model '#{model}' not found")
+          rescue StandardError => e
+            error_response("Error analyzing model: #{e.message}")
+          end
+        end
+
+        private
+
+        def self.error_response(message)
+          MCP::Tool::Response.new([
+                                    { type: 'text', text: message }
+                                  ])
+        end
+      end
+    end
+  end
+end

data/lib/rails_active_mcp/sdk/tools/safe_query_tool.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'mcp'
+
+module RailsActiveMcp
+  module Sdk
+    module Tools
+      class SafeQueryTool < MCP::Tool
+        description 'Execute safe read-only database queries on Rails models'
+
+        input_schema(
+          properties: {
+            model: {
+              type: 'string',
+              description: 'Model class name (e.g., "User", "Product")'
+            },
+            method: {
+              type: 'string',
+              description: 'Query method (find, where, count, etc.)'
+            },
+            args: {
+              type: 'array',
+              description: 'Arguments for the query method'
+            },
+            limit: {
+              type: 'integer',
+              description: 'Limit results (default: 100)'
+            }
+          },
+          required: %w[model method]
+        )
+
+        annotations(
+          title: 'Safe Query Executor',
+          destructive_hint: false,
+          read_only_hint: true,
+          idempotent_hint: true,
+          open_world_hint: false
+        )
+
+        def self.call(model:, method:, server_context:, args: [], limit: 100)
+          config = RailsActiveMcp.config
+
+          executor = RailsActiveMcp::ConsoleExecutor.new(config)
+
+          result = executor.execute_safe_query(
+            model: model,
+            method: method,
+            args: args,
+            limit: limit
+          )
+
+          if result[:success]
+            output = []
+            output << "Query: #{model}.#{method}(#{args.join(', ')})"
+            output << "Count: #{result[:count]}" if result[:count]
+            output << "Result: #{result[:result].inspect}"
+
+            MCP::Tool::Response.new([
+                                      { type: 'text', text: output.join("\n") }
+                                    ])
+          else
+            error_response(result[:error])
+          end
+        end
+
+        private
+
+        def self.error_response(message)
+          MCP::Tool::Response.new([
+                                    { type: 'text', text: message }
+                                  ])
+        end
+      end
+    end
+  end
+end

data/lib/rails_active_mcp/tasks.rake

@@ -1,5 +1,5 @@
 namespace :rails_active_mcp do
-  desc "Check the safety of Ruby code"
+  desc 'Check the safety of Ruby code'
   task :check_safety, [:code] => :environment do |task, args|
     code = args[:code]
 
@@ -24,7 +24,7 @@ namespace :rails_active_mcp do
     end
   end
 
-  desc "Execute Ruby code with safety checks"
+  desc 'Execute Ruby code with safety checks'
   task :execute, [:code] => :environment do |task, args|
     code = args[:code]
 
@@ -44,111 +44,267 @@ namespace :rails_active_mcp do
         puts "Error: #{result[:error]}"
         puts "Error class: #{result[:error_class]}" if result[:error_class]
       end
-    rescue => e
+    rescue StandardError => e
       puts "Failed to execute: #{e.message}"
       exit 1
     end
   end
 
-  desc "Test MCP tools"
-  task :test_tools => :environment do
-    puts "Testing Rails Active MCP tools..."
+  desc 'Test MCP tools'
+  task test_tools: :environment do
+    puts 'Testing Rails Active MCP tools...'
 
-    # Test SafeQueryTool
-    puts "\n1. Testing SafeQueryTool..."
-    if defined?(User)
-      tool = RailsActiveMcp::Tools::SafeQueryTool.new
-      result = tool.call(model: "User", method: "count")
-      puts "  User.count: #{result[:success] ? result[:result] : result[:error]}"
+    # Test console execution
+    puts "\n1. Testing console_execute tool:"
+    result = RailsActiveMcp.execute('1 + 1')
+    puts "  Simple math: #{result[:success] ? 'PASS' : 'FAIL'}"
+
+    # Test safety checking
+    puts "\n2. Testing safety checking:"
+    safe_result = RailsActiveMcp.safe?('User.count')
+    dangerous_result = RailsActiveMcp.safe?('User.delete_all')
+    puts "  Safe code detection: #{safe_result ? 'PASS' : 'FAIL'}"
+    puts "  Dangerous code detection: #{!dangerous_result ? 'PASS' : 'FAIL'}"
+
+    # Test Rails integration
+    puts "\n3. Testing Rails integration:"
+    if defined?(Rails) && Rails.respond_to?(:env)
+      puts "  Rails environment: #{Rails.env} - PASS"
     else
-      puts "  Skipped (User model not found)"
+      puts '  Rails environment: NOT DETECTED - FAIL'
     end
 
-    # Test ConsoleExecuteTool
-    puts "\n2. Testing ConsoleExecuteTool..."
-    tool = RailsActiveMcp::Tools::ConsoleExecuteTool.new
-    result = tool.call(code: "1 + 1")
-    puts "  1 + 1: #{result[:success] ? result[:return_value] : result[:error]}"
+    puts "\nAll tests completed!"
+  end
 
-    # Test DryRunTool
-    puts "\n3. Testing DryRunTool..."
-    tool = RailsActiveMcp::Tools::DryRunTool.new
-    result = tool.call(code: "User.delete_all")
-    puts "  User.delete_all analysis: #{result[:estimated_risk]} risk"
+  desc 'Benchmark MCP tools performance'
+  task benchmark: :environment do
+    require 'benchmark'
 
-    puts "\nAll tools tested!"
-  end
+    puts 'Rails Active MCP Performance Benchmark'
+    puts '=' * 50
 
-  desc "Show configuration"
-  task :config => :environment do
-    config = RailsActiveMcp.config
+    # Benchmark safety checking
+    puts "\nSafety Checker Performance:"
+    Benchmark.bm(20) do |x|
+      x.report('Simple check:') do
+        1000.times { RailsActiveMcp.safe?('User.count') }
+      end
 
-    puts "Rails Active MCP Configuration:"
-    puts "  Enabled: #{config.enabled}"
-    puts "  Safe mode: #{config.safe_mode}"
-    puts "  Default timeout: #{config.default_timeout}s"
-    puts "  Max results: #{config.max_results}"
-    puts "  Log executions: #{config.log_executions}"
-    puts "  Audit file: #{config.audit_file}"
-    puts "  Enable mutation tools: #{config.enable_mutation_tools}"
-    puts "  Execution environment: #{config.execution_environment}"
+      x.report('Complex check:') do
+        100.times { RailsActiveMcp.safe?('User.where(active: true).includes(:posts).limit(10)') }
+      end
 
-    if config.allowed_models.any?
-      puts "  Allowed models: #{config.allowed_models.join(', ')}"
+      x.report('Dangerous check:') do
+        1000.times { RailsActiveMcp.safe?('User.delete_all') }
+      end
     end
 
-    if config.blocked_models.any?
-      puts "  Blocked models: #{config.blocked_models.join(', ')}"
-    end
+    # Benchmark code execution
+    puts "\nCode Execution Performance:"
+    Benchmark.bm(20) do |x|
+      x.report('Simple math:') do
+        100.times { RailsActiveMcp.execute('1 + 1') }
+      end
 
-    if config.custom_safety_patterns.any?
-      puts "  Custom safety patterns: #{config.custom_safety_patterns.size}"
+      x.report('String operations:') do
+        100.times { RailsActiveMcp.execute('"hello".upcase') }
+      end
     end
   end
 
-  desc "View audit log"
-  task :audit_log, [:lines] => :environment do |task, args|
-    lines = args[:lines]&.to_i || 10
-    audit_file = RailsActiveMcp.config.audit_file
+  desc 'Validate Rails Active MCP configuration'
+  task validate_config: :environment do
+    puts 'Validating Rails Active MCP configuration...'
+
+    config = RailsActiveMcp.config
+
+    if config.valid?
+      puts '✅ Configuration is valid'
 
-    unless File.exist?(audit_file)
-      puts "Audit log not found at: #{audit_file}"
+      puts "\nCurrent Settings:"
+      puts "  Safe mode: #{config.safe_mode}"
+      puts "  Command timeout: #{config.command_timeout}s"
+      puts "  Max results: #{config.max_results}"
+      puts "  Log executions: #{config.log_executions}"
+      puts "  Log level: #{config.log_level}"
+      puts "  Allowed models: #{config.allowed_models.any? ? config.allowed_models.join(', ') : 'All models allowed'}"
+      puts "  Custom safety patterns: #{config.custom_safety_patterns.length} patterns"
+    else
+      puts '❌ Configuration is invalid'
+      puts 'Please check your config/initializers/rails_active_mcp.rb file'
       exit 1
     end
+  end
+
+  desc 'Generate example usage documentation'
+  task generate_examples: :environment do
+    examples_file = Rails.root.join('doc', 'rails_active_mcp_examples.md')
+    FileUtils.mkdir_p(File.dirname(examples_file))
+
+    content = <<~MARKDOWN
+      # Rails Active MCP Usage Examples
+
+      Generated on #{Date.current}
+
+      ## Safe Operations
+
+      These operations are considered safe and can be executed in safe mode:
+
+      ```ruby
+      # Basic model queries
+      User.count
+      User.all.limit(10)
+      User.where(active: true)
+      User.find(1)
+
+      # Associations
+      User.includes(:posts).limit(5)
+      Post.joins(:user).where(users: { active: true })
+
+      # Aggregations
+      Order.sum(:total_amount)
+      User.group(:status).count
+
+      # System information
+      Rails.env
+      Rails.version
+      Time.current
+      ```
+
+      ## Dangerous Operations (Blocked in Safe Mode)
+
+      These operations are blocked when safe_mode is enabled:
 
-    puts "Last #{lines} entries from audit log:"
-    puts "=" * 50
-
-    File.readlines(audit_file).last(lines).each do |line|
-      begin
-        entry = JSON.parse(line)
-        timestamp = entry['timestamp']
-        code = entry['code']
-        user = entry.dig('user', 'email') || entry.dig('user', 'environment') || 'unknown'
-
-        puts "#{timestamp} [#{user}]: #{code}"
-
-        if entry['type'] == 'error'
-          puts "  ERROR: #{entry['error']}"
-        elsif entry['safety_check'] && !entry['safety_check']['safe']
-          puts "  SAFETY: #{entry['safety_check']['summary']}"
-        end
-        puts
-      rescue JSON::ParserError
-        puts "Invalid JSON entry: #{line}"
+      ```ruby
+      # Mass deletions
+      User.delete_all
+      User.destroy_all
+
+      # System commands
+      system('rm -rf /')
+      `ls -la`
+
+      # File operations
+      File.delete('important_file.txt')
+      FileUtils.rm_rf('/important/directory')
+
+      # Code evaluation
+      eval(user_input)
+      send(dynamic_method)
+      ```
+
+      ## Claude Desktop Usage Examples
+
+      Ask Claude these questions to interact with your Rails app:
+
+      - "How many users do we have?"
+      - "Show me the User model structure"
+      - "What are the most recent orders?"
+      - "Check if this code is safe: User.where(active: false).delete_all"
+      - "Find users created in the last week"
+      - "What associations does the Post model have?"
+
+      ## Configuration Examples
+
+      ### Development Configuration
+      ```ruby
+      RailsActiveMcp.configure do |config|
+        config.safe_mode = false
+        config.log_level = :debug
+        config.command_timeout = 60
+        config.max_results = 200
       end
-    end
+      ```
+
+      ### Production Configuration
+      ```ruby
+      RailsActiveMcp.configure do |config|
+        config.safe_mode = true
+        config.log_level = :warn
+        config.command_timeout = 15
+        config.max_results = 50
+        config.allowed_models = %w[User Post Comment]
+      end
+      ```
+    MARKDOWN
+
+    File.write(examples_file, content)
+    puts "Examples generated at: #{examples_file}"
   end
 
-  desc "Clear audit log"
-  task :clear_audit_log => :environment do
-    audit_file = RailsActiveMcp.config.audit_file
+  desc 'Install Claude Desktop configuration'
+  task install_claude_config: :environment do
+    config_template = {
+      mcpServers: {
+        'rails-active-mcp' => {
+          command: Rails.root.join('bin', 'rails-active-mcp-wrapper').to_s,
+          cwd: Rails.root.to_s,
+          env: {
+            RAILS_ENV: Rails.env
+          }
+        }
+      }
+    }
 
-    if File.exist?(audit_file)
-      File.truncate(audit_file, 0)
-      puts "Audit log cleared: #{audit_file}"
-    else
-      puts "Audit log not found: #{audit_file}"
+    puts 'Claude Desktop Configuration:'
+    puts JSON.pretty_generate(config_template)
+    puts ''
+    puts 'Add this to your Claude Desktop configuration file:'
+    puts '  macOS/Linux: ~/.config/claude-desktop/claude_desktop_config.json'
+    puts '  Windows: %APPDATA%\\Claude\\claude_desktop_config.json'
+  end
+
+  desc 'Show comprehensive status and diagnostics'
+  task status: :environment do
+    puts 'Rails Active MCP Status Report'
+    puts '=' * 50
+
+    # Basic environment info
+    puts "\n📋 Environment Information:"
+    puts "  Rails version: #{Rails.version}"
+    puts "  Ruby version: #{RUBY_VERSION}"
+    puts "  Rails environment: #{Rails.env}"
+    puts "  Rails Active MCP version: #{RailsActiveMcp::VERSION}"
+
+    # Configuration status
+    puts "\n⚙️  Configuration Status:"
+    config = RailsActiveMcp.config
+    puts "  Valid: #{config.valid? ? '✅' : '❌'}"
+    puts "  Safe mode: #{config.safe_mode ? '🔒 Enabled' : '⚠️  Disabled'}"
+    puts "  Timeout: #{config.command_timeout}s"
+    puts "  Max results: #{config.max_results}"
+
+    # File status
+    puts "\n📁 File Status:"
+    files_to_check = [
+      'bin/rails-active-mcp-server',
+      'bin/rails-active-mcp-wrapper',
+      'config/initializers/rails_active_mcp.rb'
+    ]
+
+    files_to_check.each do |file|
+      full_path = Rails.root.join(file)
+      if File.exist?(full_path)
+        executable = File.executable?(full_path)
+        puts "  #{file}: ✅ #{executable ? '(executable)' : ''}"
+      else
+        puts "  #{file}: ❌ Missing"
+      end
+    end
+
+    # Test basic functionality
+    puts "\n🧪 Functionality Test:"
+    begin
+      test_result = RailsActiveMcp.execute('1 + 1')
+      puts "  Basic execution: #{test_result[:success] ? '✅' : '❌'}"
+    rescue StandardError => e
+      puts "  Basic execution: ❌ (#{e.message})"
     end
+
+    puts "\n🔗 Integration URLs:"
+    puts '  Documentation: https://github.com/goodpie/rails-active-mcp'
+    puts '  Issues: https://github.com/goodpie/rails-active-mcp/issues'
+    puts '  MCP Protocol: https://modelcontextprotocol.io'
   end
-end
+end

data/lib/rails_active_mcp/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RailsActiveMcp
-  VERSION = '0.1.7'
+  VERSION = '2.0.8'
 end

data/lib/rails_active_mcp.rb

@@ -5,18 +5,17 @@ require_relative 'rails_active_mcp/version'
 require_relative 'rails_active_mcp/configuration'
 require_relative 'rails_active_mcp/safety_checker'
 require_relative 'rails_active_mcp/console_executor'
-require_relative 'rails_active_mcp/mcp_server'
+
+# Load SDK server
+require_relative 'rails_active_mcp/sdk/server'
 
 # Load Engine for Rails integration
 require_relative 'rails_active_mcp/engine' if defined?(Rails)
 
 module RailsActiveMcp
   class Error < StandardError; end
-
   class SafetyError < Error; end
-
   class ExecutionError < Error; end
-
   class TimeoutError < Error; end
 
   class << self
@@ -42,16 +41,11 @@ module RailsActiveMcp
       ConsoleExecutor.new(config).execute(code, **options)
     end
 
-    # Access to MCP server instance
-    def server
-      @server ||= McpServer.new
-    end
-
-    # Logger accessor - configured by railtie or defaults to stderr
+    # Logger accessor - configured by engine or defaults to stderr
     attr_accessor :logger
 
     def logger
-      @logger ||= Logger.new(STDERR).tap do |logger|
+      @logger ||= Logger.new($stderr).tap do |logger|
         logger.level = Logger::INFO
         logger.formatter = proc do |severity, datetime, progname, msg|
           "[#{datetime}] #{severity} -- RailsActiveMcp: #{msg}\n"