rails-mcp-server 1.1.4 → 1.2.1

data/lib/rails-mcp-server/extensions/resource_templating.rb

@@ -0,0 +1,182 @@
+module RailsMcpServer
+  module Extensions
+    # Extension module to add URI templating capabilities to FastMcp::Resource
+    # Uses module prepending for clean method override behavior
+    module ResourceTemplating
+      # Class methods to be prepended to the singleton class
+      module ClassMethods
+        attr_reader :template_params
+
+        def variabilized_uri(params = {})
+          addressable_template.partial_expand(params).pattern
+        end
+
+        def addressable_template
+          @addressable_template ||= Addressable::Template.new(uri)
+        end
+
+        def template_variables
+          addressable_template.variables
+        end
+
+        def templated?
+          template_variables.any?
+        end
+
+        def non_templated?
+          !templated?
+        end
+
+        def match(uri)
+          addressable_template.match(uri)
+        end
+
+        def initialize_from_uri(uri)
+          new(params_from_uri(uri))
+        end
+
+        def params_from_uri(uri)
+          match(uri).mapping.transform_keys(&:to_sym)
+        end
+
+        def instance(uri = self.uri)
+          @instances ||= {}
+          @instances[uri] ||= begin
+            resource_class = Class.new(self)
+            params = params_from_uri(uri)
+            resource_class.instance_variable_set(:@params, params)
+
+            resource_class.define_singleton_method(:instance) do
+              @instance ||= begin
+                instance = new
+                instance.instance_variable_set(:@params, params)
+                instance
+              end
+            end
+
+            resource_class.instance
+          end
+        end
+
+        def params
+          @params || {}
+        end
+
+        def name
+          return resource_name if resource_name
+          super
+        end
+
+        def metadata
+          if templated?
+            {
+              uriTemplate: uri,
+              name: resource_name,
+              description: description,
+              mimeType: mime_type
+            }.compact
+          else
+            super
+          end
+        end
+      end
+
+      # Instance methods to be prepended
+      module InstanceMethods
+        def initialize
+          @params = self.class.params
+          super if defined?(super)
+        end
+
+        def params
+          @params || self.class.params
+        end
+
+        def name
+          self.class.resource_name
+        end
+      end
+
+      # Called when this module is prepended to a class
+      def self.prepended(base)
+        base.singleton_class.prepend(ClassMethods)
+        base.prepend(InstanceMethods)
+      end
+    end
+
+    # Main setup class for resource extensions
+    class ResourceExtensionSetup
+      class << self
+        def setup!
+          return if @setup_complete
+
+          ensure_dependencies_loaded!
+          apply_extensions!
+
+          @setup_complete = true
+          RailsMcpServer.log(:info, "FastMcp::Resource extensions loaded successfully")
+        rescue => e
+          RailsMcpServer.log(:error, "Failed to setup resource extensions: #{e.message}")
+          raise
+        end
+
+        def reset!
+          @setup_complete = false
+        end
+
+        def setup_complete?
+          @setup_complete || false
+        end
+
+        private
+
+        def ensure_dependencies_loaded!
+          # Check that FastMcp::Resource exists
+          unless defined?(FastMcp::Resource)
+            begin
+              require "fast-mcp"
+            rescue LoadError => e
+              raise LoadError, "fast-mcp gem is required but not available. Ensure it's in your Gemfile: #{e.message}"
+            end
+          end
+
+          # Verify the expected interface exists
+          unless FastMcp::Resource.respond_to?(:uri)
+            raise "FastMcp::Resource doesn't have expected interface. Check fast-mcp gem version."
+          end
+
+          # Load addressable template dependency
+          begin
+            require "addressable/template"
+          rescue LoadError => e
+            raise LoadError, "addressable gem is required for URI templating: #{e.message}"
+          end
+
+          # Optional: Version checking
+          if defined?(FastMcp::VERSION)
+            version = Gem::Version.new(FastMcp::VERSION)
+            minimum_version = Gem::Version.new("1.4.0")
+
+            if version < minimum_version
+              RailsMcpServer.log(:warn, "FastMcp version #{FastMcp::VERSION} detected. Extensions tested with #{minimum_version}+")
+            end
+          end
+        end
+
+        def apply_extensions!
+          # Apply extensions to FastMcp::Resource
+          FastMcp::Resource.prepend(ResourceTemplating)
+
+          # Also ensure our BaseResource gets the extensions
+          if defined?(RailsMcpServer::BaseResource)
+            # BaseResource already inherits from FastMcp::Resource, so it gets extensions automatically
+            RailsMcpServer.log(:debug, "BaseResource will inherit templating extensions")
+          end
+
+          # Setup server extensions as well
+          RailsMcpServer::Extensions::ServerExtensionSetup.setup!
+        end
+      end
+    end
+  end
+end

