mcp_on_ruby 1.0.0 → 2.0.0

data/lib/mcp_on_ruby/generators/resource_generator.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails/generators'
-
-module McpOnRuby
-  module Generators
-    # Generator for creating MCP resources
-    class ResourceGenerator < Rails::Generators::NamedBase
-      source_root File.expand_path('templates', __dir__)
-
-      desc "Generate an MCP resource class"
-
-      argument :name, type: :string, desc: "Name of the resource"
-      
-      class_option :uri, type: :string, desc: "URI pattern for the resource"
-      class_option :description, type: :string, desc: "Description of the resource"
-      class_option :mime_type, type: :string, default: 'application/json', desc: "MIME type of the resource"
-      class_option :template, type: :boolean, default: false, desc: "Create a templated resource with parameters"
-
-      def create_resource_file
-        template 'resource.rb', File.join('app/resources', "#{file_name}_resource.rb")
-      end
-
-      def create_spec_file
-        return unless File.exist?(Rails.root.join('spec'))
-        
-        template 'resource_spec.rb', File.join('spec/resources', "#{file_name}_resource_spec.rb")
-      end
-
-      private
-
-      def resource_name
-        name.underscore
-      end
-
-      def resource_class_name
-        "#{name.camelize}Resource"
-      end
-
-      def resource_uri
-        options[:uri] || (options[:template] ? "#{resource_name}/{id}" : resource_name)
-      end
-
-      def resource_description
-        options[:description] || "#{name.humanize} resource"
-      end
-
-      def resource_mime_type
-        options[:mime_type]
-      end
-
-      def is_template?
-        options[:template] || resource_uri.include?('{')
-      end
-
-      def template_params
-        return [] unless is_template?
-        
-        resource_uri.scan(/\{([^}]+)\}/).flatten
-      end
-    end
-  end
-end

data/lib/mcp_on_ruby/generators/templates/README

@@ -1,31 +0,0 @@
-MCP on Ruby has been installed successfully!
-
-Next steps:
-
-1. Configure your MCP server in config/initializers/mcp_on_ruby.rb
-2. Create tools in app/tools/ using: rails generate mcp_on_ruby:tool ToolName
-3. Create resources in app/resources/ using: rails generate mcp_on_ruby:resource ResourceName
-4. Start your Rails server and access MCP at http://localhost:3000/mcp
-
-Example tool generation:
-  rails generate mcp_on_ruby:tool UserManager --description "Manage users"
-
-Example resource generation:
-  rails generate mcp_on_ruby:resource UserData --uri "users/{id}" --template
-
-Your MCP server will automatically discover and register all tools and resources
-in app/tools/ and app/resources/ that inherit from ApplicationTool and ApplicationResource.
-
-For manual setup, you can configure tools and resources in the initializer:
-
-McpOnRuby.mount_in_rails(Rails.application) do |server|
-  server.tool 'custom_tool', 'Description' do |args|
-    { result: 'Custom logic here' }
-  end
-  
-  server.resource 'custom_resource' do
-    { data: 'Custom resource data' }
-  end
-end
-
-Visit the documentation for more advanced usage patterns!

data/lib/mcp_on_ruby/generators/templates/application_resource.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-# Base class for all MCP resources in this application
-class ApplicationResource < McpOnRuby::Resource
-  # Common functionality for all resources can be added here
-  
-  # Example: Add common authorization logic
-  # def authorize(context)
-  #   # Check if user is authenticated
-  #   context[:authenticated] == true
-  # end
-  
-  # Example: Add caching for all resource reads
-  # def read(params = {}, context = {})
-  #   cache_key = "mcp:resource:#{uri}:#{params.to_json}"
-  #   Rails.cache.fetch(cache_key, expires_in: 5.minutes) do
-  #     super
-  #   end
-  # end
-end

