mcp_on_ruby 0.1.0 → 0.3.0

data/lib/ruby_mcp/storage/active_record.rb

@@ -0,0 +1,414 @@
+# frozen_string_literal: true
+
+begin
+  require 'active_record'
+rescue LoadError
+  # ActiveRecord is an optional dependency
+  # This error will be handled by the storage factory
+end
+
+require 'securerandom'
+require 'json'
+require_relative 'base'
+
+module RubyMCP
+  module Storage
+    # ActiveRecord-based storage implementation for RubyMCP
+    class ActiveRecord < Base
+      # Initialize ActiveRecord storage with options
+      # @param options [Hash] Options for ActiveRecord storage
+      # @option options [Hash] :connection ActiveRecord connection configuration
+      # @option options [String] :table_prefix Prefix for table names (default: 'mcp_')
+      def initialize(options = {})
+        super
+        @table_prefix = options[:table_prefix] || 'mcp_'
+        @logger = options[:logger] || RubyMCP.logger
+
+        # Set up ActiveRecord connection if provided
+        ::ActiveRecord::Base.establish_connection(options[:connection]) if options[:connection].is_a?(Hash)
+
+        setup_models
+        ensure_tables_exist
+      end
+
+      # Create a new context
+      # @param context [RubyMCP::Models::Context] Context to create
+      # @return [RubyMCP::Models::Context] Created context
+      def create_context(context)
+        # Check if context already exists
+        if @context_model.exists?(external_id: context.id)
+          raise RubyMCP::Errors::ContextError, "Context already exists: #{context.id}"
+        end
+
+        # Create the context record
+        ar_context = @context_model.create!(
+          external_id: context.id,
+          metadata: JSON.generate(context.metadata || {}),
+          created_at: context.created_at,
+          updated_at: context.updated_at
+        )
+
+        # Create message records if any
+        context.messages.each do |message|
+          create_message_record(ar_context.id, message)
+        end
+
+        # Create content records if any
+        context.content_map.each do |content_id, content_data|
+          create_content_record(ar_context.id, content_id, content_data)
+        end
+
+        context
+      end
+
+      # Get a context by ID
+      # @param context_id [String] ID of the context to get
+      # @return [RubyMCP::Models::Context] Found context
+      # @raise [RubyMCP::Errors::ContextError] If context not found
+      def get_context(context_id)
+        ar_context = @context_model.find_by(external_id: context_id)
+        raise RubyMCP::Errors::ContextError, "Context not found: #{context_id}" unless ar_context
+
+        # Parse metadata
+        metadata = begin
+          json = JSON.parse(ar_context.metadata)
+          symbolize_keys(json)
+        rescue JSON::ParserError => e
+          @logger.warn("Error parsing context metadata: #{e.message}")
+          {}
+        end
+
+        # Create a new context object
+        context = RubyMCP::Models::Context.new(
+          id: ar_context.external_id,
+          metadata: metadata
+        )
+
+        # Set timestamps
+        context.instance_variable_set(:@created_at, ar_context.created_at)
+        context.instance_variable_set(:@updated_at, ar_context.updated_at)
+
+        # Load messages
+        ar_messages = @message_model.where(context_id: ar_context.id).order(:created_at)
+        ar_messages.each do |ar_message|
+          # Parse message metadata
+          msg_metadata = begin
+            json = JSON.parse(ar_message.metadata)
+            symbolize_keys(json)
+          rescue JSON::ParserError => e
+            @logger.warn("Error parsing message metadata: #{e.message}")
+            {}
+          end
+
+          message = RubyMCP::Models::Message.new(
+            id: ar_message.external_id,
+            role: ar_message.role,
+            content: ar_message.content,
+            metadata: msg_metadata
+          )
+          message.instance_variable_set(:@created_at, ar_message.created_at)
+          context.instance_variable_get(:@messages) << message
+        end
+
+        # Load content
+        ar_contents = @content_model.where(context_id: ar_context.id)
+        ar_contents.each do |ar_content|
+          content_data = if ar_content.content_type == 'json'
+                           begin
+                             json = JSON.parse(ar_content.data_json)
+                             symbolize_keys(json)
+                           rescue JSON::ParserError => e
+                             @logger.warn("Error parsing content JSON: #{e.message}")
+                             {}
+                           end
+                         else
+                           ar_content.data_binary
+                         end
+          context.instance_variable_get(:@content_map)[ar_content.external_id] = content_data
+        end
+
+        context
+      end
+
+      # Update a context
+      # @param context [RubyMCP::Models::Context] Context to update
+      # @return [RubyMCP::Models::Context] Updated context
+      # @raise [RubyMCP::Errors::ContextError] If context not found
+      def update_context(context)
+        ar_context = @context_model.find_by(external_id: context.id)
+        raise RubyMCP::Errors::ContextError, "Context not found: #{context.id}" unless ar_context
+
+        # Update the context record
+        ar_context.update!(
+          metadata: JSON.generate(context.metadata || {}),
+          updated_at: context.updated_at
+        )
+
+        # We don't update messages or content here as they are added separately
+        context
+      end
+
+      # Delete a context
+      # @param context_id [String] ID of the context to delete
+      # @return [Boolean] True if deleted
+      # @raise [RubyMCP::Errors::ContextError] If context not found
+      def delete_context(context_id)
+        ar_context = @context_model.find_by(external_id: context_id)
+        raise RubyMCP::Errors::ContextError, "Context not found: #{context_id}" unless ar_context
+
+        # Delete all related records manually since we can't rely on cascading in tests
+        @message_model.where(context_id: ar_context.id).delete_all
+        @content_model.where(context_id: ar_context.id).delete_all
+        ar_context.destroy
+
+        true
+      end
+
+      # List contexts with pagination
+      # @param limit [Integer] Maximum number of contexts to return
+      # @param offset [Integer] Number of contexts to skip
+      # @return [Array<RubyMCP::Models::Context>] List of contexts
+      def list_contexts(limit: 100, offset: 0)
+        ar_contexts = @context_model.order(updated_at: :desc).limit(limit).offset(offset)
+
+        ar_contexts.map do |ar_context|
+          get_context(ar_context.external_id)
+        end
+      end
+
+      # List all content for a context
+      # @param context_id [String] ID of the context
+      # @return [Hash] Map of content_id to content data
+      # @raise [RubyMCP::Errors::ContextError] If context not found
+      def list_content(context_id)
+        ar_context = @context_model.find_by(external_id: context_id)
+        raise RubyMCP::Errors::ContextError, "Context not found: #{context_id}" unless ar_context
+
+        content_map = {}
+        ar_contents = @content_model.where(context_id: ar_context.id)
+
+        ar_contents.each do |ar_content|
+          content_data = if ar_content.content_type == 'json'
+                           begin
+                             json = JSON.parse(ar_content.data_json)
+                             symbolize_keys(json)
+                           rescue JSON::ParserError => e
+                             raise RubyMCP::Errors::ContentError,
+                                   "Invalid JSON in content #{ar_content.external_id}: #{e.message}"
+                           end
+                         else
+                           ar_content.data_binary
+                         end
+          content_map[ar_content.external_id] = content_data
+        end
+
+        content_map
+      end
+
+      # Add a message to a context
+      # @param context_id [String] ID of the context
+      # @param message [RubyMCP::Models::Message] Message to add
+      # @return [RubyMCP::Models::Message] Added message
+      # @raise [RubyMCP::Errors::ContextError] If context not found
+      def add_message(context_id, message)
+        ar_context = @context_model.find_by(external_id: context_id)
+        raise RubyMCP::Errors::ContextError, "Context not found: #{context_id}" unless ar_context
+
+        # Create the message record
+        create_message_record(ar_context.id, message)
+
+        # Update the context's updated_at timestamp
+        ar_context.touch
+
+        message
+      end
+
+      # Add content to a context
+      # @param context_id [String] ID of the context
+      # @param content_id [String] ID of the content
+      # @param content_data [Object] Content data
+      # @return [String] Content ID
+      # @raise [RubyMCP::Errors::ContextError] If context not found
+      def add_content(context_id, content_id, content_data)
+        ar_context = @context_model.find_by(external_id: context_id)
+        raise RubyMCP::Errors::ContextError, "Context not found: #{context_id}" unless ar_context
+
+        # Create the content record
+        create_content_record(ar_context.id, content_id, content_data)
+
+        # Update the context's updated_at timestamp
+        ar_context.touch
+
+        content_id
+      end
+
+      # Get content from a context
+      # @param context_id [String] ID of the context
+      # @param content_id [String] ID of the content
+      # @return [Object] Content data
+      # @raise [RubyMCP::Errors::ContextError] If context not found
+      # @raise [RubyMCP::Errors::ContentError] If content not found
+      def get_content(context_id, content_id)
+        ar_context = @context_model.find_by(external_id: context_id)
+        raise RubyMCP::Errors::ContextError, "Context not found: #{context_id}" unless ar_context
+
+        ar_content = @content_model.find_by(context_id: ar_context.id, external_id: content_id)
+        raise RubyMCP::Errors::ContentError, "Content not found: #{content_id}" unless ar_content
+
+        if ar_content.content_type == 'json'
+          begin
+            json = JSON.parse(ar_content.data_json)
+            symbolize_keys(json)
+          rescue JSON::ParserError => e
+            raise RubyMCP::Errors::ContentError, "Invalid JSON in content #{content_id}: #{e.message}"
+          end
+        else
+          ar_content.data_binary
+        end
+      end
+
+      private
+
+      # Setup model classes
+      def setup_models
+        prefix = @table_prefix
+
+        # Context model
+        @context_model = Class.new(::ActiveRecord::Base) do
+          self.table_name = "#{prefix}contexts"
+        end
+        Object.const_set("MCPContext#{SecureRandom.hex(4)}", @context_model)
+
+        # Message model
+        @message_model = Class.new(::ActiveRecord::Base) do
+          self.table_name = "#{prefix}messages"
+        end
+        Object.const_set("MCPMessage#{SecureRandom.hex(4)}", @message_model)
+
+        # Content model
+        @content_model = Class.new(::ActiveRecord::Base) do
+          self.table_name = "#{prefix}contents"
+        end
+        Object.const_set("MCPContent#{SecureRandom.hex(4)}", @content_model)
+      end
+
+      # Ensure necessary tables exist
+      def ensure_tables_exist
+        connection = ::ActiveRecord::Base.connection
+
+        # Drop tables if they exist (for clean setup)
+        connection.drop_table("#{@table_prefix}contents") if connection.table_exists?("#{@table_prefix}contents")
+
+        connection.drop_table("#{@table_prefix}messages") if connection.table_exists?("#{@table_prefix}messages")
+
+        connection.drop_table("#{@table_prefix}contexts") if connection.table_exists?("#{@table_prefix}contexts")
+
+        # Create tables in proper order
+        create_contexts_table
+        create_messages_table
+        create_contents_table
+      end
+
+      # Check if a table exists
+      def table_exists?(table_name)
+        ::ActiveRecord::Base.connection.table_exists?(table_name)
+      end
+
+      # Create the contexts table
+      def create_contexts_table
+        connection = ::ActiveRecord::Base.connection
+        connection.create_table("#{@table_prefix}contexts") do |t|
+          t.string :external_id, null: false
+          t.text :metadata, default: '{}'
+          t.timestamps
+        end
+        connection.add_index("#{@table_prefix}contexts", :external_id, unique: true)
+        connection.add_index("#{@table_prefix}contexts", :updated_at)
+      end
+
+      # Create the messages table
+      def create_messages_table
+        connection = ::ActiveRecord::Base.connection
+        connection.create_table("#{@table_prefix}messages") do |t|
+          t.bigint :context_id, null: false
+          t.string :external_id, null: false
+          t.string :role, null: false
+          t.text :content, null: false
+          t.text :metadata, default: '{}'
+          t.timestamps
+        end
+        connection.add_index("#{@table_prefix}messages", %i[context_id external_id], unique: true)
+        connection.add_index("#{@table_prefix}messages", :context_id)
+      end
+
+      # Create the contents table
+      def create_contents_table
+        connection = ::ActiveRecord::Base.connection
+        connection.create_table("#{@table_prefix}contents") do |t|
+          t.bigint :context_id, null: false
+          t.string :external_id, null: false
+          t.binary :data_binary
+          t.text :data_json
+          t.string :content_type
+          t.timestamps
+        end
+        connection.add_index("#{@table_prefix}contents", %i[context_id external_id], unique: true)
+        connection.add_index("#{@table_prefix}contents", :context_id)
+      end
+
+      # Create a message record
+      def create_message_record(context_id, message)
+        @message_model.create!(
+          context_id: context_id,
+          external_id: message.id,
+          role: message.role,
+          content: message.content.to_s,
+          metadata: JSON.generate(message.metadata || {}),
+          created_at: message.created_at
+        )
+      end
+
+      # Create a content record
+      def create_content_record(context_id, content_id, content_data)
+        # Validate data type first
+        unless content_data.is_a?(String) || content_data.is_a?(Hash) ||
+               content_data.is_a?(Array) || content_data.is_a?(Numeric) ||
+               content_data.is_a?(TrueClass) || content_data.is_a?(FalseClass) ||
+               content_data.is_a?(NilClass)
+          raise RubyMCP::Errors::ContentError,
+                "Invalid data type: #{content_data.class.name}. Must be String, Hash, Array, Numeric, Boolean, or nil."
+        end
+
+        if content_data.is_a?(Hash) || content_data.is_a?(Array)
+          @content_model.create!(
+            context_id: context_id,
+            external_id: content_id,
+            data_json: JSON.generate(content_data),
+            content_type: 'json'
+          )
+        else
+          @content_model.create!(
+            context_id: context_id,
+            external_id: content_id,
+            data_binary: content_data.to_s,
+            content_type: 'binary'
+          )
+        end
+      end
+
+      # Helper method to symbolize keys in hashes (including nested ones)
+      def symbolize_keys(obj)
+        case obj
+        when Hash
+          obj.each_with_object({}) do |(key, value), result|
+            result[key.to_sym] = symbolize_keys(value)
+          end
+        when Array
+          obj.map { |item| symbolize_keys(item) }
+        else
+          obj
+        end
+      end
+    end
+  end
+end