data/lib/rails-mcp-server/extensions/server_templating.rb

@@ -0,0 +1,333 @@
+module RailsMcpServer
+  module Extensions
+    # Extension module to add any missing templated resource support to FastMcp::Server
+    # This version of the server already has most templated resource functionality
+    module ServerTemplating
+      # Instance methods to be prepended
+      module InstanceMethods
+        # The target server already has most functionality, but we can add defensive checks
+        def read_resource(uri)
+          # Handle both hash-based and array-based resource storage
+          if @resources.is_a?(Hash)
+            # First try exact match (hash lookup)
+            exact_match = @resources[uri]
+            return exact_match if exact_match
+
+            # Then try templated resource matching
+            @resources.values.find { |r| r.respond_to?(:match) && r.match(uri) }
+          else
+            # Array-based storage (original target server behavior)
+            resource = @resources.find { |r| r.respond_to?(:match) && r.match(uri) }
+
+            # Fallback: if no templated match, try exact URI match for backward compatibility
+            resource ||= @resources.find { |r| r.respond_to?(:uri) && r.uri == uri }
+
+            resource
+          end
+        end
+
+        # Add some defensive programming to handle_resources_read
+        def handle_resources_read(params, id)
+          uri = params["uri"]
+
+          return send_error(-32_602, "Invalid params: missing resource URI", id) unless uri
+
+          @logger.debug("Looking for resource with URI: #{uri}")
+
+          begin
+            resource = read_resource(uri)
+            return send_error(-32_602, "Resource not found: #{uri}", id) unless resource
+
+            # Defensive check for templated method
+            is_templated = resource.respond_to?(:templated?) ? resource.templated? : false
+            @logger.debug("Found resource: #{resource.respond_to?(:resource_name) ? resource.resource_name : resource.name}, templated: #{is_templated}")
+
+            base_content = {uri: uri}
+            base_content[:mimeType] = resource.mime_type if resource.mime_type
+
+            # Handle both templated and non-templated resources
+            resource_instance = if is_templated && resource.respond_to?(:instance)
+              resource.instance(uri)
+            else
+              # Fallback for non-templated resources or resources without instance method
+              resource.respond_to?(:instance) ? resource.instance : resource
+            end
+
+            # Defensive check for params method
+            if resource_instance.respond_to?(:params)
+              @logger.debug("Resource instance params: #{resource_instance.params.inspect}")
+            end
+
+            result = if resource_instance.respond_to?(:binary?) && resource_instance.binary?
+              {
+                contents: [base_content.merge(blob: Base64.strict_encode64(resource_instance.content))]
+              }
+            else
+              {
+                contents: [base_content.merge(text: resource_instance.content)]
+              }
+            end
+
+            send_result(result, id)
+          rescue => e
+            @logger.error("Error reading resource: #{e.message}")
+            @logger.error(e.backtrace.join("\n"))
+            send_error(-32_600, "Internal error reading resource: #{e.message}", id)
+          end
+        end
+
+        # The target server already has these methods, but we can add defensive checks
+        def handle_resources_list(id)
+          # Handle both hash-based and array-based resource storage
+          resources_collection = @resources.is_a?(Hash) ? @resources.values : @resources
+
+          resources_list = resources_collection.select do |resource|
+            !resource.respond_to?(:templated?) || resource.non_templated?
+          end.map(&:metadata) # rubocop:disable Performance/ChainArrayAllocation
+
+          send_result({resources: resources_list}, id)
+        end
+
+        def handle_resources_templates_list(id)
+          @logger.debug("Handling resources/templates/list request")
+
+          # Handle both hash-based and array-based resource storage
+          resources_collection = @resources.is_a?(Hash) ? @resources.values : @resources
+
+          templated_resources_list = resources_collection.select do |resource|
+            resource.respond_to?(:templated?) && resource.templated?
+          end.map do |resource| # rubocop:disable Performance/ChainArrayAllocation
+            metadata = resource.metadata
+            @logger.debug("Template resource metadata: #{metadata}")
+            metadata
+          end
+
+          @logger.info("Returning #{templated_resources_list.length} templated resources")
+          send_result({resourceTemplates: templated_resources_list}, id)
+        end
+
+        # Override handle_request to ensure resources/templates/list endpoint is available
+        def handle_request(*args)
+          # Extract arguments - handle different signatures
+          if args.length == 2
+            json_str, headers = args
+            headers ||= {}
+          else
+            json_str = args[0]
+            headers = {}
+          end
+
+          begin
+            request = JSON.parse(json_str)
+          rescue JSON::ParserError, TypeError
+            return send_error(-32_600, "Invalid Request", nil)
+          end
+
+          @logger.debug("Received request: #{request.inspect}")
+
+          # Check if it's a valid JSON-RPC 2.0 request
+          unless request["jsonrpc"] == "2.0" && request["method"]
+            return send_error(-32_600, "Invalid Request", request["id"])
+          end
+
+          method = request["method"]
+          params = request["params"] || {}
+          id = request["id"]
+
+          # Handle the resources/templates/list endpoint specifically since it might not exist in original
+          if method == "resources/templates/list"
+            @logger.debug("Handling resources/templates/list via extension")
+            return handle_resources_templates_list(id)
+          end
+
+          # For all other methods, call the original implementation
+          begin
+            super
+          rescue NoMethodError => e
+            # If super doesn't work, provide our own fallback
+            @logger.debug("Original handle_request not available, using fallback: #{e.message}")
+            handle_request_fallback(method, params, id, headers)
+          end
+        rescue => e
+          @logger.error("Error handling request: #{e.message}, #{e.backtrace.join("\n")}")
+          send_error(-32_600, "Internal error: #{e.message}", id)
+        end
+
+        private
+
+        def handle_request_fallback(method, params, id, headers)
+          @logger.debug("Using fallback handler for method: #{method}")
+
+          case method
+          when "ping"
+            send_result({}, id)
+          when "initialize"
+            handle_initialize(params, id)
+          when "notifications/initialized"
+            handle_initialized_notification
+          when "tools/list"
+            handle_tools_list(id)
+          when "tools/call"
+            # Handle different method signatures for tools/call
+            if method(:handle_tools_call).arity == 3
+              handle_tools_call(params, headers, id)
+            else
+              handle_tools_call(params, id)
+            end
+          when "resources/list"
+            handle_resources_list(id)
+          when "resources/templates/list"
+            handle_resources_templates_list(id)
+          when "resources/read"
+            handle_resources_read(params, id)
+          when "resources/subscribe"
+            handle_resources_subscribe(params, id)
+          when "resources/unsubscribe"
+            handle_resources_unsubscribe(params, id)
+          else
+            send_error(-32_601, "Method not found: #{method}", id)
+          end
+        end
+
+        # Add defensive programming to resource subscription methods
+        def handle_resources_subscribe(params, id)
+          return unless @client_initialized
+
+          uri = params["uri"]
+
+          unless uri
+            send_error(-32_602, "Invalid params: missing resource URI", id)
+            return
+          end
+
+          # Use the read_resource method which supports templated resources
+          resource = read_resource(uri)
+          return send_error(-32_602, "Resource not found: #{uri}", id) unless resource
+
+          # Add to subscriptions
+          @resource_subscriptions[uri] ||= []
+          @resource_subscriptions[uri] << id
+
+          send_result({subscribed: true}, id)
+        end
+
+        # Enhanced logging for resource registration
+        def register_resource(resource)
+          # Handle both hash-based and array-based resource storage
+          if @resources.is_a?(Hash)
+            @resources[resource.uri] = resource
+          else
+            @resources << resource
+          end
+
+          resource_name = if resource.respond_to?(:resource_name)
+            resource.resource_name
+          else
+            (resource.respond_to?(:name) ? resource.name : "Unknown")
+          end
+          is_templated = resource.respond_to?(:templated?) ? resource.templated? : false
+
+          @logger.debug("Registered resource: #{resource_name} (#{resource.uri}) - Templated: #{is_templated}")
+          resource.server = self if resource.respond_to?(:server=)
+
+          # Notify subscribers about the list change
+          notify_resource_list_changed if @transport
+
+          resource
+        end
+      end
+
+      # Called when this module is prepended to a class
+      def self.prepended(base)
+        base.prepend(InstanceMethods)
+      end
+    end
+
+    # Setup class for server extensions
+    class ServerExtensionSetup
+      class << self
+        def setup!
+          return if @setup_complete
+
+          ensure_dependencies_loaded!
+          check_server_compatibility!
+          apply_extensions_if_needed!
+
+          @setup_complete = true
+          RailsMcpServer.log(:info, "FastMcp::Server extensions checked and applied if needed")
+        rescue => e
+          RailsMcpServer.log(:error, "Failed to setup server extensions: #{e.message}")
+          raise
+        end
+
+        def reset!
+          @setup_complete = false
+        end
+
+        def setup_complete?
+          @setup_complete || false
+        end
+
+        private
+
+        def ensure_dependencies_loaded!
+          # Check that FastMcp::Server exists
+          unless defined?(FastMcp::Server)
+            begin
+              require "fast-mcp"
+            rescue LoadError => e
+              raise LoadError, "fast-mcp gem is required but not available: #{e.message}"
+            end
+          end
+
+          # Verify the expected interface exists
+          unless FastMcp::Server.instance_methods.include?(:read_resource)
+            raise "FastMcp::Server doesn't have expected read_resource method. Check fast-mcp gem version."
+          end
+
+          # Check handle_request method signature
+          handle_request_method = FastMcp::Server.instance_method(:handle_request)
+          arity = handle_request_method.arity
+          RailsMcpServer.log(:debug, "FastMcp::Server#handle_request arity: #{arity}")
+
+          # Check if resources/templates/list is already supported
+          test_server = FastMcp::Server.new(name: "test", version: "1.0.0")
+          has_templates_method = test_server.respond_to?(:handle_resources_templates_list)
+          RailsMcpServer.log(:debug, "Original server has handle_resources_templates_list: #{has_templates_method}")
+        end
+
+        def check_server_compatibility!
+          # Check if the server already has templated resource support
+          server_instance = FastMcp::Server.new(name: "test", version: "1.0.0")
+
+          @server_has_templates = server_instance.respond_to?(:handle_resources_templates_list)
+          @server_has_advanced_read = begin
+            # Check if read_resource method body includes 'match'
+            method_source = FastMcp::Server.instance_method(:read_resource).source_location
+            method_source ? true : false
+          rescue
+            false
+          end
+
+          RailsMcpServer.log(:debug, "Server template support detected: #{@server_has_templates}")
+          RailsMcpServer.log(:debug, "Server advanced read support detected: #{@server_has_advanced_read}")
+        end
+
+        def apply_extensions_if_needed!
+          # Always apply extensions to ensure resources/templates/list endpoint is available
+          # The MCP inspector error shows this endpoint is missing
+          RailsMcpServer.log(:info, "Applying server extensions to ensure full MCP compliance")
+          FastMcp::Server.prepend(ServerTemplating)
+
+          # Verify the extension was applied by checking if our methods are available
+          test_server = FastMcp::Server.new(name: "test", version: "1.0.0")
+          has_templates_list = test_server.respond_to?(:handle_resources_templates_list)
+          RailsMcpServer.log(:info, "Server extension verification - handle_resources_templates_list available: #{has_templates_list}")
+        rescue => e
+          RailsMcpServer.log(:error, "Error applying server extensions: #{e.message}")
+          raise
+        end
+      end
+    end
+  end
+end