data/lib/mcp_on_ruby/generators/templates/application_tool.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-# Base class for all MCP tools in this application
-class ApplicationTool < McpOnRuby::Tool
-  # Common functionality for all tools can be added here
-  
-  # Example: Add common authorization logic
-  # def authorize(context)
-  #   # Check if user is authenticated
-  #   context[:authenticated] == true
-  # end
-  
-  # Example: Add logging for all tool executions
-  # def call(arguments = {}, context = {})
-  #   Rails.logger.info("Tool #{name} called with: #{arguments.inspect}")
-  #   super
-  # end
-end

data/lib/mcp_on_ruby/generators/templates/initializer.rb

@@ -1,41 +0,0 @@
-# MCP on Ruby configuration
-McpOnRuby.configure do |config|
-  # Logging level
-  config.log_level = Rails.logger.level
-  
-  # MCP endpoint path
-  config.path = '/mcp'
-  
-  # Authentication (set to true for production)
-  config.authentication_required = false
-  config.authentication_token = ENV['MCP_AUTH_TOKEN']
-  
-  # Security settings
-  config.allowed_origins = []  # Empty means allow all origins
-  config.localhost_only = Rails.env.development?
-  config.dns_rebinding_protection = true
-  
-  # Rate limiting (requests per minute per IP)
-  config.rate_limit_per_minute = 60
-  
-  # Features
-  config.enable_sse = true
-  config.cors_enabled = true
-end
-
-# Enable MCP server in Rails
-Rails.application.configure do
-  config.mcp.enabled = true
-  config.mcp.auto_register_tools = true
-  config.mcp.auto_register_resources = true
-end
-
-# Mount MCP server (alternative to route-based mounting)
-# Rails.application.config.after_initialize do
-#   McpOnRuby.mount_in_rails(Rails.application) do |server|
-#     # Manual tool/resource registration if needed
-#     # server.tool 'custom_tool', 'Description' do |args|
-#     #   { result: 'Custom logic here' }
-#     # end
-#   end
-# end

data/lib/mcp_on_ruby/generators/templates/resource.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-# <%= resource_description %>
-class <%= resource_class_name %> < ApplicationResource
-  def initialize
-    super(
-      uri: '<%= resource_uri %>',
-      name: '<%= name.humanize %>',
-      description: '<%= resource_description %>',
-      mime_type: '<%= resource_mime_type %>',
-      metadata: {
-        category: 'custom',
-        version: '1.0.0'
-      },
-      tags: ['<%= resource_name %>']
-    )
-  end
-
-  protected
-
-  def fetch_content(params, context)
-    <% if is_template? -%>
-    # This is a templated resource with parameters: <%= template_params.join(', ') %>
-    # Access parameters via params hash:
-    <% template_params.each do |param| -%>
-    # <%= param %> = params['<%= param %>']
-    <% end -%>
-    <% end -%>
-    
-    # Implement your resource content fetching logic here
-    # Return data that will be serialized according to mime_type
-    
-    {
-      resource: '<%= resource_name %>',
-      <% if is_template? -%>
-      parameters: params,
-      <% end -%>
-      data: {
-        # Your resource data here
-      },
-      generated_at: Time.current.iso8601
-    }
-  end
-
-  # Optional: Add authorization logic
-  # def authorize(context)
-  #   # Return true/false based on context (user, permissions, etc.)
-  #   true
-  # end
-end