data/lib/ruby_mcp/storage/error.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module RubyMCP
+  module Storage
+    # Error class for storage-related errors
+    class Error < StandardError; end
+  end
+end

data/lib/ruby_mcp/storage/redis.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+require 'redis'
+require 'json'
+require_relative 'error'
+
+module RubyMCP
+  module Storage
+    # Redis-based storage implementation for RubyMCP
+    class Redis < Base
+      def initialize(options = {})
+        super
+        @redis = if options[:connection].is_a?(::Redis)
+                   options[:connection]
+                 elsif options[:connection].is_a?(Hash)
+                   ::Redis.new(options[:connection])
+                 else
+                   ::Redis.new
+                 end
+        @namespace = options[:namespace] || 'ruby_mcp'
+        @ttl = options[:ttl] || 86_400 # Default 1 day TTL in seconds
+      end
+
+      # Context management
+      def create_context(context)
+        # Ensure context has an ID
+        context_id = context['id']
+        raise Error, 'Context must have an ID' unless context_id
+
+        # Check if context already exists
+        raise Error, "Context with ID '#{context_id}' already exists" if get_context(context_id)
+
+        # Store the context
+        store_context(context)
+
+        # Add to index with timestamp for ordering
+        @redis.zadd(
+          contexts_index_key,
+          Time.now.to_f,
+          context_id
+        )
+
+        # Return the created context
+        context
+      end
+
+      def get_context(context_id)
+        # Get the context data
+        context_data = @redis.get(context_key(context_id))
+        return nil unless context_data
+
+        # Parse the context
+        context = JSON.parse(context_data)
+
+        # Get messages if any
+        messages = get_messages(context_id)
+        context['messages'] = messages if messages.any?
+
+        context
+      end
+
+      def update_context(context)
+        context_id = context['id']
+
+        # Check if context exists
+        raise Error, "Context with ID '#{context_id}' does not exist" unless get_context(context_id)
+
+        # Store the updated context
+        store_context(context)
+
+        context
+      end
+
+      def delete_context(context_id)
+        # Remove from index
+        @redis.zrem(contexts_index_key, context_id)
+
+        # Delete context data
+        @redis.del(context_key(context_id))
+
+        # Delete messages
+        @redis.del(messages_key(context_id))
+
+        # Delete all content (using pattern matching)
+        content_pattern = key(['context', context_id, 'content', '*'])
+        content_keys = @redis.keys(content_pattern)
+        @redis.del(*content_keys) if content_keys.any?
+
+        true
+      end
+
+      def list_contexts(limit: 100, offset: 0)
+        # Get context IDs from the index, sorted by score (timestamp) descending
+        context_ids = @redis.zrevrange(contexts_index_key, offset, offset + limit - 1)
+
+        # Return early if no contexts
+        return [] if context_ids.empty?
+
+        # Get each context
+        context_ids.map { |id| get_context(id) }.compact
+      end
+
+      # Message handling
+      def add_message(context_id, message)
+        # Ensure context exists
+        raise Error, "Context with ID '#{context_id}' does not exist" unless get_context(context_id)
+
+        # Add message to the messages list
+        message_json = JSON.generate(message)
+        @redis.rpush(messages_key(context_id), message_json)
+
+        # Set TTL on messages key
+        @redis.expire(messages_key(context_id), @ttl)
+
+        message
+      end
+
+      # Content handling
+      def add_content(context_id, content_id, content_data)
+        # Ensure context exists
+        raise Error, "Context with ID '#{context_id}' does not exist" unless get_context(context_id)
+
+        # Store content
+        key = content_key(context_id, content_id)
+
+        # If content is binary or complex, use Base64 encoding
+        if content_data.is_a?(String) &&
+           (content_data.encoding == Encoding::BINARY || content_data.include?("\0"))
+          @redis.set(key, [content_data].pack('m0'))
+          @redis.set("#{key}:encoding", 'base64')
+        else
+          @redis.set(key, content_data)
+        end
+
+        # Set TTL
+        @redis.expire(key, @ttl)
+        @redis.expire("#{key}:encoding", @ttl) if @redis.exists?("#{key}:encoding")
+
+        content_data
+      end
+
+      def get_content(context_id, content_id)
+        key = content_key(context_id, content_id)
+        content = @redis.get(key)
+        return nil unless content
+
+        # Check if we need to decode from Base64
+        encoding = @redis.get("#{key}:encoding")
+        content = content.unpack1('m0') if encoding == 'base64'
+
+        content
+      end
+
+      private
+
+      def store_context(context)
+        context_id = context['id']
+
+        # Store the context
+        context_json = JSON.generate(context)
+        @redis.set(context_key(context_id), context_json)
+
+        # Set TTL
+        @redis.expire(context_key(context_id), @ttl)
+      end
+
+      def get_messages(context_id)
+        # Get all messages from the list
+        message_jsons = @redis.lrange(messages_key(context_id), 0, -1)
+
+        # Parse each message
+        message_jsons.map { |json| JSON.parse(json) }
+      end
+
+      # Helper methods for key generation
+      def key(parts)
+        [@namespace, *parts].join(':')
+      end
+
+      def context_key(context_id)
+        key(['context', context_id])
+      end
+
+      def messages_key(context_id)
+        key(['context', context_id, 'messages'])
+      end
+
+      def content_key(context_id, content_id)
+        key(['context', context_id, 'content', content_id])
+      end
+
+      def contexts_index_key
+        key(%w[contexts index])
+      end
+    end
+  end
+end

