rails-active-mcp 2.0.7 → 2.0.12

data/lib/generators/rails_active_mcp/install/templates/rails-active-mcp-wrapper

@@ -0,0 +1,94 @@
+#!/usr/bin/env bash
+
+# Rails Active MCP Wrapper Script
+# This script ensures Rails Active MCP works reliably across different Ruby version managers
+
+# Function to detect Ruby version manager
+detect_ruby_manager() {
+    if command -v asdf >/dev/null 2>&1 && [ -f .tool-versions ]; then
+        echo "asdf"
+    elif command -v rbenv >/dev/null 2>&1 && [ -f .ruby-version ]; then
+        echo "rbenv"
+    elif command -v rvm >/dev/null 2>&1 && [ -f .rvmrc ]; then
+        echo "rvm"
+    else
+        echo "system"
+    fi
+}
+
+# Function to setup environment for different Ruby managers
+setup_ruby_environment() {
+    local manager=$1
+
+    case $manager in
+        "asdf")
+            if [ -n "$ASDF_DIR" ] && [ -f "$ASDF_DIR/asdf.sh" ]; then
+                source "$ASDF_DIR/asdf.sh"
+            elif [ -f "$HOME/.asdf/asdf.sh" ]; then
+                export ASDF_DIR="$HOME/.asdf"
+                source "$HOME/.asdf/asdf.sh"
+            fi
+            ;;
+        "rbenv")
+            if [ -n "$RBENV_ROOT" ] && [ -f "$RBENV_ROOT/bin/rbenv" ]; then
+                export PATH="$RBENV_ROOT/bin:$PATH"
+                eval "$(rbenv init -)"
+            elif [ -f "$HOME/.rbenv/bin/rbenv" ]; then
+                export PATH="$HOME/.rbenv/bin:$PATH"
+                eval "$(rbenv init -)"
+            fi
+            ;;
+        "rvm")
+            if [ -f "$HOME/.rvm/scripts/rvm" ]; then
+                source "$HOME/.rvm/scripts/rvm"
+            fi
+            ;;
+    esac
+}
+
+# Get the directory where this script is located
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(dirname "$SCRIPT_DIR")"
+
+# Change to the Rails project directory
+cd "$PROJECT_ROOT" || {
+    echo "Error: Cannot change to project root directory: $PROJECT_ROOT" >&2
+    exit 1
+}
+
+# Detect and setup Ruby environment
+RUBY_MANAGER=$(detect_ruby_manager)
+setup_ruby_environment "$RUBY_MANAGER"
+
+# Verify we have the necessary files
+if [ ! -f "Gemfile" ]; then
+    echo "Error: Gemfile not found in $PROJECT_ROOT" >&2
+    echo "Please ensure you're running this from a Rails application root" >&2
+    exit 1
+fi
+
+if [ ! -f "config/environment.rb" ]; then
+    echo "Warning: config/environment.rb not found. This may not be a Rails application." >&2
+fi
+
+# Set default environment if not specified
+export RAILS_ENV="${RAILS_ENV:-development}"
+
+# Ensure we have the rails-active-mcp gem available
+if ! bundle list | grep -q "rails-active-mcp"; then
+    echo "Error: rails-active-mcp gem not found in bundle" >&2
+    echo "Please run: bundle install" >&2
+    exit 1
+fi
+
+# Execute the Rails Active MCP server
+# Try bundle exec first, then fall back to direct execution
+if bundle exec rails-active-mcp-server "$@" 2>/dev/null; then
+    exit 0
+elif command -v rails-active-mcp-server >/dev/null 2>&1; then
+    exec rails-active-mcp-server "$@"
+else
+    echo "Error: Cannot find rails-active-mcp-server executable" >&2
+    echo "Please ensure the rails-active-mcp gem is properly installed" >&2
+    exit 1
+fi

data/lib/rails_active_mcp/configuration.rb

@@ -8,7 +8,7 @@ module RailsActiveMcp
     attr_accessor :allowed_commands, :command_timeout, :enable_logging, :log_level
 
     # Safety and execution options
