rails_mcp_engine 0.1.0

data/app/lib/tool_schema/fast_mcp_factory.rb

@@ -0,0 +1,49 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'sorbet-runtime'
+require_relative 'fast_mcp_builder'
+
+module ToolSchema
+  class FastMcpFactory
+    extend T::Sig
+
+    sig do
+      params(
+        service_class: T.class_of(Object),
+        schema: T::Hash[Symbol, T.untyped],
+        before_call: T.nilable(Proc),
+        after_call: T.nilable(Proc)
+      ).returns(T.class_of(Object))
+    end
+    def self.build(service_class, schema, before_call: nil, after_call: nil)
+      tool_constant = tool_class_name(service_class)
+      parent = Mcp
+      parent.send(:remove_const, tool_constant) if parent.const_defined?(tool_constant, false)
+
+      klass = Class.new(ApplicationTool) do
+        description(schema[:description])
+        tool_name(schema[:name])
+        arguments(&FastMcpBuilder.arguments_block(schema[:params]))
+
+        define_method(:call) do |**kwargs|
+          before_call&.call(kwargs)
+          result = service_class.new.public_send(schema[:entrypoint], **kwargs)
+          after_call&.call(result)
+          result
+        end
+      end
+
+      parent.const_set(tool_constant, klass)
+    end
+
+    sig { params(service_class: T.class_of(Object)).returns(String) }
+    def self.tool_class_name(service_class)
+      base = service_class.name.split('::').last
+      base.gsub(/Service$/, '')
+    end
+  end
+end
+
+module Mcp
+end

data/app/lib/tool_schema/ruby_llm_builder.rb

@@ -0,0 +1,80 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'sorbet-runtime'
+
+module ToolSchema
+  module RubyLlmBuilder
+    extend T::Sig
+
+    sig { params(params_ast: T::Array[T::Hash[Symbol, T.untyped]]).returns(Proc) }
+    def self.params_block(params_ast)
+      proc do
+        params_ast.each do |param|
+          RubyLlmBuilder.build_param(self, param)
+        end
+      end
+    end
+
+    sig { params(ctx: BasicObject, param: T::Hash[Symbol, T.untyped]).void }
+    def self.build_param(ctx, param)
+      name = param[:name]
+      case param[:type]
+      when :object
+        ctx.object(name) do
+          (param[:children] || []).each do |child|
+            RubyLlmBuilder.build_param(self, child)
+          end
+        end
+      when :array
+        item = param[:item_type]
+        if item && scalar_type?(item[:type])
+          ctx.array(name, of: scalar_symbol(item[:type]))
+        elsif item&.dig(:type) == :object
+          ctx.array(name) do
+            object :item do
+              (item[:children] || []).each do |child|
+                RubyLlmBuilder.build_param(self, child)
+              end
+            end
+          end
+        else
+          ctx.array(name)
+        end
+      when :any
+        ctx.object(name, description: param[:description]) do
+          additional_properties true
+        end
+      else
+        method = scalar_method(param[:type])
+        ctx.public_send(method, name)
+      end
+    end
+
+    sig { params(type: T.untyped).returns(T::Boolean) }
+    def self.scalar_type?(type)
+      %i[string integer float boolean].include?(type)
+    end
+
+    sig { params(type: T.untyped).returns(Symbol) }
+    def self.scalar_symbol(type)
+      case type
+      when :string then :string
+      when :integer then :integer
+      when :float then :float
+      when :boolean then :boolean
+      else :any
+      end
+    end
+
+    sig { params(type: T.untyped).returns(Symbol) }
+    def self.scalar_method(type)
+      case type
+      when :integer then :integer
+      when :float then :float
+      when :boolean then :boolean
+      else :string
+      end
+    end
+  end
+end

data/app/lib/tool_schema/ruby_llm_factory.rb