data/lib/ruby_mcp/storage_factory.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RubyMCP
+  class StorageFactory
+    def self.create(config)
+      # Support both old and new configuration interfaces
+      storage_config = if config.respond_to?(:storage_config)
+                         config.storage_config
+                       else
+                         config.storage
+                       end
+
+      case storage_config[:type]
+      when :memory, nil
+        Storage::Memory.new(storage_config)
+      when :redis
+        # Load Redis dependencies
+        begin
+          require 'redis'
+          require_relative 'storage/redis'
+        rescue LoadError
+          raise LoadError, "Redis storage requires the redis gem. Add it to your Gemfile with: gem 'redis', '~> 5.0'"
+        end
+
+        Storage::Redis.new(storage_config)
+      when :active_record
+        # Load ActiveRecord dependencies
+        begin
+          require 'active_record'
+          require_relative 'storage/active_record'
+        rescue LoadError
+          raise LoadError,
+                "ActiveRecord storage requires the activerecord gem. Add it to your Gemfile with:
+                gem 'activerecord', '~> 6.0'"
+        end
+
+        Storage::ActiveRecord.new(storage_config)
+      else
+        raise ArgumentError, "Unknown storage type: #{storage_config[:type]}"
+      end
+    end
+  end
+end

data/lib/ruby_mcp/version.rb

@@ -2,5 +2,5 @@
 
 # lib/ruby_mcp/version.rb
 module RubyMCP
-  VERSION = '0.1.0'
+  VERSION = '0.3.0'
 end