context_drop 0.1.0

data/lib/context_drop/mcp/dispatcher.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+require "json"
+
+module ContextDrop
+  module MCP
+    class Dispatcher
+      PROTOCOL_VERSION = "2025-03-26"
+
+      TOOLS = {
+        "list_feedbacks" => ContextDrop::MCP::Tools::ListFeedbacks,
+        "get_feedback" => ContextDrop::MCP::Tools::GetFeedback,
+        "get_feedback_attachment" => ContextDrop::MCP::Tools::GetFeedbackAttachment,
+        "update_feedback_status" => ContextDrop::MCP::Tools::UpdateFeedbackStatus
+      }.freeze
+
+      PROMPTS = {
+        "investigate_feedback" => ContextDrop::MCP::Prompts::InvestigateFeedback
+      }.freeze
+
+      RESOURCES = [
+        {
+          uri: "contextdrop://feedbacks/new",
+          name: "Unresolved New Feedbacks",
+          description: "List of all ContextDrop feedback records currently in 'new' status.",
+          mimeType: "application/json"
+        }
+      ].freeze
+
+      RESOURCE_TEMPLATES = [
+        {
+          uriTemplate: "contextdrop://feedbacks/{id}",
+          name: "Feedback Record by ID",
+          description: "Full ContextDrop feedback submission, DOM element snapshots, and attachment metadata for a specific ID.",
+          mimeType: "application/json"
+        }
+      ].freeze
+
+      class << self
+        def call(raw_message)
+          if raw_message.is_a?(Array)
+            responses = raw_message.filter_map { |item| dispatch_single(item) }
+            return responses.empty? ? nil : responses
+          end
+
+          dispatch_single(raw_message)
+        end
+
+        private
+
+        def dispatch_single(msg)
+          unless msg.is_a?(Hash)
+            return jsonrpc_error(nil, -32_600, "Invalid Request: expected JSON object")
+          end
+
+          req = msg.transform_keys(&:to_s)
+          id = req["id"]
+          method = req["method"].to_s
+          params = req["params"].is_a?(Hash) ? req["params"].transform_keys(&:to_s) : {}
+
+          # Notifications have no `id` and expect no response
+          return nil if method.start_with?("notifications/") || (id.nil? && !req.key?("id"))
+
+          case method
+          when "initialize"
+            client_version = params["protocolVersion"].to_s.strip
+            negotiated_version = client_version.empty? ? PROTOCOL_VERSION : client_version
+            jsonrpc_result(id, {
+              protocolVersion: negotiated_version,
+              capabilities: {
+                tools: { listChanged: false },
+                resources: { subscribe: false, listChanged: false },
+                prompts: { listChanged: false }
+              },
+              serverInfo: {
+                name: "context_drop",
+                version: ContextDrop::VERSION
+              }
+            })
+          when "ping"
+            jsonrpc_result(id, {})
+          when "tools/list"
+            jsonrpc_result(id, {
+              tools: TOOLS.values.map { |tool_cls| tool_cls::DEFINITION }
+            })
+          when "tools/call"
+            handle_tool_call(id, params)
+          when "resources/list"
+            jsonrpc_result(id, { resources: RESOURCES })
+          when "resources/templates/list"
+            jsonrpc_result(id, { resourceTemplates: RESOURCE_TEMPLATES })
+          when "resources/read"
+            handle_resource_read(id, params)
+          when "prompts/list"
+            jsonrpc_result(id, {
+              prompts: PROMPTS.values.map { |prompt_cls| prompt_cls::DEFINITION }
+            })
+          when "prompts/get"
+            handle_prompt_get(id, params)
+          else
+            jsonrpc_error(id, -32_601, "Method not found: #{method}")
+          end
+        rescue StandardError => e
+          jsonrpc_error(id, -32_603, "Internal error: #{e.message}")
+        end
+
+        def handle_tool_call(id, params)
+          tool_name = params["name"].to_s
+          tool_cls = TOOLS[tool_name]
+          unless tool_cls
+            return jsonrpc_error(id, -32_602, "Unknown tool: #{tool_name}")
+          end
+
+          arguments = params["arguments"].is_a?(Hash) ? params["arguments"] : {}
+          result = tool_cls.call(arguments)
+          jsonrpc_result(id, result)
+        end
+
+        def handle_resource_read(id, params)
+          uri = params["uri"].to_s.strip
+          case uri
+          when "contextdrop://feedbacks/new"
+            records = ContextDrop::Feedback
+                      .includes(:submitter, :element_references, :attachments)
+                      .new_records
+                      .recent
+                      .limit(50)
+                      .map { |fb| ContextDrop::MCP::Tools::ListFeedbacks.serialize_summary(fb) }
+            jsonrpc_result(id, {
+              contents: [
+                {
+                  uri: uri,
+                  mimeType: "application/json",
+                  text: JSON.pretty_generate(feedbacks: records)
+                }
+              ]
+            })
+          when %r{\Acontextdrop://feedbacks/(\d+)\z}
+            feedback_id = Regexp.last_match(1)
+            feedback = ContextDrop::Feedback
+                       .includes(:submitter, :element_references, :attachments)
+                       .find_by(id: feedback_id)
+            unless feedback
+              return jsonrpc_error(id, -32_602, "Feedback ##{feedback_id} not found")
+            end
+
+            payload = ContextDrop::MCP::Tools::GetFeedback.serialize_feedback(feedback)
+            jsonrpc_result(id, {
+              contents: [
+                {
+                  uri: uri,
+                  mimeType: "application/json",
+                  text: JSON.pretty_generate(payload)
+                }
+              ]
+            })
+          else
+            jsonrpc_error(id, -32_602, "Unknown resource URI: #{uri}")
+          end
+        end
+
+        def handle_prompt_get(id, params)
+          prompt_name = params["name"].to_s
+          prompt_cls = PROMPTS[prompt_name]
+          unless prompt_cls
+            return jsonrpc_error(id, -32_602, "Unknown prompt: #{prompt_name}")
+          end
+
+          arguments = params["arguments"].is_a?(Hash) ? params["arguments"] : {}
+          result = prompt_cls.call(arguments)
+          jsonrpc_result(id, result)
+        rescue ContextDrop::Error => e
+          jsonrpc_error(id, -32_602, e.message)
+        end
+
+        def jsonrpc_result(id, result)
+          {
+            jsonrpc: "2.0",
+            id: id,
+            result: result
+          }
+        end
+
+        def jsonrpc_error(id, code, message)
+          {
+            jsonrpc: "2.0",
+            id: id,
+            error: {
+              code: code,
+              message: message
+            }
+          }
+        end
+      end
+    end
+  end
+end

data/lib/context_drop/mcp/prompts/investigate_feedback.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module ContextDrop
+  module MCP
+    module Prompts
+      class InvestigateFeedback
+        DEFINITION = {
+          name: "investigate_feedback",
+          description: "Generate a structured investigation brief for a ContextDrop feedback record, including its originating URL, DOM element selectors/paths, and visual screenshots.",
+          arguments: [
+            {
+              name: "feedback_id",
+              description: "ID of the ContextDrop::Feedback record to investigate.",
+              required: true
+            }
+          ]
+        }.freeze
+
+        def self.call(args = {})
+          params = args.is_a?(Hash) ? args.transform_keys(&:to_s) : {}
+          feedback_id = params["feedback_id"] || params["id"]
+          raise ContextDrop::Error, "Missing required argument: feedback_id" if feedback_id.nil? || feedback_id.to_s.strip.empty?
+
+          feedback = ContextDrop::Feedback
+                     .includes(:submitter, :element_references, :attachments)
+                     .find_by(id: feedback_id)
+          raise ContextDrop::Error, "Feedback ##{feedback_id} not found" unless feedback
+
+          element_lines = if feedback.element_references.any?
+                            feedback.element_references.map.with_index(1) do |el, idx|
+                              <<~EL.strip
+                                #{idx}. `<#{el.tag_name}>` — Selector: `#{el.selector}`
+                                   - DOM Path: `#{el.dom_path || 'N/A'}`
+                                   - Visible Text: #{el.text_content.inspect}
+                                   - Bounding Box: `#{JSON.generate(el.bounding_rect || {})}`
+                                   - Attributes: `#{JSON.generate(el.attributes_snapshot || {})}`
+                              EL
+                            end.join("\n")
+                          else
+                            "None selected."
+                          end
+
+          instructions = <<~PROMPT
+            Investigate and resolve ContextDrop Feedback ##{feedback.id} (status: #{feedback.status}).
+
+            ## Reported Feedback
+            - **Message:** #{feedback.message.presence || '(No text message provided)'}
+            - **Originating Page URL:** `#{feedback.page_url}`
+            - **Submitter:** #{feedback.submitter_label}
+            - **Submitted At:** #{feedback.created_at&.iso8601}
+            - **Viewport / Metadata:** `#{JSON.generate(feedback.metadata || {})}`
+
+            ## Attached DOM Element References
+            #{element_lines}
+
+            ## Recommended Investigation Steps
+            1. Locate the Rails route and controller action corresponding to `#{feedback.page_url}` in `config/routes.rb` and `app/controllers/`.
+            2. Search the view templates (`app/views/`, ViewComponents, or frontend components) for the attached DOM selectors (`#{feedback.element_references.map(&:selector).join(', ')}`) and structural DOM paths (`#{feedback.element_references.map(&:dom_path).compact.join(', ')}`).
+            3. Inspect any attached screenshots (`get_feedback` with `id: #{feedback.id}`) to verify the visual layout issue.
+            4. Propose and verify a fix, then call `update_feedback_status` (`id: #{feedback.id}`, `status: "resolved"`) once complete.
+          PROMPT
+
+          message_content = [{ type: "text", text: instructions }]
+
+          feedback.attachments.each do |att|
+            img_block = ContextDrop::MCP::Tools::GetFeedback.build_image_content_block(att)
+            message_content << img_block if img_block
+          end
+
+          {
+            description: "Investigation brief for ContextDrop Feedback ##{feedback.id} on #{feedback.page_url}",
+            messages: [
+              {
+                role: "user",
+                content: message_content.size == 1 ? message_content.first : message_content
+              }
+            ]
+          }
+        end
+      end
+    end
+  end
+end

data/lib/context_drop/mcp/server.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "tools/list_feedbacks"
+require_relative "tools/get_feedback"
+require_relative "tools/get_feedback_attachment"
+require_relative "tools/update_feedback_status"
+require_relative "prompts/investigate_feedback"
+require_relative "dispatcher"
+require_relative "stdio_runner"
+
+module ContextDrop
+  module MCP
+    class Server
+      class << self
+        def handle_http_payload(payload)
+          Dispatcher.call(payload)
+        end
+
+        def run_stdio(input: $stdin, output: $stdout, error: $stderr)
+          StdioRunner.new(input: input, output: output, error: error).run
+        end
+      end
+    end
+  end
+end

data/lib/context_drop/mcp/stdio_runner.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "json"
+begin
+  require "logger"
+rescue LoadError
+  # Logger gem is optional outside full Rails environment
+end
+
+module ContextDrop
+  module MCP
+    class StdioRunner
+      def initialize(input: $stdin, output: $stdout, error: $stderr)
+        @input = input
+        @output = output
+        @error = error
+      end
+
+      def run
+        isolate_stdio_logging!
+        @output.sync = true if @output.respond_to?(:sync=)
+
+        while (line = @input.gets)
+          stripped = line.strip
+          next if stripped.empty?
+
+          response = process_line(stripped)
+          next if response.nil?
+
+          @output.puts(JSON.generate(response))
+          @output.flush if @output.respond_to?(:flush)
+        end
+      end
+
+      def process_line(line)
+        parsed = JSON.parse(line)
+        ContextDrop::MCP::Dispatcher.call(parsed)
+      rescue JSON::ParserError => e
+        {
+          jsonrpc: "2.0",
+          id: nil,
+          error: {
+            code: -32_700,
+            message: "Parse error: #{e.message}"
+          }
+        }
+      end
+
+      private
+
+      def isolate_stdio_logging!
+        return unless defined?(Logger)
+
+        stderr_logger = Logger.new(@error)
+        stderr_logger.level = ENV["CONTEXT_DROP_MCP_DEBUG"] == "1" ? Logger::DEBUG : Logger::WARN
+
+        Rails.logger = stderr_logger if defined?(Rails) && Rails.respond_to?(:logger=)
+        ActiveRecord::Base.logger = stderr_logger if defined?(ActiveRecord::Base) && ActiveRecord::Base.respond_to?(:logger=)
+      end
+    end
+  end
+end

data/lib/context_drop/mcp/tools/get_feedback.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module ContextDrop
+  module MCP
+    module Tools
+      class GetFeedback
+        MAX_INLINE_IMAGE_BYTES = 5 * 1024 * 1024 # 5 MB
+
+        DEFINITION = {
+          name: "get_feedback",
+          description: "Retrieve a complete ContextDrop feedback record, all DOM ElementReference snapshots, and screenshots/images as multimodal MCP image blocks.",
+          inputSchema: {
+            type: "object",
+            required: ["id"],
+            properties: {
+              id: {
+                type: %w[integer string],
+                description: "The ID of the ContextDrop::Feedback record."
+              },
+              include_images: {
+                type: "boolean",
+                description: "When true (default), includes attached screenshots and images as base64 MCP image content blocks."
+              }
+            }
+          }
+        }.freeze
+
+        def self.call(args = {})
+          params = args.is_a?(Hash) ? args.transform_keys(&:to_s) : {}
+          feedback_id = params["id"] || params["feedback_id"]
+          return error_result("Missing required parameter: id") if feedback_id.nil? || feedback_id.to_s.strip.empty?
+
+          include_images = params.key?("include_images") ? !!params["include_images"] : true
+
+          feedback = ContextDrop::Feedback
+                     .includes(:submitter, :element_references, :attachments)
+                     .find_by(id: feedback_id)
+
+          return error_result("Feedback ##{feedback_id} not found") unless feedback
+
+          payload = serialize_feedback(feedback)
+          content_blocks = [
+            {
+              type: "text",
+              text: JSON.pretty_generate(payload)
+            }
+          ]
+
+          if include_images
+            feedback.attachments.each do |att|
+              img_block = build_image_content_block(att)
+              content_blocks << img_block if img_block
+            end
+          end
+
+          {
+            content: content_blocks,
+            isError: false
+          }
+        end
+
+        def self.serialize_feedback(feedback)
+          {
+            id: feedback.id,
+            status: feedback.status,
+            message: feedback.message,
+            page_url: feedback.page_url,
+            user_agent: feedback.user_agent,
+            submitter: {
+              type: feedback.submitter_type,
+              id: feedback.submitter_id,
+              label: feedback.submitter_label
+            },
+            metadata: feedback.metadata || {},
+            created_at: feedback.created_at&.iso8601,
+            updated_at: feedback.updated_at&.iso8601,
+            element_references: feedback.element_references.map do |el|
+              {
+                id: el.id,
+                client_ref: el.client_ref,
+                tag_name: el.tag_name,
+                selector: el.selector,
+                dom_path: el.dom_path,
+                text_content: el.text_content,
+                attributes_snapshot: el.attributes_snapshot || {},
+                bounding_rect: el.bounding_rect || {},
+                viewport: el.viewport || {},
+                metadata: el.metadata || {},
+                captured_at: el.captured_at&.iso8601
+              }
+            end,
+            attachments: feedback.attachments.map do |att|
+              attached = att.respond_to?(:file) && att.file.attached?
+              {
+                id: att.id,
+                attachment_type: att.attachment_type,
+                element_reference_id: att.element_reference_id,
+                metadata: att.metadata || {},
+                filename: attached ? att.file.filename.to_s : nil,
+                content_type: attached ? att.file.content_type : nil,
+                byte_size: attached ? att.file.byte_size : nil,
+                created_at: att.created_at&.iso8601
+              }
+            end
+          }
+        end
+
+        def self.build_image_content_block(attachment)
+          return nil unless attachment.respond_to?(:file) && attachment.file.attached?
+          return nil if attachment.file.byte_size.to_i > MAX_INLINE_IMAGE_BYTES
+
+          raw_bytes = attachment.file.download
+          return nil if raw_bytes.nil? || raw_bytes.empty?
+
+          {
+            type: "image",
+            data: ContextDrop::Base64Util.strict_encode64(raw_bytes),
+            mimeType: attachment.file.content_type || "image/png"
+          }
+        rescue StandardError
+          nil
+        end
+
+        def self.error_result(msg)
+          {
+            content: [{ type: "text", text: JSON.generate(error: msg) }],
+            isError: true
+          }
+        end
+      end
+    end
+  end
+end

data/lib/context_drop/mcp/tools/get_feedback_attachment.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module ContextDrop
+  module MCP
+    module Tools
+      class GetFeedbackAttachment
+        DEFINITION = {
+          name: "get_feedback_attachment",
+          description: "Retrieve a specific ContextDrop::Attachment record and its binary image/screenshot as an MCP image content block.",
+          inputSchema: {
+            type: "object",
+            required: ["attachment_id"],
+            properties: {
+              attachment_id: {
+                type: %w[integer string],
+                description: "The ID of the ContextDrop::Attachment record."
+              }
+            }
+          }
+        }.freeze
+
+        def self.call(args = {})
+          params = args.is_a?(Hash) ? args.transform_keys(&:to_s) : {}
+          att_id = params["attachment_id"] || params["id"]
+          return error_result("Missing required parameter: attachment_id") if att_id.nil? || att_id.to_s.strip.empty?
+
+          attachment = ContextDrop::Attachment.includes(:element_reference).find_by(id: att_id)
+          return error_result("Attachment ##{att_id} not found") unless attachment
+
+          attached = attachment.respond_to?(:file) && attachment.file.attached?
+          meta_payload = {
+            id: attachment.id,
+            feedback_id: attachment.feedback_id,
+            element_reference_id: attachment.element_reference_id,
+            element_selector: attachment.element_reference&.selector,
+            attachment_type: attachment.attachment_type,
+            metadata: attachment.metadata || {},
+            filename: attached ? attachment.file.filename.to_s : nil,
+            content_type: attached ? attachment.file.content_type : nil,
+            byte_size: attached ? attachment.file.byte_size : nil
+          }
+
+          blocks = [{ type: "text", text: JSON.pretty_generate(meta_payload) }]
+
+          if attached
+            raw_bytes = attachment.file.download
+            if raw_bytes && !raw_bytes.empty?
+              blocks << {
+                type: "image",
+                data: ContextDrop::Base64Util.strict_encode64(raw_bytes),
+                mimeType: attachment.file.content_type || "image/png"
+              }
+            end
+          end
+
+          {
+            content: blocks,
+            isError: false
+          }
+        end
+
+        def self.error_result(msg)
+          {
+            content: [{ type: "text", text: JSON.generate(error: msg) }],
+            isError: true
+          }
+        end
+      end
+    end
+  end
+end