-    attr_accessor :safe_mode, :default_timeout, :max_results, :log_executions, :audit_file
+    attr_accessor :safe_mode, :max_results, :log_executions, :audit_file, :enabled
     attr_accessor :custom_safety_patterns, :allowed_models
 
     def initialize
@@ -24,12 +24,12 @@ module RailsActiveMcp
 
       # Safety and execution defaults
       @safe_mode = true
-      @default_timeout = 30
       @max_results = 100
       @log_executions = false
       @audit_file = nil
       @custom_safety_patterns = []
       @allowed_models = []
+      @enabled = true
     end
 
     def model_allowed?(model_name)
@@ -44,15 +44,55 @@ module RailsActiveMcp
         [true, false].include?(enable_logging) &&
         %i[debug info warn error].include?(log_level) &&
         [true, false].include?(safe_mode) &&
-        default_timeout.is_a?(Numeric) && default_timeout > 0 &&
         max_results.is_a?(Numeric) && max_results > 0 &&
         [true, false].include?(log_executions) &&
         custom_safety_patterns.is_a?(Array) &&
-        allowed_models.is_a?(Array)
+        allowed_models.is_a?(Array) &&
+        [true, false].include?(enabled)
+    end
+
+    def validate?
+      raise ArgumentError, 'allowed_commands must be an array' unless allowed_commands.is_a?(Array)
+
+      raise ArgumentError, 'command_timeout must be positive' unless command_timeout.is_a?(Numeric) && command_timeout > 0
+
+      raise ArgumentError, 'log_level must be one of: debug, info, warn, error' unless %i[debug info warn error].include?(log_level)
+
+      raise ArgumentError, 'safe_mode must be a boolean' unless [true, false].include?(safe_mode)
+
+      raise ArgumentError, 'max_results must be positive' unless max_results.is_a?(Numeric) && max_results > 0
+
+      raise ArgumentError, 'enabled must be a boolean' unless [true, false].include?(enabled)
+
+      true
     end
 
     def reset!
       initialize
     end
+
+    # Environment-specific configuration presets
+    def production_mode!
+      @safe_mode = true
+      @log_level = :warn
+      @command_timeout = 15
+      @max_results = 50
+      @log_executions = true
+    end
+
+    def development_mode!
+      @safe_mode = false
+      @log_level = :debug
+      @command_timeout = 60
+      @max_results = 200
+      @log_executions = false
+    end
+
+    def test_mode!
+      @safe_mode = true
+      @log_level = :error
+      @command_timeout = 30
+      @log_executions = false
+    end
   end
 end

data/lib/rails_active_mcp/console_executor.rb

@@ -4,9 +4,11 @@ require 'concurrent-ruby'
 require 'rails'
 
 module RailsActiveMcp
+  # rubocop:disable Metrics/ClassLength
   class ConsoleExecutor
     # Thread-safe execution errors
     class ExecutionError < StandardError; end
+
     class ThreadSafetyError < StandardError; end
 
     def initialize(config)
@@ -17,13 +19,13 @@ module RailsActiveMcp
     end
 
     def execute(code, timeout: nil, safe_mode: nil, capture_output: true)
-      timeout ||= @config.default_timeout
+      timeout ||= @config.command_timeout
       safe_mode = @config.safe_mode if safe_mode.nil?
 
       # Pre-execution safety check
       if safe_mode
         safety_analysis = @safety_checker.analyze(code)
-        raise SafetyError, "Code failed safety check: #{safety_analysis[:summary]}" unless safety_analysis[:safe]
+        raise RailsActiveMcp::SafetyError, "Code failed safety check: #{safety_analysis[:summary]}" unless safety_analysis[:safe]
       end
 
       # Log execution if enabled
@@ -34,41 +36,59 @@ module RailsActiveMcp
 
       # Post-execution processing
       process_result(result)
+    rescue RailsActiveMcp::SafetyError => e
+      {
+        success: false,
+        error: e.message,
+        error_class: 'SafetyError',
+        code: code
+      }
     end
 
     def execute_safe_query(model:, method:, args: [], limit: nil)
       limit ||= @config.max_results
 
