rails-mcp-server 1.2.3 → 1.4.0

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

@@ -1,333 +0,0 @@
-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/tools/analyze_controller_views.rb

@@ -1,239 +0,0 @@
-module RailsMcpServer
-  class AnalyzeControllerViews < BaseTool
-    tool_name "analyze_controller_views"
-
-    description "Analyze the relationships between controllers, their actions, and corresponding views to understand the application's UI flow."
-
-    arguments do
-      optional(:controller_name).filled(:string).description("Name of a specific controller to analyze (e.g., 'UsersController' or 'users'). If omitted, all controllers will be analyzed.")
-    end
-
-    def call(controller_name: nil)
-      unless current_project
-        message = "No active project. Please switch to a project first."
-        log(:warn, message)
-
-        return message
-      end
-
-      # Find all controllers
-      controllers_dir = File.join(active_project_path, "app", "controllers")
-      unless File.directory?(controllers_dir)
-        message = "Controllers directory not found at app/controllers."
-        log(:warn, message)
-
-        return message
-      end
-
-      # Get all controller files
-      controller_files = Dir.glob(File.join(controllers_dir, "**", "*_controller.rb"))
-
-      if controller_files.empty?
-        message = "No controllers found in the project."
-        log(:warn, message)
-
-        return message
-      end
-
-      # If a specific controller was requested, filter the files
-      if controller_name
-        # Normalize controller name (allow both 'users' and 'UsersController')
-        controller_name = "#{controller_name.sub(/_?controller$/i, "").downcase}_controller.rb"
-        controller_files = controller_files.select { |f| File.basename(f).downcase == controller_name }
-
-        if controller_files.empty?
-          message = "Controller '#{controller_name}' not found."
-          log(:warn, message)
-
-          return message
-        end
-      end
-
-      # Parse controllers to extract actions
-      controllers_data = {}
-
-      controller_files.each do |file_path|
-        file_content = File.read(file_path)
-        controller_class = File.basename(file_path, ".rb").gsub(/_controller$/i, "").then { |s| camelize(s) } + "Controller"
-
-        # Extract controller actions (methods that are not private/protected)
-        actions = []
-        action_matches = file_content.scan(/def\s+([a-zA-Z0-9_]+)/).flatten
-
-        # Find where private/protected begins
-        private_index = file_content =~ /^\s*(private|protected)/
-
-        if private_index
-          # Get the actions defined before private/protected
-          private_content = file_content[private_index..-1]
-          private_methods = private_content.scan(/def\s+([a-zA-Z0-9_]+)/).flatten
-          actions = action_matches - private_methods
-        else
-          actions = action_matches
-        end
-
-        # Remove Rails controller lifecycle methods
-        lifecycle_methods = %w[initialize action_name controller_name params response]
-        actions -= lifecycle_methods
-
-        # Get routes mapped to this controller
-        routes_output = RailsMcpServer::RunProcess.execute_rails_command(
-          active_project_path,
-          "bin/rails routes -c #{controller_class}"
-        )
-
-        routes = {}
-        if routes_output && !routes_output.empty?
-          routes_output.split("\n").each do |line|
-            next if line.include?("(erb):") || line.include?("Prefix") || line.strip.empty?
-            parts = line.strip.split(/\s+/)
-            if parts.size >= 4
-              # Get action name from the rails routes output
-              action = parts[1].to_s.strip.downcase
-              if actions.include?(action)
-                verb = parts[0].to_s.strip
-                path = parts[2].to_s.strip
-                routes[action] = {verb: verb, path: path}
-              end
-            end
-          end
-        end
-
-        # Find views for each action
-        views_dir = File.join(active_project_path, "app", "views", File.basename(file_path, "_controller.rb"))
-        views = {}
-
-        if File.directory?(views_dir)
-          actions.each do |action|
-            # Look for view templates with various extensions
-            view_files = Dir.glob(File.join(views_dir, "#{action}.*"))
-            if view_files.any?
-              views[action] = {
-                templates: view_files.map { |f| f.sub("#{active_project_path}/", "") },
-                partials: []
-              }
-
-              # Look for partials used in this template
-              view_files.each do |view_file|
-                if File.file?(view_file)
-                  view_content = File.read(view_file)
-                  # Find render calls with partials
-                  partial_matches = view_content.scan(/render\s+(?:partial:|:partial\s+=>\s+|:partial\s*=>|partial:)\s*["']([^"']+)["']/).flatten
-                  views[action][:partials] += partial_matches if partial_matches.any?
-
-                  # Find instance variables used in the view
-                  instance_vars = view_content.scan(/@([a-zA-Z0-9_]+)/).flatten.uniq # rubocop:disable Performance/ChainArrayAllocation
-                  views[action][:instance_variables] = instance_vars if instance_vars.any?
-
-                  # Look for Stimulus controllers
-                  stimulus_controllers = view_content.scan(/data-controller="([^"]+)"/).flatten.uniq # rubocop:disable Performance/ChainArrayAllocation
-                  views[action][:stimulus_controllers] = stimulus_controllers if stimulus_controllers.any?
-                end
-              end
-            end
-          end
-        end
-
-        # Extract instance variables set in the controller action
-        instance_vars_in_controller = {}
-        actions.each do |action|
-          # Find the action method in the controller
-          action_match = file_content.match(/def\s+#{action}\b(.*?)(?:(?:def|private|protected|public)\b|\z)/m)
-          if action_match && action_match[1]
-            action_body = action_match[1]
-            # Find instance variable assignments
-            vars = action_body.scan(/@([a-zA-Z0-9_]+)\s*=/).flatten.uniq # rubocop:disable Performance/ChainArrayAllocation
-            instance_vars_in_controller[action] = vars if vars.any?
-          end
-        end
-
-        controllers_data[controller_class] = {
-          file: file_path.sub("#{active_project_path}/", ""),
-          actions: actions,
-          routes: routes,
-          views: views,
-          instance_variables: instance_vars_in_controller
-        }
-      rescue => e
-        log(:error, "Error parsing controller #{file_path}: #{e.message}")
-      end
-
-      # Format the output
-      output = []
-
-      controllers_data.each do |controller, data|
-        output << "Controller: #{controller}"
-        output << "  File: #{data[:file]}"
-        output << "  Actions: #{data[:actions].size}"
-
-        data[:actions].each do |action|
-          output << "    Action: #{action}"
-
-          # Show route if available
-          if data[:routes] && data[:routes][action]
-            route = data[:routes][action]
-            output << "      Route: [#{route[:verb]}] #{route[:path]}"
-          else
-            output << "      Route: Not mapped to a route"
-          end
-
-          # Show view templates if available
-          if data[:views] && data[:views][action]
-            view_data = data[:views][action]
-
-            output << "      View Templates:"
-            view_data[:templates].each do |template|
-              output << "        - #{template}"
-            end
-
-            # Show partials
-            if view_data[:partials]&.any?
-              output << "      Partials Used:"
-              view_data[:partials].uniq.each do |partial|
-                output << "        - #{partial}"
-              end
-            end
-
-            # Show Stimulus controllers
-            if view_data[:stimulus_controllers]&.any?
-              output << "      Stimulus Controllers:"
-              view_data[:stimulus_controllers].each do |controller|
-                output << "        - #{controller}"
-              end
-            end
-
-            # Show instance variables used in views
-            if view_data[:instance_variables]&.any?
-              output << "      Instance Variables Used in View:"
-              view_data[:instance_variables].sort.each do |var|
-                output << "        - @#{var}"
-              end
-            end
-          else
-            output << "      View: No view template found"
-          end
-
-          # Show instance variables set in controller
-          if data[:instance_variables] && data[:instance_variables][action]
-            output << "      Instance Variables Set in Controller:"
-            data[:instance_variables][action].sort.each do |var|
-              output << "        - @#{var}"
-            end
-          end
-
-          output << ""
-        end
-
-        output << "-------------------------"
-      end
-
-      output.join("\n")
-    end
-
-    private
-
-    def camelize(string)
-      string.split("_").map(&:capitalize).join
-    end
-  end
-end