rails_mcp_engine 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 46864199e9aea2b6d1e7b9b9c065109f3f70a012c35cc68a632a8fe39fd1ff06
-  data.tar.gz: a3cbbe5460b4c2d36e84a1d25fa3481e82ab678d1cd12dfef083819db352feb4
+  metadata.gz: b2e3e700975a36670beecb72ac35ea09692525da7af72e60b0aada577a06c15f
+  data.tar.gz: 4a7bc04fd73423db8a1704705c3d9855aeaf997ff677244029e935cd04d50f01
 SHA512:
-  metadata.gz: a7f7134090f0de5dfb89878baf43ae74e6d5c0d9b9020744cdf4673f49e3daed9e0128e6d80c33d3e6fda0cd12af6b4e43e99307d6e44b817a88cf28e1952487
-  data.tar.gz: c7eb6c1be9166b14e06341b5ab10a097345fceb88790fceb432c20e09d0c3d707066f9d756e0e30aaa411e1f7d48d0d75f0e7b572ddc1d2cad897ec7987056c5
+  metadata.gz: d3be894c46aa48a2a14116d77d6d5427df142ed026f89da13a3042c2ff7e935daa91ddd78f3e1a36702025926bbc9ff6f74e0bf249d4ce74f9861d99c92c55fe
+  data.tar.gz: 99c99e5a1e62477b9b0f24d01598e4738a032d4ae9bc2317b56326e05a5e29cc51679a770a33f50e7d01968d3653496bf197d9e1bbd90fb5fbfb578317b8321b

data/app/controllers/rails_mcp_engine/playground_controller.rb

@@ -12,14 +12,11 @@ module RailsMcpEngine
 
     def register
       source = params[:source].to_s
-      class_name = extract_class_name(source)
 
       result = if source.strip.empty?
                  { error: 'Tool source code is required' }
-               elsif class_name.nil?
-                 { error: 'Could not infer class name from the provided source' }
                else
-                 register_source(source, class_name)
+                 register_source(source)
                end
 
       flash[:register_result] = result
@@ -50,7 +47,7 @@ module RailsMcpEngine
       result = if schema.nil?
                  { error: "Tool not found: #{tool_name}" }
                else
-                 delete_tool_from_registry(schema[:service_class])
+                 delete_tool_from_registry(tool_name)
                end
 
       flash[:register_result] = result
@@ -63,70 +60,7 @@ module RailsMcpEngine
       ToolMeta.registry.map { |service_class| ToolSchema::Builder.build(service_class) }
     end
 
-    def extract_class_name(source)
-      require 'ripper'
-      sexp = Ripper.sexp(source)
-      return nil unless sexp
-
-      # sexp is [:program, statements]
-      statements = sexp[1]
-      find_class(statements, [])
-    end
-
-    def find_class(statements, namespace)
-      return nil unless statements.is_a?(Array)
-
-      statements.each do |stmt|
-        next unless stmt.is_a?(Array)
-
-        case stmt.first
-        when :module
-          # [:module, const_ref, body]
-          # body is [:bodystmt, statements, ...]
-          const_node = stmt[1]
-          const_name = get_const_name(const_node)
-
-          body_stmt = stmt[2]
-          inner_statements = body_stmt[1]
-
-          result = find_class(inner_statements, namespace + [const_name])
-          return result if result
-        when :class
-          # [:class, const_ref, superclass, body]
-          const_node = stmt[1]
-          const_name = get_const_name(const_node)
-
-          return (namespace + [const_name]).join('::')
-        end
-      end
-      nil
-    end
-
-    def get_const_name(node)
-      return nil unless node.is_a?(Array)
-
-      type = node.first
-      if type == :const_ref
-        # [:const_ref, [:@const, "Name", ...]]
-        node[1][1]
-      elsif type == :const_path_ref
-        # [:const_path_ref, parent, child]
-        parent = node[1]
-        child = node[2] # [:@const, "Name", ...]
-
-        parent_name = if parent.first == :var_ref
-                        parent[1][1]
-                      else
-                        get_const_name(parent)
-                      end
-
-        "#{parent_name}::#{child[1]}"
-      else
-        nil
-      end
-    end
-
-    def register_source(source, class_name)
+    def register_source(source)
       Object.class_eval(source)
       # Use the engine's namespace or ensure Tools is available.
       # Assuming Tools module is defined in the host app or globally.
@@ -139,7 +73,8 @@ module RailsMcpEngine
       # The engine.rb defines ApplicationTool.
 
       # Re-using the logic from ManualController but adapting for Engine.