-      # Validate model access
-      raise SafetyError, "Access to model '#{model}' is not allowed" unless @config.model_allowed?(model)
+      begin
+        # Validate model access
+        raise RailsActiveMcp::SafetyError, "Access to model '#{model}' is not allowed" unless @config.model_allowed?(model)
 
-      # Validate method safety
-      raise SafetyError, "Method '#{method}' is not allowed for safe queries" unless safe_query_method?(method)
+        # Validate method safety
+        raise RailsActiveMcp::SafetyError, "Method '#{method}' is not allowed for safe queries" unless safe_query_method?(method)
 
-      # Execute with proper Rails executor and connection management
-      execute_with_rails_executor_and_connection do
-        model_class = model.to_s.constantize
+        # Execute with proper Rails executor and connection management
+        execute_with_rails_executor_and_connection do
+          model_class = model.to_s.constantize
 
-        # Build and execute query
-        query = if args.empty?
-                  model_class.public_send(method)
-                else
-                  model_class.public_send(method, *args)
-                end
+          # Build and execute query
+          query = if args.empty?
+                    model_class.public_send(method)
+                  else
+                    model_class.public_send(method, *args)
+                  end
 
-        # Apply limit for enumerable results
-        query = query.limit(limit) if query.respond_to?(:limit) && !count_method?(method)
+          # Apply limit for enumerable results
+          query = query.limit(limit) if query.respond_to?(:limit) && !count_method?(method)
 
-        result = execute_query_with_timeout(query)
+          result = execute_query_with_timeout(query)
 
+          {
+            success: true,
+            model: model,
+            method: method,
+            args: args,
+            result: serialize_result(result),
+            count: calculate_count(result),
+            executed_at: Time.now
+          }
+        end
+      rescue RailsActiveMcp::SafetyError => e
         {
-          success: true,
+          success: false,
+          error: e.message,
+          error_class: 'SafetyError',
           model: model,
           method: method,
-          args: args,
-          result: serialize_result(result),
-          count: calculate_count(result),
-          executed_at: Time.now
+          args: args
         }
       rescue StandardError => e
         log_error(e, { model: model, method: method, args: args })
@@ -83,6 +103,86 @@ module RailsActiveMcp
       end
     end
 
+    def get_model_info(model_name)
+      # Validate model access
+      raise RailsActiveMcp::SafetyError, "Access to model '#{model_name}' is not allowed" unless @config.model_allowed?(model_name)
+
+      begin
+        model_class = model_name.to_s.constantize
+
+        # Ensure it's an ActiveRecord model
+        unless model_class.respond_to?(:columns) && model_class.respond_to?(:reflect_on_all_associations)
+          raise RailsActiveMcp::SafetyError, "#{model_name} is not a valid ActiveRecord model"
+        end
+
+        # Extract model information
+        columns_info = build_model_columns(model_class)
+
+        associations_info = build_model_reflections(model_class)
+
+        validators_info = build_model_validator_info(model_class)
+
+        {
+          success: true,
+          model_name: model_name,
+          table_name: model_class.table_name,
+          primary_key: model_class.primary_key,
+          columns: columns_info,
+          associations: associations_info,
+          validators: validators_info,
+          extracted_at: Time.now
+        }
+      rescue NameError => e
+        {
+          success: false,
+          error: "Model '#{model_name}' not found: #{e.message}",
+          error_class: 'NameError',
+          model_name: model_name
+        }
+      rescue StandardError => e
+        {
+          success: false,
+          error: e.message,
+          error_class: e.class.name,
+          model_name: model_name
+        }
+      end
+    end
+
+    def build_model_reflections(model_class)
+      model_class.reflect_on_all_associations.map do |association|
+        {
+          name: association.name,
+          type: association.macro,
+          class_name: association.class_name
+        }
+      end
+    end
+
+    def build_model_columns(model_class)
+      model_class.columns.map do |column|
+        {
+          name: column.name,
+          type: column.type,
+          primary: column.name == model_class.primary_key
+        }
+      end
+    end
+
+    def build_model_validator_info(model_class)
+      if model_class.respond_to?(:validators)
+        model_class.validators.map do |validator|
+          {
+            type: validator.class.name,
+            attributes: validator.attributes,
+            options: validator.options
+          }
+        end
+      else
+        []
+      end
+    end
+
     def dry_run(code)
       # Analyze without executing
       safety_analysis = @safety_checker.analyze(code)