@@ -0,0 +1,48 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'sorbet-runtime'
+require_relative 'ruby_llm_builder'
+
+module ToolSchema
+  class RubyLlmFactory
+    extend T::Sig
+
+    sig do
+      params(
+        service_class: T.class_of(Object),
+        schema: T::Hash[Symbol, T.untyped],
+        before_call: T.nilable(Proc),
+        after_call: T.nilable(Proc)
+      ).returns(T.class_of(Object))
+    end
+    def self.build(service_class, schema, before_call: nil, after_call: nil)
+      tool_constant = tool_class_name(service_class)
+      parent = Tools
+      parent.send(:remove_const, tool_constant) if parent.const_defined?(tool_constant, false)
+
+      klass = Class.new(RubyLLM::Tool) do
+        description(schema[:description])
+        params(&RubyLlmBuilder.params_block(schema[:params]))
+
+        define_method(:execute) do |**kwargs|
+          before_call&.call(kwargs)
+          result = service_class.new.public_send(schema[:entrypoint], **kwargs)
+          after_call&.call(result)
+          result
+        end
+      end
+
+      parent.const_set(tool_constant, klass)
+    end
+
+    sig { params(service_class: T.class_of(Object)).returns(String) }
+    def self.tool_class_name(service_class)
+      base = service_class.name.split('::').last
+      base.gsub(/Service$/, '')
+    end
+  end
+end
+
+module Tools
+end

data/app/lib/tool_schema/sorbet_type_mapper.rb

@@ -0,0 +1,137 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'sorbet-runtime'
+
+module ToolSchema
+  module SorbetTypeMapper
+    extend T::Sig
+
+    TypeAst = T.type_alias do
+      T::Hash[Symbol, T.untyped]
+    end
+
+    sig { params(method: UnboundMethod).returns(T::Hash[Symbol, T.untyped]) }
+    def self.map_signature(method)
+      signature = T::Private::Methods.signature_for_method(method)
+      raise ToolMeta::MissingSignatureError, "Missing Sorbet signature for #{method.name}" if signature.nil?
+
+      params_ast = signature.arg_types.map do |name, type|
+        map_param(name, type)
+      end
+
+      signature.kwarg_types.each do |name, type|
+        params_ast << map_param(name, type)
+      end
+
+      {
+        params: params_ast,
+        return_type: map_type(signature.return_type)
+      }
+    end
+
+    sig { params(name: T.any(String, Symbol), type: T.untyped).returns(TypeAst) }
+    def self.map_param(name, type)
+      details = map_type(type)
+      details.merge(name: name.to_sym)
+    end
+
+    sig { params(type: T.untyped).returns(TypeAst) }
+    def self.map_type(type)
+      nilable, inner_type = unwrap_nilable(type)
+      mapped = case inner_type
+               when T::Types::FixedHash
+                 map_fixed_hash(inner_type)
+               when T::Types::TypedArray
+                 map_array(inner_type)
+               when T::Types::TypedHash
+                 map_hash(inner_type)
+               when T::Types::Simple
+                 map_simple(inner_type)
+               when T::Types::Union
+                 map_union(inner_type)
+               else
+                 { type: :any }
+               end
+
+      mapped.merge(required: !nilable)
+    end
+
+    sig { params(type: T::Types::Union).returns(TypeAst) }
+    def self.map_union(type)
+      non_nil_types = type.types.reject { |t| t.is_a?(T::Types::Simple) && t.raw_type == NilClass }
+
+      # Check for Boolean (TrueClass | FalseClass)
+      is_boolean = non_nil_types.length == 2 && non_nil_types.all? do |t|
+        t.is_a?(T::Types::Simple) && [TrueClass, FalseClass].include?(t.raw_type)
+      end
+      return { type: :boolean } if is_boolean
+
+      return { type: :any } if non_nil_types.length != 1
+
+      map_type(non_nil_types.first).merge(required: true)
+    end
+
+    sig { params(type: T::Types::TypedArray).returns(TypeAst) }
+    def self.map_array(type)
+      {
+        type: :array,
+        item_type: map_type(type.type)
+      }
+    end
+
+    sig { params(type: T::Types::TypedHash).returns(TypeAst) }
+    def self.map_hash(type)
+      {
+        type: :object,
+        children: [],
+        key_type: map_type(type.keys),
+        value_type: map_type(type.values)
+      }
+    end
+
+    sig { params(type: T::Types::FixedHash).returns(TypeAst) }
+    def self.map_fixed_hash(type)
+      children = type.keys.map do |key, value|
+        mapped = map_type(value.type)
+        mapped.merge(name: key.to_sym, required: value.required?)
+      end
+
+      {
+        type: :object,
+        children: children
+      }
+    end
+
+    sig { params(type: T::Types::Simple).returns(TypeAst) }
+    def self.map_simple(type)
+      raw = type.raw_type
+      case raw.name
+      when 'String'
+        { type: :string }
+      when 'Integer'
+        { type: :integer }
+      when 'Float'
+        { type: :float }
+      when 'TrueClass', 'FalseClass'
+        { type: :boolean }
+      else
+        if raw == T::Boolean
+          { type: :boolean }
+        else
+          { type: :any }
+        end
+      end
+    end
+
+    sig { params(type: T.untyped).returns([T::Boolean, T.untyped]) }
+    def self.unwrap_nilable(type)
+      return [false, type] unless type.is_a?(T::Types::Union)
+
+      nilable = type.types.any? { |t| t.is_a?(T::Types::Simple) && t.raw_type == NilClass }
+      non_nil = type.types.reject { |t| t.is_a?(T::Types::Simple) && t.raw_type == NilClass }
+      target = non_nil.length == 1 ? non_nil.first : type
+      [nilable, target]
+    end
+  end
+end