data/lib/mcp_on_ruby/generators/templates/resource_spec.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe <%= resource_class_name %>, type: :model do
-  subject(:resource) { described_class.new }
-
-  describe '#read' do
-    <% if is_template? -%>
-    let(:params) { { <%= template_params.map { |p| "'#{p}' => 'test_#{p}'" }.join(', ') %> } }
-    <% else -%>
-    let(:params) { {} }
-    <% end -%>
-    let(:context) { { remote_ip: '127.0.0.1' } }
-
-    it 'returns resource content' do
-      result = resource.read(params, context)
-      
-      expect(result).to be_a(Hash)
-      expect(result).to have_key(:contents)
-      expect(result[:contents]).to be_an(Array)
-      
-      content = result[:contents].first
-      expect(content).to include(:uri, :mimeType, :text)
-    end
-
-    <% if is_template? -%>
-    it 'uses template parameters' do
-      result = resource.read(params, context)
-      content = JSON.parse(result[:contents].first[:text])
-      
-      expect(content['parameters']).to eq(params.stringify_keys)
-    end
-    <% end -%>
-  end
-
-  describe '#authorize' do
-    let(:context) { { authenticated: true } }
-
-    it 'returns true for authorized context' do
-      expect(resource.authorized?(context)).to be true
-    end
-  end
-
-  describe '#to_schema' do
-    it 'returns valid schema' do
-      schema = resource.to_schema
-      
-      expect(schema).to include(:uri, :mimeType)
-      expect(schema[:uri]).to eq('<%= resource_uri %>')
-    end
-  end
-
-  <% if is_template? -%>
-  describe '#template?' do
-    it 'returns true' do
-      expect(resource.template?).to be true
-    end
-  end
-
-  describe '#template_params' do
-    it 'returns parameter names' do
-      expect(resource.template_params).to match_array(<%= template_params.inspect %>)
-    end
-  end
-  <% end -%>
-end

data/lib/mcp_on_ruby/generators/templates/sample_resource.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-# Sample resource demonstrating MCP resource creation
-class SampleResource < ApplicationResource
-  def initialize
-    super(
-      uri: 'sample_data',
-      name: 'Sample Data',
-      description: 'A sample resource that provides application statistics',
-      mime_type: 'application/json',
-      metadata: {
-        category: 'sample',
-        version: '1.0.0'
-      },
-      tags: ['sample', 'stats']
-    )
-  end
-
-  protected
-
-  def fetch_content(params, context)
-    # Example: Fetch data from Rails models
-    {
-      application: {
-        name: Rails.application.class.module_parent_name,
-        environment: Rails.env,
-        version: '1.0.0'
-      },
-      statistics: {
-        # users_count: User.count,
-        # posts_count: Post.count,
-        uptime: uptime_info
-      },
-      timestamp: Time.current.iso8601,
-      request_info: {
-        remote_ip: context[:remote_ip],
-        user_agent: context[:user_agent]
-      }
-    }
-  end
-
-  # Optional: Add authorization logic
-  # def authorize(context)
-  #   # Example: Only allow authenticated users to read this resource
-  #   context[:authenticated] == true
-  # end
-
-  private
-
-  def uptime_info
-    load_avg = `uptime`.strip rescue 'unavailable'
-    {
-      server_uptime: load_avg,
-      rails_uptime: Time.current - Rails.application.config.time_zone.parse('2024-01-01')
-    }
-  end
-end

data/lib/mcp_on_ruby/generators/templates/sample_tool.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-# Sample tool demonstrating MCP tool creation
-class SampleTool < ApplicationTool
-  def initialize
-    super(
-      name: 'sample_tool',
-      description: 'A sample tool that demonstrates basic functionality',
-      input_schema: {
-        type: 'object',
-        properties: {
-          message: {
-            type: 'string',
-            description: 'Message to process'
-          },
-          count: {
-            type: 'integer',
-            description: 'Number of times to repeat',
-            minimum: 1,
-            maximum: 10,
-            default: 1
-          }
-        },
-        required: ['message']
-      },
-      metadata: {
-        category: 'sample',
-        version: '1.0.0'
-      },
-      tags: ['sample', 'demo']
-    )
-  end
-
-  protected
-
-  def execute(arguments, context)
-    message = arguments['message']
-    count = arguments['count'] || 1
-    
-    # Example: Access Rails models or services
-    # user_count = User.count
-    
-    {
-      success: true,
-      result: message * count,
-      processed_at: Time.current.iso8601,
-      context_info: {
-        remote_ip: context[:remote_ip],
-        user_agent: context[:user_agent]
-      }
-    }
-  end
-
-  # Optional: Add authorization logic
-  # def authorize(context)
-  #   # Example: Only allow authenticated users
-  #   context[:authenticated] == true
-  # end
-end