@@ -98,6 +198,21 @@ module RailsActiveMcp
 
     private
 
+    def safe_query_method?(method)
+      # Define safe read-only methods for database queries
+      safe_methods = %w[
+        find find_by find_by! first last
+        where select limit offset order
+        count size length exists? empty?
+        pluck ids maximum minimum average sum
+        group having joins includes
+        readonly distinct unscope
+        all none
+      ]
+
+      safe_methods.include?(method.to_s)
+    end
+
     def execute_with_rails_executor(code, timeout, capture_output)
       if defined?(Rails) && Rails.application
         # Handle development mode reloading if needed
@@ -129,20 +244,15 @@ module RailsActiveMcp
 
     # Manage ActiveRecord connection pool properly
     def execute_with_connection_pool(code, timeout, capture_output)
-      if defined?(ActiveRecord::Base)
-        ActiveRecord::Base.connection_pool.with_connection do
+      if defined?(::ActiveRecord::Base)
+        ::ActiveRecord::Base.connection_pool.with_connection do
           execute_with_timeout(code, timeout, capture_output)
         end
       else
         execute_with_timeout(code, timeout, capture_output)
       end
     ensure
-      # Clean up connections to prevent pool exhaustion
-      if defined?(ActiveRecord::Base)
-        ActiveRecord::Base.clear_active_connections!
-        # Probabilistic garbage collection for long-running processes
-        GC.start if rand(100) < 5
-      end
+      RailsActiveMcp::GarbageCollectionUtils.probalistic_clean!
     end
 
     # Helper method for safe queries with proper Rails executor and connection management
@@ -151,8 +261,8 @@ module RailsActiveMcp
         if defined?(ActiveSupport::Dependencies) && ActiveSupport::Dependencies.respond_to?(:interlock)
           ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
             Rails.application.executor.wrap do
-              if defined?(ActiveRecord::Base)
-                ActiveRecord::Base.connection_pool.with_connection(&block)
+              if defined?(::ActiveRecord::Base)
+                ::ActiveRecord::Base.connection_pool.with_connection(&block)
               else
                 yield
               end
@@ -160,8 +270,8 @@ module RailsActiveMcp
           end
         else
           Rails.application.executor.wrap do
-            if defined?(ActiveRecord::Base)
-              ActiveRecord::Base.connection_pool.with_connection(&block)
+            if defined?(::ActiveRecord::Base)
+              ::ActiveRecord::Base.connection_pool.with_connection(&block)
             else
               yield
             end
@@ -171,12 +281,7 @@ module RailsActiveMcp
         yield
       end
     ensure
-      # Clean up connections
-      if defined?(ActiveRecord::Base)
-        ActiveRecord::Base.clear_active_connections!
-        # Probabilistic garbage collection for long-running processes
-        GC.start if rand(100) < 5
-      end
+      RailsActiveMcp::GarbageCollectionUtils.probalistic_clean!
     end
 
     def execute_with_timeout(code, timeout, capture_output)
@@ -208,32 +313,39 @@ module RailsActiveMcp
 
           # Execute code
           start_time = Time.now
-          return_value = binding_context.eval(code)
-          execution_time = Time.now - start_time
-
+          begin
+            return_value = binding_context.eval(code)
+          rescue SyntaxError => e
+            return {
+              success: false,
+              error: "Syntax Error: #{e.message}",
+              error_class: 'SyntaxError',
+              backtrace: e.backtrace&.first(10),
+              code: code,
+              output: nil
+            }
+          end
           output = captured_output.string
           errors = captured_errors.string
 
           # Combine output and errors for comprehensive result
           combined_output = [output, errors].reject(&:empty?).join("\n")