-      ::Tools::MetaToolService.new.register_tool(
+
+      ::Tools::MetaToolWriteService.new.register_tool(
         class_name,
         before_call: ->(args) { Rails.logger.info("  [MCP] Request #{class_name}: #{args.inspect}") },
         after_call: ->(result) { Rails.logger.info("  [MCP] Response #{class_name}: #{result.inspect}") }
@@ -168,14 +103,8 @@ module RailsMcpEngine
       { error: e.message }
     end
 
-    def delete_tool_from_registry(service_class)
-      ToolMeta.registry.delete(service_class)
-
-      # Also remove the RubyLLM tool class constant
-      tool_constant = ToolSchema::RubyLlmFactory.tool_class_name(service_class)
-      ::Tools.send(:remove_const, tool_constant) if ::Tools.const_defined?(tool_constant, false)
-
-      { success: 'Tool deleted successfully' }
+    def delete_tool_from_registry(tool_name)
+      ::Tools::MetaToolWriteService.new.delete_tool(tool_name)
     rescue StandardError => e
       { error: e.message }
     end

data/app/services/tools/meta_tool_service.rb

@@ -44,26 +44,7 @@ module Tools
       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
 
     sig { params(tool_names: T::Array[String]).returns(T::Array[T.class_of(Object)]) }
     def self.ruby_llm_tools(tool_names)
@@ -76,7 +57,6 @@ module Tools
       end
     end
 
-    private
 
     sig { params(query: T.nilable(String)).returns(T::Hash[Symbol, T.untyped]) }
     def search_tools(query)
@@ -153,11 +133,6 @@ module Tools
       "#{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

data/app/services/tools/meta_tool_write_service.rb

@@ -0,0 +1,143 @@
+# 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 MetaToolWriteService
+    extend T::Sig
+
+    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: meta_service.summary_payload(schema) }
+    rescue ToolMeta::MissingSignatureError => e
+      { error: e.message }
+    rescue NameError => e
+      { error: "Could not find #{class_name}: #{e.message}" }
+    end
+
+    sig { params(source: T.nilable(String), before_call: T.nilable(Proc), after_call: T.nilable(Proc)).returns(T::Hash[Symbol, T.untyped]) }
+    def register_tool_from_source(source: nil, before_call: nil, after_call: nil)
+      class_name = extract_class_name(source)
+      return { error: 'class_name is required for register' } if class_name.nil? || class_name.empty?
+
+      # If source is provided, evaluate it first
+      if source
+        begin
+          Object.class_eval(source)
+        rescue StandardError => e
+          return { error: "Failed to evaluate source: #{e.message}" }
+        end
+      end
+
+      register_tool(class_name, before_call: before_call, after_call: after_call)
+    end
+
+    sig { params(tool_name: String).returns(T::Hash[Symbol, T.untyped]) }
+    def delete_tool(tool_name)
+      schema = meta_service.find_schema(tool_name)
+      return { error: "Tool not found: #{tool_name}" } unless schema
+
+      service_class = schema[:service_class]
+      ToolMeta.registry.delete(service_class)
+
+      tool_constant = ToolSchema::RubyLlmFactory.tool_class_name(service_class)
+      Tools.send(:remove_const, tool_constant) if Tools.const_defined?(tool_constant, false)
+      fast_mcp_constant = ToolSchema::FastMcpFactory.tool_class_name(service_class)
+      Mcp.send(:remove_const, fast_mcp_constant) if Mcp.const_defined?(fast_mcp_constant, false)
+
+      { success: 'Tool deleted successfully' }
+    rescue StandardError => e
+      { error: e.message }
+    end
+
+    private
+
+    def meta_service
+      @meta_service ||= Tools::MetaToolService.new
+    end
+
+    def extract_class_name(source)
+      require 'ripper'
+      sexp = Ripper.sexp(source)
+      return nil unless sexp
+
+      # sexp is [:program, statements]
+      statements = sexp[1]
+      find_class(statements, [])
+    end
+
+    def find_class(statements, namespace)
+      return nil unless statements.is_a?(Array)
+
+      statements.each do |stmt|
+        next unless stmt.is_a?(Array)
+
+        case stmt.first
+        when :module
+          # [:module, const_ref, body]
+          # body is [:bodystmt, statements, ...]
+          const_node = stmt[1]
+          const_name = get_const_name(const_node)
+
+          body_stmt = stmt[2]
+          inner_statements = body_stmt[1]
+
+          result = find_class(inner_statements, namespace + [const_name])
+          return result if result
+        when :class
+          # [:class, const_ref, superclass, body]
+          const_node = stmt[1]
+          const_name = get_const_name(const_node)
+
+          return (namespace + [const_name]).join('::')
+        end
+      end
+      nil
+    end
+
+    def get_const_name(node)
+      return nil unless node.is_a?(Array)
+
+      type = node.first
+      if type == :const_ref
+        # [:const_ref, [:@const, "Name", ...]]
+        node[1][1]
+      elsif type == :const_path_ref
+        # [:const_path_ref, parent, child]
+        parent = node[1]
+        child = node[2] # [:@const, "Name", ...]
+
+        parent_name = if parent.first == :var_ref
+                        parent[1][1]
+                      else
+                        get_const_name(parent)
+                      end
+
+        "#{parent_name}::#{child[1]}"
+      else
+        nil
+      end
+    end
+
+    def constantize(name)
+      Object.const_get(name)
+    end
+  end
+end

data/lib/rails_mcp_engine/version.rb

@@ -1,3 +1,3 @@
 module RailsMcpEngine
-  VERSION = '0.2.0'
+  VERSION = '0.4.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_mcp_engine
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Soonoh Jung
@@ -92,6 +92,7 @@ files:
 - app/lib/tool_schema/ruby_llm_factory.rb
 - app/lib/tool_schema/sorbet_type_mapper.rb
 - app/services/tools/meta_tool_service.rb
+- app/services/tools/meta_tool_write_service.rb
 - app/views/rails_mcp_engine/chat/show.html.erb
 - app/views/rails_mcp_engine/playground/show.html.erb
 - config/routes.rb