rails_mcp_engine 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f6c501b19758aada1c867684284621f255130d3d031aa39d4df44da9f3a79f93
-  data.tar.gz: e07a3da73bf2414648584e8a1eaa05b45e903d64151ec458dfd554c9ae15c0bd
+  metadata.gz: b2e3e700975a36670beecb72ac35ea09692525da7af72e60b0aada577a06c15f
+  data.tar.gz: 4a7bc04fd73423db8a1704705c3d9855aeaf997ff677244029e935cd04d50f01
 SHA512:
-  metadata.gz: 6a4df6b3b995f865c86ed8d648d1629207ad9a603033f4b74ecbfff58c9913550b90588ae71952fbec505b3b4699e1c6247c4b310e7f777a60c3167c32aadb5b
-  data.tar.gz: 76372d4ad6346c20b65306dc277e7daba2921089fe808e721258b5b6ecb3bb72ba8d1caf16e57f7be728ad0e77a5131ad0b6cbe22d1adbf86dd2ec64a66ec345
+  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
@@ -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,9 +73,9 @@ module RailsMcpEngine
       # The engine.rb defines ApplicationTool.
 
       # Re-using the logic from ManualController but adapting for Engine.
+
       ::Tools::MetaToolWriteService.new.register_tool(
         class_name,
-        source: source,
         before_call: ->(args) { Rails.logger.info("  [MCP] Request #{class_name}: #{args.inspect}") },
         after_call: ->(result) { Rails.logger.info("  [MCP] Response #{class_name}: #{result.inspect}") }
       )

data/app/services/tools/meta_tool_service.rb

@@ -133,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

@@ -11,25 +11,12 @@ module Tools
   class MetaToolWriteService
     extend T::Sig
 
-    sig { params(class_name: T.nilable(String), source: T.nilable(String), before_call: T.nilable(Proc), after_call: T.nilable(Proc)).returns(T::Hash[Symbol, T.untyped]) }
-    def register_tool(class_name, source: nil, before_call: nil, after_call: nil)
+    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?
 
-      # 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
-
-      begin
-        service_class = meta_service.constantize(class_name)
-      rescue NameError
-        return { error: "Could not find #{class_name}" }
-      end
-      
+      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)
@@ -45,6 +32,23 @@ module Tools
       { 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)
@@ -68,5 +72,72 @@ module Tools
     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.3.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.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Soonoh Jung