-
           {
             success: true,
             return_value: return_value,
             output: combined_output,
             return_value_string: safe_inspect(return_value),
-            execution_time: execution_time,
+            execution_time: Time.now - start_time,
             code: code
           }
         rescue StandardError => e
-          execution_time = Time.now - start_time if defined?(start_time)
+          execution_time = Time.now - start_time if start_time.present?
           errors = captured_errors.string
-
           {
             success: false,
-            error: e.message,
+            error: e&.message || 'Unknown error',
             error_class: e.class.name,
-            backtrace: e.backtrace&.first(10),
+            backtrace: e&.backtrace&.first(10) || [],
             execution_time: execution_time,
             code: code,
             stderr: errors.empty? ? nil : errors
@@ -260,7 +372,7 @@ module RailsActiveMcp
         code: code
       }
     rescue StandardError => e
-      execution_time = Time.now - start_time if defined?(start_time)
+      execution_time = Time.now - start_time if start_time.present?
 
       {
         success: false,
@@ -273,8 +385,8 @@ module RailsActiveMcp
     end
 
     def execute_query_with_timeout(query)
-      Timeout.timeout(@config.default_timeout) do
-        if query.is_a?(ActiveRecord::Relation)
+      Timeout.timeout(@config.command_timeout) do
+        if defined?(::ActiveRecord::Relation) && query.is_a?(::ActiveRecord::Relation)
           query.to_a
         else
           query
@@ -315,15 +427,15 @@ module RailsActiveMcp
 
         # Add common console helpers (thread-safe)
         def sql(query)
-          raise NoMethodError, 'ActiveRecord not available' unless defined?(ActiveRecord::Base)
+          raise NoMethodError, 'ActiveRecord not available' unless defined?(::ActiveRecord::Base)
 
-          ActiveRecord::Base.connection.select_all(query).to_a
+          ::ActiveRecord::Base.connection.select_all(query).to_a
         end
 
         def schema(table_name)
-          raise NoMethodError, 'ActiveRecord not available' unless defined?(ActiveRecord::Base)
+          raise NoMethodError, 'ActiveRecord not available' unless defined?(::ActiveRecord::Base)
 
-          ActiveRecord::Base.connection.columns(table_name)
+          ::ActiveRecord::Base.connection.columns(table_name)
         end
       end
 
@@ -336,40 +448,28 @@ module RailsActiveMcp
       create_thread_safe_console_binding
     end
 
-    def safe_query_method?(method)
-      safe_methods = %w[
-        find find_by find_each find_in_batches
-        where all first last take
-        count sum average maximum minimum size length
-        pluck ids exists? empty? any? many?
-        select distinct group order limit offset
-        includes joins left_joins preload eager_load
-        to_a to_sql explain inspect as_json to_json
-        attributes attribute_names column_names
-        model_name table_name primary_key
-      ]
-      safe_methods.include?(method.to_s)
-    end
-
     def count_method?(method)
       %w[count sum average maximum minimum size length].include?(method.to_s)
     end
 
     def serialize_result(result)
       case result
-      when ActiveRecord::Base
-        result.attributes.merge(_model_class: result.class.name)
       when Array
         limited_result = result.first(@config.max_results)
         limited_result.map { |item| serialize_result(item) }
-      when ActiveRecord::Relation
-        serialize_result(result.to_a)
       when Hash
         result
       when Numeric, String, TrueClass, FalseClass, NilClass
         result
       else
-        safe_inspect(result)
+        # Handle ActiveRecord objects if available
+        if defined?(::ActiveRecord::Base) && result.is_a?(::ActiveRecord::Base)
+          result.attributes.merge(_model_class: result.class.name)
+        elsif defined?(::ActiveRecord::Relation) && result.is_a?(::ActiveRecord::Relation)
+          serialize_result(result.to_a)
+        else
+          safe_inspect(result)
+        end
       end
     end
 
@@ -377,12 +477,15 @@ module RailsActiveMcp
       case result
       when Array
         result.size
-      when ActiveRecord::Relation
-        result.count
       when Numeric
         1
       else
-        1
+        # Handle ActiveRecord::Relation if available
+        if defined?(::ActiveRecord::Relation) && result.is_a?(::ActiveRecord::Relation)
+          result.count
+        else
+          1
+        end
       end
     end
 
@@ -430,9 +533,7 @@ module RailsActiveMcp
         end
       end
 
-      unless safety_analysis[:read_only]
-        recommendations << 'Consider using the safe_query tool for read-only operations'
-      end
+      recommendations << 'Consider using the safe_query tool for read-only operations' unless safety_analysis[:read_only]
 
       recommendations
     end
@@ -499,4 +600,5 @@ module RailsActiveMcp
       RailsActiveMcp.logger.warn "Failed to reload in development: #{e.message}" if defined?(RailsActiveMcp.logger)
     end
   end
+  # rubocop:enable Metrics/ClassLength
 end

data/lib/rails_active_mcp/engine.rb

@@ -25,9 +25,9 @@ module RailsActiveMcp
                                 end
                               else
                                 # Fallback to our own logger if Rails logger is not available
-                                Logger.new(STDERR).tap do |logger|
+                                Logger.new($stderr).tap do |logger|
                                   logger.level = Rails.env.production? ? Logger::WARN : Logger::INFO
-                                  logger.formatter = proc do |severity, datetime, progname, msg|
+                                  logger.formatter = proc do |severity, datetime, _progname, msg|
                                     "[#{datetime}] #{severity} -- RailsActiveMcp: #{msg}\n"
                                   end
                                 end

data/lib/rails_active_mcp/garbage_collection_utils.rb

@@ -0,0 +1,13 @@
+module RailsActiveMcp
+  class GarbageCollectionUtils
+    # Probabilistic garbage collection for long-running processes
+    # Not sure if this is the best approach but it's a quick common pattern that works
+    def self.probalistic_clean!
+      return unless defined?(::ActiveRecord::Base)
+
+      # Clean up connections to prevent pool exhaustion
+      ::ActiveRecord::Base.clear_active_connections!
+      GC.start if rand(100) < 5
+    end
+  end
+end

data/lib/rails_active_mcp/safety_checker.rb

@@ -54,7 +54,6 @@ module RailsActiveMcp
     end
 
     def safe?(code)
-
       analysis = analyze(code)
       analysis[:safe]
     end
@@ -85,8 +84,21 @@ module RailsActiveMcp
       critical_violations = violations.select { |v| v[:severity] == :critical }
       high_violations = violations.select { |v| v[:severity] == :high }
 
-      safe = (@config.safe_mode && read_only && critical_violations.empty? && high_violations.empty?) ||
-             (!@config.safe_mode && critical_violations.empty?)
+      # In safe mode: allow code with no critical/high violations
+      # For database operations, also require read_only patterns
+      # For simple Ruby code (no database patterns), allow if no dangerous violations
+      if @config.safe_mode
+        has_database_operations = code.match?(/\b(User|Model|ActiveRecord|\.where|\.find|\.create|\.update|\.delete)\b/)
+        safe = if has_database_operations
+                 read_only && critical_violations.empty? && high_violations.empty?
+               else
+                 # Simple Ruby code - just check for dangerous patterns
+                 critical_violations.empty? && high_violations.empty?
+               end
+      else
+        # Not in safe mode - only block critical violations
+        safe = critical_violations.empty?
+      end
 
       {
         safe: safe,
@@ -136,10 +148,8 @@ module RailsActiveMcp
         read_only ? 'Code appears safe and read-only' : 'Code appears safe'
       else
         severity_counts = violations.group_by { |v| v[:severity] }.transform_values(&:count)
-        parts = []
-
-        severity_counts.each do |severity, count|
-          parts << "#{count} #{severity} violation#{'s' if count > 1}"
+        parts = severity_counts.map do |severity, count|
+          "#{count} #{severity} violation#{'s' if count > 1}"
         end
 
         "Found #{parts.join(', ')}"