data/lib/rails-mcp-server/helpers/resource_base.rb

@@ -0,0 +1,143 @@
+require "fileutils"
+require "digest"
+require "yaml"
+
+module RailsMcpServer
+  class ResourceBase
+    attr_reader :resource_name, :config_dir, :resource_folder, :manifest_file
+
+    def initialize(resource_name, config_dir:, force: false, verbose: false)
+      @resource_name = resource_name.to_s
+      @config_dir = config_dir
+      @force = force
+      @verbose = verbose
+      setup_paths
+    end
+
+    protected
+
+    def setup_paths
+      @resource_folder = File.join(@config_dir, "resources", @resource_name)
+      @manifest_file = File.join(@resource_folder, "manifest.yaml")
+    end
+
+    def setup_directories
+      FileUtils.mkdir_p(@resource_folder)
+    end
+
+    def load_manifest
+      @manifest = if File.exist?(@manifest_file)
+        YAML.load_file(@manifest_file)
+      else
+        create_manifest
+      end
+    end
+
+    def save_manifest
+      @manifest["updated_at"] = Time.now.to_s
+      File.write(@manifest_file, @manifest.to_yaml)
+    end
+
+    def file_unchanged?(filename, file_path)
+      return false unless File.exist?(file_path)
+      current_hash = file_hash(file_path)
+      @manifest["files"][filename] && @manifest["files"][filename]["hash"] == current_hash
+    end
+
+    def save_file_to_manifest(filename, file_path, additional_data = {})
+      metadata = extract_metadata(File.read(file_path), filename)
+
+      @manifest["files"][filename] = {
+        "hash" => file_hash(file_path),
+        "size" => File.size(file_path)
+      }.merge(timestamp_key => Time.now.to_s)
+        .merge(additional_data)
+        .merge(metadata)
+    end
+
+    def extract_metadata(content, filename = nil)
+      metadata = {}
+
+      title = find_title(content) || (filename ? humanize_filename(filename) : nil)
+      metadata["title"] = title if title
+
+      description = find_description(content)
+      metadata["description"] = description if description && !description.empty?
+
+      metadata
+    end
+
+    def find_title(content)
+      lines = content.lines
+
+      # H1 header
+      lines.each do |line|
+        return $1.strip if line.strip =~ /^#\s+(.+)$/
+      end
+
+      # Underlined title
+      lines.each_with_index do |line, index|
+        next if index >= lines.length - 1
+        return line.strip if /^=+$/.match?(lines[index + 1].strip)
+      end
+
+      nil
+    end
+
+    def find_description(content)
+      # Clean content
+      clean = content.dup
+      clean = clean.sub(/^---\s*\n.*?\n---\s*\n/m, "") # Remove YAML frontmatter
+      clean = clean.gsub(/^#\s+.*?\n/, "") # Remove H1 headers
+      clean = clean.gsub(/^.+\n=+\s*\n/, "") # Remove underlined titles
+      clean = clean.strip.gsub(/\n+/, " ").gsub(/\s+/, " ")
+
+      return "" if clean.empty?
+
+      if clean.length > 200
+        truncate_at = clean.rindex(" ", 200) || 200
+        clean[0...truncate_at] + "..."
+      else
+        clean
+      end
+    end
+
+    def humanize_filename(filename)
+      base = File.basename(filename, File.extname(filename))
+
+      title = base.gsub(/[_-]/, " ")
+        .gsub(/^\d+[.\-_\s]*/, "")
+        .split(" ").map(&:capitalize).join(" ")
+
+      # Common abbreviations
+      replacements = {
+        /\bApi\b/ => "API", /\bHtml\b/ => "HTML", /\bCss\b/ => "CSS",
+        /\bJs\b/ => "JavaScript", /\bUi\b/ => "UI", /\bUrl\b/ => "URL",
+        /\bRest\b/ => "REST", /\bJson\b/ => "JSON", /\bXml\b/ => "XML",
+        /\bSql\b/ => "SQL"
+      }
+
+      replacements.each { |pattern, replacement| title = title.gsub(pattern, replacement) }
+
+      title.strip.empty? ? "Untitled Guide" : title
+    end
+
+    def file_hash(file_path)
+      Digest::SHA256.file(file_path).hexdigest
+    end
+
+    def log(message, newline: true)
+      return unless @verbose
+      newline ? puts(message) : print(message)
+    end
+
+    # Abstract methods to be implemented by subclasses
+    def create_manifest
+      raise NotImplementedError
+    end
+
+    def timestamp_key
+      raise NotImplementedError
+    end
+  end
+end