actionmcp 0.1.0

data/lib/action_mcp/resources_bank.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+# frozen_string_literal: true
+
+module ActionMCP
+  module ResourcesBank
+    @resources = {}    # { uri => content_object }
+    @templates  = {}   # { uri => template_object }
+    @watchers   = {}   # { source_uri => watcher }
+
+    class << self
+      # Basic resource registration.
+      def register_resource(uri, content)
+        @resources[uri] = content
+      end
+
+      def all_resources
+        @resources.values
+      end
+
+      def read(uri)
+        @resources[uri]
+      end
+
+      def register_template(uri, template)
+        @templates[uri] = template
+      end
+
+      def all_templates
+        @templates.values
+      end
+
+      # Registers a source (file or directory) for resources.
+      #
+      # @param source_uri [String] An identifier for this source.
+      # @param path [String] Filesystem path to the source.
+      # @param watch [Boolean] Whether to watch the source for changes.
+      def register_source(source_uri, path, watch: false)
+        reload_source(source_uri, path) # Initial load
+
+        if watch
+          require "active_support/evented_file_update_checker"
+          # Watch all files under the given path (recursive)
+          file_paths = Dir.glob("#{path}/**/*")
+          watcher = ActiveSupport::EventedFileUpdateChecker.new(file_paths) do |modified, added, removed|
+            Rails.logger.info("Files changed in #{path} - Modified: #{modified.inspect}, Added: #{added.inspect}, Removed: #{removed.inspect}")
+            # Reload resources for this source when changes occur.
+            reload_source(source_uri, path)
+          end
+          @watchers[source_uri] = { path: path, watcher: watcher }
+        end
+      end
+
+      # Unregisters a source and stops watching it.
+      #
+      # @param source_uri [String] The identifier for the source.
+      def unregister_source(source_uri)
+        @watchers.delete(source_uri)
+        # Optionally, remove any resources associated with this source.
+        @resources.reject! { |uri, _| uri.start_with?("#{source_uri}://") }
+      end
+
+      # Reloads (or loads) all resources from the given directory.
+      #
+      # @param source_uri [String] The identifier for the source.
+      # @param path [String] Filesystem path to the source.
+      def reload_source(source_uri, path)
+        Rails.logger.info("Reloading resources from #{path} for #{source_uri}")
+        Dir.glob("#{path}/**/*").each do |file|
+          next unless File.file?(file)
+          # Create a resource URI from the source and file path.
+          relative_path = file.sub(%r{\A#{Regexp.escape(path)}/?}, "")
+          resource_uri = "#{source_uri}://#{relative_path}"
+          # For this example, we assume text files.
+          begin
+            text = File.read(file)
+            content = ActionMCP::Content::Text.new(text)
+            register_resource(resource_uri, content)
+            Rails.logger.info("Registered resource: #{resource_uri}")
+          rescue StandardError => e
+            Rails.logger.error("Error reading file #{file}: #{e.message}")
+          end
+        end
+      end
+
+      # This method should be called periodically (e.g. via a background thread)
+      # to check if any watched files have changed.
+      def run_watchers
+        @watchers.each_value do |data|
+          data[:watcher].execute_if_updated
+        end
+      end
+    end
+  end
+end

data/lib/action_mcp/tool.rb

@@ -0,0 +1,147 @@
+# lib/action_mcp/tool.rb
+# frozen_string_literal: true
+
+module ActionMCP
+  class Tool
+    include ActiveModel::Model
+    include ActiveModel::Attributes
+
+    class_attribute :_tool_name, instance_accessor: false
+    class_attribute :_description, instance_accessor: false, default: ""
+    class_attribute :_schema_properties, instance_accessor: false, default: {}
+    class_attribute :_required_properties, instance_accessor: false, default: []
+    class_attribute :abstract_tool, instance_accessor: false, default: false
+
+    # Register each non-abstract subclass in ToolsRegistry
+    def self.inherited(subclass)
+      super
+      return if subclass == Tool
+      subclass.abstract_tool = false
+      return if "ApplicationTool" == subclass.name
+
+      ToolsRegistry.register(subclass.tool_name, subclass)
+    end
+
+    # Mark this tool as abstract so it won’t be available for use.
+    def self.abstract!
+      self.abstract_tool = true
+      ToolsRegistry.unregister(self.tool_name) if ToolsRegistry.items.key?(self.tool_name)
+    end
+
+    def self.abstract?
+      self.abstract_tool
+    end
+
+    # ---------------------------------------------------
+    # Tool Name & Description
+    # ---------------------------------------------------
+    def self.tool_name(name = nil)
+      if name
+        self._tool_name = name
+      else
+        _tool_name || default_tool_name
+      end
+    end
+
+    def self.default_tool_name
+      name.demodulize.underscore.dasherize.sub(/-tool$/, "")
+    end
+
+    def self.description(text = nil)
+      if text
+        self._description = text
+      else
+        _description
+      end
+    end
+
+    # ---------------------------------------------------
+    # Property DSL (Direct Declaration)
+    # ---------------------------------------------------
+    def self.property(prop_name, type: "string", description: nil, required: false, default: nil, **opts)
+      # Build JSON Schema definition for the property.
+      prop_definition = { type: type }
+      prop_definition[:description] = description if description && !description.empty?
+      prop_definition.merge!(opts) if opts.any?
+
+      self._schema_properties = _schema_properties.merge(prop_name.to_s => prop_definition)
+      self._required_properties = _required_properties.dup
+      self._required_properties << prop_name.to_s if required
+
+      # Map our DSL type to an ActiveModel attribute type.
+      am_type = case type.to_s
+      when "number" then :float
+      when "integer" then :integer
+      when "array"   then :string
+      else
+                  :string
+      end
+      attribute prop_name, am_type, default: default
+    end
+
+    # ---------------------------------------------------
+    # Collection DSL
+    # ---------------------------------------------------
+    # Supports two forms:
+    #
+    # 1. Without a block:
+    #    collection :args, type: "string", description: "Command arguments"
+    #
+    # 2. With a block (defining a nested object):
+    #    collection :files, description: "List of Files" do
+    #      property :file, required: true, description: 'file uri'
+    #      property :checksum, required: true, description: 'checksum to verify'
+    #    end
+    def self.collection(prop_name, type: nil, description: nil, required: false, default: nil, **opts, &block)
+      if block_given?
+        # Build nested schema for an object.
+        nested_schema = { type: "object", properties: {}, required: [] }
+        dsl = CollectionDSL.new(nested_schema)
+        dsl.instance_eval(&block)
+        collection_definition = { type: "array", description: description, items: nested_schema }
+      else
+        raise ArgumentError, "Type is required for a collection without a block" if type.nil?
+        collection_definition = { type: "array", description: description, items: { type: type } }
+      end
+
+      self._schema_properties = _schema_properties.merge(prop_name.to_s => collection_definition)
+      self._required_properties = _required_properties.dup
+      self._required_properties << prop_name.to_s if required
+
+      # Register the property as an attribute.
+      # (Mapping for a collection can be customized; here we use :string to mimic previous behavior.)
+      attribute prop_name, :string, default: default
+    end
+
+    # DSL for building a nested schema within a collection block.
+    class CollectionDSL
+      attr_reader :schema
+
+      def initialize(schema)
+        @schema = schema
+      end
+
+      def property(prop_name, type: "string", description: nil, required: false, default: nil, **opts)
+        prop_definition = { type: type }
+        prop_definition[:description] = description if description && !description.empty?
+        prop_definition.merge!(opts) if opts.any?
+
+        @schema[:properties][prop_name.to_s] = prop_definition
+        @schema[:required] << prop_name.to_s if required
+      end
+    end
+
+    # ---------------------------------------------------
+    # Convert Tool Definition to Hash
+    # ---------------------------------------------------
+    def self.to_h
+      schema = { type: "object", properties: self._schema_properties }
+      schema[:required] = self._required_properties if self._required_properties.any?
+      {
+        name: self.tool_name,
+        description: self.description.presence,
+        inputSchema: schema
+      }.compact
+    end
+  end
+end

data/lib/action_mcp/tools_registry.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# frozen_string_literal: true
+
+module ActionMCP
+  class ToolsRegistry < RegistryBase
+    class << self
+      alias_method :tools, :items
+      alias_method :available_tools, :enabled
+    end
+  end
+end

data/lib/action_mcp/transport.rb

@@ -0,0 +1,244 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  class Transport
+    HEARTBEAT_INTERVAL = 15 # seconds
+
+    def initialize(output_io)
+      # output_io can be any IO-like object where we write events.
+      @output = output_io
+      @output.sync = true
+    end
+
+    # Sends the capabilities JSON-RPC notification.
+    #
+    # @param request_id [String, Integer] The request identifier.
+    def send_capabilities(request_id)
+      payload = {
+        protocolVersion: "2024-11-05",
+        capabilities: {
+          tools: { listChanged: true },
+          prompts: { listChanged: true },
+          resources: { listChanged: true },
+          logging: {}
+        },
+        serverInfo: {
+          name: Rails.application.name,
+          version: Rails.application.version.to_s
+        }
+      }
+      send_jsonrpc_response(request_id, result: payload)
+    end
+
+    # Sends the tools list JSON-RPC notification.
+    #
+    # @param request_id [String, Integer] The request identifier.
+    def send_tools_list(request_id)
+      tools = format_registry_items(ActionMCP::ToolsRegistry.available_tools)
+      send_jsonrpc_response(request_id, result: { tools: tools })
+    end
+
+    # Sends the resources list JSON-RPC response.
+    #
+    # @param request_id [String, Integer] The request identifier.
+    def send_resources_list(request_id)
+      begin
+        resources = ActionMCP::ResourcesRegistry.all_resources  # fetch all resources
+        result_data = { "resources" => resources }
+        send_jsonrpc_response(request_id, result: result_data)
+        Rails.logger.info("resources/list: Returned #{resources.size} resources.")
+      rescue StandardError => e
+        Rails.logger.error("resources/list failed: #{e.message}")
+        error_obj = JsonRpcError.new(
+          :internal_error,
+          message: "Failed to list resources: #{e.message}"
+        ).as_json
+        send_jsonrpc_response(request_id, error: error_obj)
+      end
+    end
+
+    # Sends the resource templates list JSON-RPC response.
+    #
+    # @param request_id [String, Integer] The request identifier.
+    def send_resource_templates_list(request_id)
+      begin
+        templates = ActionMCP::ResourcesRegistry.all_templates  # get all resource templates
+        result_data = { "resourceTemplates" => templates }
+        send_jsonrpc_response(request_id, result: result_data)
+        Rails.logger.info("resources/templates/list: Returned #{templates.size} resource templates.")
+      rescue StandardError => e
+        Rails.logger.error("resources/templates/list failed: #{e.message}")
+        error_obj = JsonRpcError.new(
+          :internal_error,
+          message: "Failed to list resource templates: #{e.message}"
+        ).as_json
+        send_jsonrpc_response(request_id, error: error_obj)
+      end
+    end
+
+    # Sends the resource read JSON-RPC response.
+    #
+    # @param request_id [String, Integer] The request identifier.
+    # @param params [Hash] The parameters including the 'uri' for the resource.
+    def send_resource_read(request_id, params)
+      uri = params&.fetch("uri", nil)
+      if uri.nil? || uri.empty?
+        Rails.logger.error("resources/read: 'uri' parameter is missing")
+        error_obj = JsonRpcError.new(
+          :invalid_params,
+          message: "Missing 'uri' parameter for resources/read"
+        ).as_json
+        return send_jsonrpc_response(request_id, error: error_obj)
+      end
+
+      begin
+        content = ActionMCP::ResourcesRegistry.read(uri)  # Expecting an instance of an ActionMCP::Content subclass
+        if content.nil?
+          Rails.logger.error("resources/read: Resource not found for URI #{uri}")
+          error_obj = JsonRpcError.new(
+            :invalid_params,
+            message: "Resource not found: #{uri}"
+          ).as_json
+          return send_jsonrpc_response(request_id, error: error_obj)
+        end
+
+        # Use the content object's `to_h` to build the JSON-RPC result.
+        result_data = { "contents" => [ content.to_h ] }
+        send_jsonrpc_response(request_id, result: result_data)
+
+        log_msg = "resources/read: Successfully read content of #{uri}"
+        log_msg += " (#{content.text.size} bytes)" if content.respond_to?(:text) && content.text
+        Rails.logger.info(log_msg)
+      rescue StandardError => e
+        Rails.logger.error("resources/read: Error reading #{uri} - #{e.message}")
+        error_obj = JsonRpcError.new(
+          :internal_error,
+          message: "Failed to read resource: #{e.message}"
+        ).as_json
+        send_jsonrpc_response(request_id, error: error_obj)
+      end
+    end
+
+
+    # Sends a call to a tool. Currently logs the call details.
+    #
+    # @param request_id [String, Integer] The request identifier.
+    # @param tool_name [String] The name of the tool.
+    # @param params [Hash] The parameters for the tool.
+    def send_tools_call(request_id, tool_name, params)
+      begin
+        tool = ActionMCP::ToolsRegistry.fetch_available_tool(tool_name.to_s)
+        Rails.logger.info("Sending tool call: #{tool_name} with params: #{params}")
+        # TODO: Implement tool call handling and response if needed.
+      rescue StandardError => e
+        Rails.logger.error("tools/call: Failed to call tool #{tool_name} - #{e.message}")
+        error_obj = JsonRpcError.new(
+          :internal_error,
+          message: "Failed to call tool #{tool_name}: #{e.message}"
+        ).as_json
+        send_jsonrpc_response(request_id, error: error_obj)
+      end
+    end
+
+    # Sends the prompts list JSON-RPC notification.
+    #
+    # @param request_id [String, Integer] The request identifier.
+    def send_prompts_list(request_id)
+      begin
+        prompts = format_registry_items(ActionMCP::PromptsRegistry.available_prompts)
+        send_jsonrpc_response(request_id, result: {prompts: prompts} )
+      rescue StandardError => e
+        Rails.logger.error("prompts/list failed: #{e.message}")
+        error_obj = JsonRpcError.new(
+          :internal_error,
+          message: "Failed to list prompts: #{e.message}"
+        ).as_json
+        send_jsonrpc_response(request_id, error: error_obj)
+      end
+    end
+
+    def send_prompts_get(request_id, params)
+      prompt_name = params&.fetch("name", nil)
+      if prompt_name.nil? || prompt_name.strip.empty?
+        Rails.logger.error("prompts/get: 'name' parameter is missing")
+        error_obj = JsonRpcError.new(
+          :invalid_params,
+          message: "Missing 'name' parameter for prompts/get"
+        ).as_json
+        return send_jsonrpc_response(request_id, error: error_obj)
+      end
+
+      begin
+        # Assume a method similar to fetch_available_tool exists for prompts.
+        prompt = ActionMCP::PromptsRegistry.fetch_available_prompt(prompt_name.to_s)
+        if prompt.nil?
+          Rails.logger.error("prompts/get: Prompt not found for name #{prompt_name}")
+          error_obj = JsonRpcError.new(
+            :invalid_params,
+            message: "Prompt not found: #{prompt_name}"
+          ).as_json
+          return send_jsonrpc_response(request_id, error: error_obj)
+        end
+
+        result_data = { "prompt" => prompt.to_h }
+        send_jsonrpc_response(request_id, result: result_data)
+        Rails.logger.info("prompts/get: Returned prompt #{prompt_name}")
+      rescue StandardError => e
+        Rails.logger.error("prompts/get: Error retrieving prompt #{prompt_name} - #{e.message}")
+        error_obj = JsonRpcError.new(
+          :internal_error,
+          message: "Failed to get prompt: #{e.message}"
+        ).as_json
+        send_jsonrpc_response(request_id, error: error_obj)
+      end
+    end
+
+
+    # Sends a JSON-RPC pong response.
+    # We don't actually to send any data back because the spec are not fun anymore.
+    #
+    # @param request_id [String, Integer] The request identifier.
+    def send_pong(request_id)
+      send_jsonrpc_response(request_id, result: {})
+    end
+
+    # Sends a JSON-RPC response.
+    #
+    # @param request_id [String, Integer] The request identifier.
+    # @param result [Object] The result data.
+    # @param error [Object, nil] The error data, if any.
+    def send_jsonrpc_response(request_id, result: nil, error: nil)
+      response = JsonRpc::Response.new(id: request_id, result: result, error: error)
+      write_message(response.to_json)
+    end
+
+    # Sends a generic JSON-RPC notification (no response expected).
+    #
+    # @param method [String] The JSON-RPC method.
+    # @param params [Hash] The parameters for the method.
+    def send_jsonrpc_notification(method, params = {})
+      notification = JsonRpc::Notification.new(method: method, params: params)
+      write_message(notification.to_json)
+    end
+
+    private
+
+    # Formats registry items to a hash representation.
+    #
+    # @param registry [Hash] The registry containing tool or prompt definitions.
+    # @return [Array<Hash>] The formatted registry items.
+    def format_registry_items(registry)
+      registry.map { |_, item| item[:class].to_h }
+    end
+
+    # Writes a message to the output IO.
+    #
+    # @param data [String] The data to write.
+    def write_message(data)
+      Rails.logger.debug("Response Sent: #{data}")
+      @output.write("#{data}\n")
+    rescue IOError => e
+      Rails.logger.error("Failed to write message: #{e.message}")
+    end
+  end
+end

data/lib/action_mcp/version.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative "gem_version"
+
+module ActionMCP
+  VERSION = "0.1.0"
+  # Returns the currently loaded version of Active MCP as a +Gem::Version+.
+  def self.version
+    gem_version
+  end
+end

data/lib/action_mcp.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "rails"
+require "active_support"
+require "active_model"
+require "action_mcp/version"
+require "action_mcp/railtie" if defined?(Rails)
+
+ActiveSupport::Inflector.inflections(:en) do |inflect|
+  inflect.acronym "MCP"
+end
+module ActionMCP
+  extend ActiveSupport::Autoload
+
+  autoload :RegistryBase
+  autoload :Resource
+  autoload :ToolsRegistry
+  autoload :PromptsRegistry
+  autoload :Tool
+  autoload :Prompt
+  autoload :JsonRpc
+
+  module_function
+  def tools
+    ToolsRegistry.tools
+  end
+
+  def prompts
+    PromptsRegistry.prompts
+  end
+
+  def available_tools
+    ToolsRegistry.available_tools
+  end
+
+  def available_prompts
+    PromptsRegistry.available_prompts
+  end
+end

data/lib/actionmcp.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "action_mcp"

data/lib/tasks/action_mcp_tasks.rake

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+# desc "Explaining what the task does"
+# task :action_mcp do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: actionmcp
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Abdelkader Boudih
+bindir: exe
+cert_chain: []
+date: 2025-02-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 8.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 8.0.1
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 8.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 8.0.1
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: It offers base classes and helpers for creating MCP applications, making
+  it easier to integrate your Ruby/Rails application with the MCP standard
+email:
+- terminale@gmail.com
+executables:
+- action_mcp_stdio
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- exe/action_mcp_stdio
+- lib/action_mcp.rb
+- lib/action_mcp/content.rb
+- lib/action_mcp/content/audio.rb
+- lib/action_mcp/content/image.rb
+- lib/action_mcp/content/resource.rb
+- lib/action_mcp/content/text.rb
+- lib/action_mcp/gem_version.rb
+- lib/action_mcp/json_rpc.rb
+- lib/action_mcp/json_rpc/base.rb
+- lib/action_mcp/json_rpc/json_rpc_error.rb
+- lib/action_mcp/json_rpc/notification.rb
+- lib/action_mcp/json_rpc/request.rb
+- lib/action_mcp/json_rpc/response.rb
+- lib/action_mcp/prompt.rb
+- lib/action_mcp/prompts_registry.rb
+- lib/action_mcp/railtie.rb
+- lib/action_mcp/registry_base.rb
+- lib/action_mcp/resource.rb
+- lib/action_mcp/resources_bank.rb
+- lib/action_mcp/tool.rb
+- lib/action_mcp/tools_registry.rb
+- lib/action_mcp/transport.rb
+- lib/action_mcp/version.rb
+- lib/actionmcp.rb
+- lib/tasks/action_mcp_tasks.rake
+homepage: https://github.com/seuros/action_mcp
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/seuros/action_mcp
+  source_code_uri: https://github.com/seuros/action_mcp
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: Provides essential tooling for building Model Context Protocol (MCP) capable
+  servers
+test_files: []