data/lib/mcp_on_ruby/generators/templates/tool.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-# <%= tool_description %>
-class <%= tool_class_name %> < ApplicationTool
-  def initialize
-    super(
-      name: '<%= tool_name %>',
-      description: '<%= tool_description %>',
-      <%= input_schema_code %>,
-      metadata: {
-        category: 'custom',
-        version: '1.0.0'
-      },
-      tags: ['<%= tool_name %>']
-    )
-  end
-
-  protected
-
-  def execute(arguments, context)
-    # Implement your tool logic here
-    # Arguments are validated according to input_schema
-    # Context contains request information (IP, headers, etc.)
-    
-    {
-      success: true,
-      result: "Tool <%= tool_name %> executed successfully",
-      arguments: arguments,
-      processed_at: Time.current.iso8601
-    }
-  end
-
-  # Optional: Add authorization logic
-  # def authorize(context)
-  #   # Return true/false based on context (user, permissions, etc.)
-  #   true
-  # end
-end

data/lib/mcp_on_ruby/generators/templates/tool_spec.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe <%= tool_class_name %>, type: :model do
-  subject(:tool) { described_class.new }
-
-  describe '#execute' do
-    let(:arguments) { {} }
-    let(:context) { { remote_ip: '127.0.0.1' } }
-
-    it 'executes successfully' do
-      result = tool.call(arguments, context)
-      
-      expect(result).to be_a(Hash)
-      expect(result[:success]).to be true
-    end
-
-    # Add more specific tests based on your tool's functionality
-    # context 'with valid arguments' do
-    #   let(:arguments) { { param: 'value' } }
-    #   
-    #   it 'returns expected result' do
-    #     result = tool.call(arguments, context)
-    #     
-    #     expect(result[:result]).to eq('expected_value')
-    #   end
-    # end
-    
-    # context 'with invalid arguments' do
-    #   let(:arguments) { { invalid: 'param' } }
-    #   
-    #   it 'raises validation error' do
-    #     expect { tool.call(arguments, context) }.to raise_error(McpOnRuby::ValidationError)
-    #   end
-    # end
-  end
-
-  describe '#authorize' do
-    let(:context) { { authenticated: true } }
-
-    it 'returns true for authorized context' do
-      expect(tool.authorized?(context)).to be true
-    end
-  end
-
-  describe '#to_schema' do
-    it 'returns valid schema' do
-      schema = tool.to_schema
-      
-      expect(schema).to include(:name, :description, :inputSchema)
-      expect(schema[:name]).to eq('<%= tool_name %>')
-    end
-  end
-end

data/lib/mcp_on_ruby/generators/tool_generator.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails/generators'
-
-module McpOnRuby
-  module Generators
-    # Generator for creating MCP tools
-    class ToolGenerator < Rails::Generators::NamedBase
-      source_root File.expand_path('templates', __dir__)
-
-      desc "Generate an MCP tool class"
-
-      argument :name, type: :string, desc: "Name of the tool"
-      
-      class_option :description, type: :string, desc: "Description of the tool"
-      class_option :input_schema, type: :hash, default: {}, desc: "JSON Schema for input validation"
-
-      def create_tool_file
-        template 'tool.rb', File.join('app/tools', "#{file_name}_tool.rb")
-      end
-
-      def create_spec_file
-        return unless File.exist?(Rails.root.join('spec'))
-        
-        template 'tool_spec.rb', File.join('spec/tools', "#{file_name}_tool_spec.rb")
-      end
-
-      private
-
-      def tool_name
-        name.underscore
-      end
-
-      def tool_class_name
-        "#{name.camelize}Tool"
-      end
-
-      def tool_description
-        options[:description] || "#{name.humanize} tool"
-      end
-
-      def input_schema_code
-        if options[:input_schema].any?
-          "input_schema #{options[:input_schema].inspect}"
-        else
-          "# input_schema({\n    #   type: 'object',\n    #   properties: {\n    #     param: { type: 'string' }\n    #   },\n    #   required: ['param']\n    # })"
-        end
-      end
-    end
-  end
-end