data/app/services/tools/meta_tool_service.rb

@@ -0,0 +1,165 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'sorbet-runtime'
+require 'tool_meta'
+require 'tool_schema/builder'
+require 'tool_schema/ruby_llm_factory'
+require 'tool_schema/fast_mcp_factory'
+
+module Tools
+  class MetaToolService
+    extend T::Sig
+    extend ToolMeta
+
+    tool_name 'meta_tool'
+    tool_description 'Inspect and run registered tools via a single meta interface.'
+    tool_param :action, description: 'Operation to perform', enum: %w[search list list_summary get run]
+    tool_param :tool_name, description: 'Tool name to target (for get/run)', required: false
+    tool_param :query, description: 'Search string to match against tool names/descriptions', required: false
+    tool_param :arguments, description: 'Arguments to pass when running a tool', required: false
+
+    sig do
+      params(
+        action: String,
+        tool_name: T.nilable(String),
+        query: T.nilable(String),
+        arguments: T.nilable(T::Hash[T.untyped, T.untyped])
+      ).returns(T::Hash[Symbol, T.untyped])
+    end
+    def call(action:, tool_name: nil, query: nil, arguments: nil)
+      case action
+      when 'search'
+        search_tools(query)
+      when 'list'
+        { tools: list_tools }
+      when 'list_summary'
+        { tools: list_summaries }
+      when 'get'
+        get_tool(tool_name)
+      when 'run'
+        run_tool(tool_name, arguments || {})
+      else
+        { error: "Unknown action: #{action}" }
+      end
+    end
+
+    sig { params(class_name: T.nilable(String), before_call: T.nilable(Proc), after_call: T.nilable(Proc)).returns(T::Hash[Symbol, T.untyped]) }
+    def register_tool(class_name, before_call: nil, after_call: nil)
+      return { error: 'class_name is required for register' } if class_name.nil? || class_name.empty?
+
+      service_class = constantize(class_name)
+      return { error: "Could not find #{class_name}" } if service_class.nil?
+      return { error: "#{class_name} must extend ToolMeta" } unless service_class.respond_to?(:tool_metadata)
+
+      ToolMeta.registry << service_class unless ToolMeta.registry.include?(service_class)
+
+      schema = ToolSchema::Builder.build(service_class)
+      ToolSchema::RubyLlmFactory.build(service_class, schema, before_call: before_call, after_call: after_call)
+      ToolSchema::FastMcpFactory.build(service_class, schema, before_call: before_call, after_call: after_call)
+
+      { status: 'registered', tool: summary_payload(schema) }
+    rescue ToolMeta::MissingSignatureError => e
+      { error: e.message }
+    rescue NameError => e
+      { error: "Could not find #{class_name}: #{e.message}" }
+    end
+
+    private
+
+    sig { params(query: T.nilable(String)).returns(T::Hash[Symbol, T.untyped]) }
+    def search_tools(query)
+      return { tools: list_tools } if query.nil? || query.empty?
+
+      normalized = query.downcase
+      tools = list_tools.select do |tool|
+        tool[:name].downcase.include?(normalized) || tool[:description].downcase.include?(normalized)
+      end
+
+      { tools: tools }
+    end
+
+    sig { returns(T::Array[T::Hash[Symbol, T.untyped]]) }
+    def list_tools
+      schemas.map { |schema| detailed_payload(schema) }
+    end
+
+    sig { returns(T::Array[T::Hash[Symbol, T.untyped]]) }
+    def list_summaries
+      schemas.map { |schema| summary_payload(schema) }
+    end
+
+    sig { params(tool_name: T.nilable(String)).returns(T::Hash[Symbol, T.untyped]) }
+    def get_tool(tool_name)
+      schema = find_schema(tool_name)
+      return { error: "Tool not found: #{tool_name}" } unless schema
+
+      { tool: detailed_payload(schema) }
+    end
+
+    sig { params(tool_name: T.nilable(String), arguments: T::Hash[T.untyped, T.untyped]).returns(T::Hash[Symbol, T.untyped]) }
+    def run_tool(tool_name, arguments)
+      schema = find_schema(tool_name)
+      return { error: "Tool not found: #{tool_name}" } unless schema
+
+      service_class = schema[:service_class]
+      result = service_class.new.public_send(schema[:entrypoint], **deep_symbolize(arguments))
+
+      { tool: summary_payload(schema), result: result }
+    rescue ArgumentError => e
+      { error: e.message }
+    end
+
+    sig { returns(T::Array[T::Hash[Symbol, T.untyped]]) }
+    def schemas
+      ToolMeta.registry.map { |service_class| ToolSchema::Builder.build(service_class) }
+    end
+
+    sig { params(tool_name: T.nilable(String)).returns(T.nilable(T::Hash[Symbol, T.untyped])) }
+    def find_schema(tool_name)
+      return nil if tool_name.nil? || tool_name.empty?
+
+      schemas.find { |schema| schema[:name] == tool_name }
+    end
+
+    sig { params(schema: T::Hash[Symbol, T.untyped]).returns(T::Hash[Symbol, T.untyped]) }
+    def summary_payload(schema)
+      {
+        name: schema[:name],
+        description: schema[:description],
+        usage: usage_string(schema)
+      }
+    end
+
+    sig { params(schema: T::Hash[Symbol, T.untyped]).returns(T::Hash[Symbol, T.untyped]) }
+    def detailed_payload(schema)
+      summary_payload(schema).merge(params: schema[:params], return_type: schema[:return_type])
+    end
+
+    sig { params(schema: T::Hash[Symbol, T.untyped]).returns(String) }
+    def usage_string(schema)
+      param_list = schema[:params].map { |param| param[:name].to_s }.join(', ')
+      "#{schema[:name]}(#{param_list})"
+    end
+
+    sig { params(name: String).returns(T.class_of(Object)) }
+    def constantize(name)
+      Object.const_get(name)
+    end
+
+    sig { params(value: T.untyped).returns(T.untyped) }
+    def deep_symbolize(value)
+      case value
+      when Hash
+        value.each_with_object({}) do |(key, nested), result|
+          symbol_key = key.is_a?(String) ? key.to_sym : key
+          result[symbol_key] = deep_symbolize(nested)
+        end
+      when Array
+        value.map { |element| deep_symbolize(element) }
+      else
+        value
+      end
+    end
+  end
+end