mcp_on_ruby 0.2.0 → 1.0.0

data/lib/ruby_mcp/storage/memory.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'base'
-
-module RubyMCP
-  module Storage
-    class Memory < Base
-      def initialize(options = {})
-        super
-        @contexts = {}
-        @contents = {}
-      end
-
-      def create_context(context)
-        @contexts[context.id] = context
-        context
-      end
-
-      def get_context(context_id)
-        context = @contexts[context_id]
-        raise RubyMCP::Errors::ContextError, "Context not found: #{context_id}" unless context
-
-        context
-      end
-
-      def update_context(context)
-        @contexts[context.id] = context
-        context
-      end
-
-      def delete_context(context_id)
-        context = get_context(context_id)
-        @contexts.delete(context_id)
-        @contents.delete(context_id)
-        context
-      end
-
-      def list_contexts(limit: 100, offset: 0)
-        @contexts.values
-                 .sort_by(&:updated_at)
-                 .reverse
-                 .slice(offset, limit) || []
-      end
-
-      def add_message(context_id, message)
-        context = get_context(context_id)
-        context.add_message(message)
-        update_context(context)
-        message
-      end
-
-      def add_content(context_id, content_id, content_data)
-        get_context(context_id)
-        @contents[context_id] ||= {}
-        @contents[context_id][content_id] = content_data
-        content_id
-      end
-
-      def get_content(context_id, content_id)
-        get_context(context_id)
-        contents = @contents[context_id] || {}
-        content = contents[content_id]
-        raise RubyMCP::Errors::ContentError, "Content not found: #{content_id}" unless content
-
-        content
-      end
-    end
-  end
-end

data/lib/ruby_mcp/storage/redis.rb

@@ -1,197 +0,0 @@
-# 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

@@ -1,32 +0,0 @@
-# lib/ruby_mcp/storage_factory.rb
-# 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 => e
-          raise LoadError, "Redis storage requires the redis gem. Add it to your Gemfile: #{e.message}"
-        end
-
-        Storage::Redis.new(storage_config)
-      else
-        raise ArgumentError, "Unknown storage type: #{storage_config[:type]}"
-      end
-    end
-  end
-end

data/lib/ruby_mcp/validator.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'schemas'
-
-module RubyMCP
-  class Validator
-    def self.validate_context(params)
-      validate(params, Schemas::ContextSchema)
-    end
-
-    def self.validate_message(params)
-      validate(params, Schemas::MessageSchema)
-    end
-
-    def self.validate_generate(params)
-      validate(params, Schemas::GenerateSchema)
-    end
-
-    def self.validate_content(params)
-      validate(params, Schemas::ContentSchema)
-    end
-
-    def self.validate(params, schema)
-      result = schema.call(params)
-
-      if result.success?
-        true
-      else
-        # This converts nested error hashes to strings properly
-        error_messages = format_errors(result.errors.to_h)
-        raise RubyMCP::Errors::ValidationError, "Validation failed: #{error_messages}"
-      end
-    end
-
-    def self.format_errors(errors, prefix = '')
-      errors.map do |key, value|
-        if value.is_a?(Hash)
-          format_errors(value, "#{prefix}#{key}.")
-        else
-          "#{prefix}#{key}: #{Array(value).join(', ')}"
-        end
-      end.join('; ')
-    end
-  end
-end

data/lib/ruby_mcp/version.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-# lib/ruby_mcp/version.rb
-module RubyMCP
-  VERSION = '0.2.0'
-end

data/lib/ruby_mcp.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-require 'faraday'
-require 'jwt'
-require 'json'
-
-require 'concurrent'
-require 'logger'
-require 'dry-schema'
-
-require_relative 'ruby_mcp/version'
-require_relative 'ruby_mcp/errors'
-require_relative 'ruby_mcp/configuration'
-
-require_relative 'ruby_mcp/models/context'
-require_relative 'ruby_mcp/models/message'
-require_relative 'ruby_mcp/models/engine'
-require_relative 'ruby_mcp/providers/base'
-require_relative 'ruby_mcp/storage/base'
-require_relative 'ruby_mcp/storage/memory'
-require_relative 'ruby_mcp/server/router'
-require_relative 'ruby_mcp/server/base_controller'
-require_relative 'ruby_mcp/server/app'
-require_relative 'ruby_mcp/server/controller'
-require_relative 'ruby_mcp/server/engines_controller'
-require_relative 'ruby_mcp/server/contexts_controller'
-require_relative 'ruby_mcp/server/messages_controller'
-require_relative 'ruby_mcp/server/content_controller'
-require_relative 'ruby_mcp/server/generate_controller'
-require_relative 'ruby_mcp/providers/openai'
-require_relative 'ruby_mcp/providers/anthropic'
-
-require_relative 'ruby_mcp/schemas'
-require_relative 'ruby_mcp/validator'
-
-require_relative 'ruby_mcp/client'
-
-module RubyMCP
-  class << self
-    attr_accessor :configuration
-    attr_writer :logger
-
-    def client
-      @client ||= begin
-        initialize_components unless @storage
-        Client.new(@storage)
-      end
-    end
-
-    def configure
-      self.configuration ||= Configuration.new
-      yield(configuration) if block_given?
-    end
-
-    def logger
-      @logger ||= Logger.new($stdout).tap do |log|
-        log.progname = name
-      end
-    end
-
-    private
-
-    def initialize_components
-      require_relative 'ruby_mcp/storage_factory'
-      @storage = StorageFactory.create(configuration)
-    end
-  end
-end