data/lib/mcp_on_ruby/railtie.rb

@@ -1,108 +0,0 @@
-# frozen_string_literal: true
-
-if defined?(Rails)
-  module McpOnRuby
-    # Rails integration via Railtie
-    class Railtie < Rails::Railtie
-      # Add MCP-specific directories to Rails autoload paths
-      initializer "mcp_on_ruby.setup_autoload_paths" do |app|
-        # Add app/tools and app/resources to autoload paths
-        %w[tools resources].each do |dir|
-          path = app.root.join("app", dir)
-          if path.exist? && !app.config.autoload_paths.include?(path.to_s)
-            app.config.autoload_paths = app.config.autoload_paths.dup if app.config.autoload_paths.frozen?
-            app.config.autoload_paths << path.to_s
-          end
-        end
-      end
-
-      # Set up Rails-friendly aliases
-      initializer "mcp_on_ruby.setup_aliases" do
-        # Create Rails-style base classes
-        Object.const_set('ApplicationTool', Class.new(McpOnRuby::Tool)) unless defined?(ApplicationTool)
-        Object.const_set('ApplicationResource', Class.new(McpOnRuby::Resource)) unless defined?(ApplicationResource)
-      end
-
-      # Configure MCP server if needed
-      initializer "mcp_on_ruby.configure" do |app|
-        # Set up default configuration
-        McpOnRuby.configure do |config|
-          config.log_level = Rails.logger.level
-        end
-
-        # Add MCP configuration to Rails application
-        app.config.mcp = ActiveSupport::OrderedOptions.new
-        app.config.mcp.enabled = false
-        app.config.mcp.path = '/mcp'
-        app.config.mcp.authentication_required = false
-        app.config.mcp.authentication_token = nil
-        app.config.mcp.rate_limit_per_minute = 60
-        app.config.mcp.auto_register_tools = true
-        app.config.mcp.auto_register_resources = true
-      end
-
-      # Setup MCP middleware
-      initializer "mcp_on_ruby.setup_middleware", after: :load_config_initializers do |app|
-        next unless app.config.mcp.enabled
-
-        # Eager load MCP classes in development
-        if Rails.env.development?
-          tools_path = app.root.join('app/tools')
-          resources_path = app.root.join('app/resources')
-          
-          if tools_path.exist?
-            Dir[tools_path.join('**/*.rb')].each { |file| require_dependency file }
-          end
-          
-          if resources_path.exist?
-            Dir[resources_path.join('**/*.rb')].each { |file| require_dependency file }
-          end
-        end
-
-        # Create MCP server instance
-        server = McpOnRuby.server do |s|
-          # Auto-register tools if enabled
-          if app.config.mcp.auto_register_tools && defined?(ApplicationTool)
-            ApplicationTool.descendants.each do |tool_class|
-              instance = tool_class.new
-              s.register_tool(instance)
-            end
-          end
-
-          # Auto-register resources if enabled
-          if app.config.mcp.auto_register_resources && defined?(ApplicationResource)
-            ApplicationResource.descendants.each do |resource_class|
-              instance = resource_class.new
-              s.register_resource(instance)
-            end
-          end
-        end
-
-        # Mount the server middleware (before the stack is frozen)
-        app.middleware.use(
-          McpOnRuby::Transport::RackMiddleware,
-          server: server,
-          path: app.config.mcp.path,
-          authentication_required: app.config.mcp.authentication_required,
-          authentication_token: app.config.mcp.authentication_token,
-          rate_limit_per_minute: app.config.mcp.rate_limit_per_minute
-        )
-
-        # Store server reference for manual access
-        app.config.mcp_server = server
-      end
-
-      # Add rake tasks (uncomment when tasks file is created)
-      # rake_tasks do
-      #   load File.expand_path('tasks/mcp.rake', __dir__)
-      # end
-
-      # Add generators
-      generators do
-        require_relative 'generators/install_generator'
-        require_relative 'generators/tool_generator'
-        require_relative 'generators/resource_generator'
-      end
-    end
-  end
-end