pocketrb 0.1.0

data/lib/pocketrb/mcp/client.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "json"
+require "securerandom"
+
+module Pocketrb
+  module MCP
+    # MCP client for connecting to MCP HTTP Bridge
+    # Implements JSON-RPC 2.0 protocol for MCP communication
+    class Client
+      DEFAULT_ENDPOINT = "http://localhost:7878"
+      TIMEOUT = 30
+
+      attr_reader :endpoint, :connected
+
+      def initialize(endpoint: nil)
+        @endpoint = endpoint || ENV["MCP_ENDPOINT"] || DEFAULT_ENDPOINT
+        @connected = false
+        @request_id = 0
+      end
+
+      # Initialize the MCP connection
+      def connect
+        response = rpc_call("initialize", {
+                              protocolVersion: "2024-11-05",
+                              capabilities: {
+                                tools: {}
+                              },
+                              clientInfo: {
+                                name: "pocketrb",
+                                version: Pocketrb::VERSION
+                              }
+                            })
+
+        @connected = !response["result"].nil?
+        @server_info = response.dig("result", "serverInfo")
+        @capabilities = response.dig("result", "capabilities")
+
+        Pocketrb.logger.info("MCP connected to #{@server_info&.dig("name") || "server"}")
+        @connected
+      rescue StandardError => e
+        Pocketrb.logger.warn("MCP connection failed: #{e.message}")
+        @connected = false
+      end
+
+      # List available tools from MCP server
+      def list_tools
+        ensure_connected!
+
+        response = rpc_call("tools/list", {})
+        response.dig("result", "tools") || []
+      end
+
+      # Call a tool on the MCP server
+      def call_tool(name:, arguments: {})
+        ensure_connected!
+
+        response = rpc_call("tools/call", {
+                              name: name,
+                              arguments: arguments
+                            })
+
+        raise MCPError, "Tool call failed: #{response["error"]["message"]}" if response["error"]
+
+        response.dig("result", "content")&.first&.dig("text")
+      end
+
+      # Search memory via MCP
+      def search(query:, limit: 10)
+        # Try MCP tool first
+        if tool_available?("memory_search")
+          call_tool(name: "memory_search", arguments: { query: query, limit: limit })
+        else
+          # Fall back to direct HTTP endpoint
+          http_search(query, limit)
+        end
+      end
+
+      # Store to memory via MCP
+      def store(content:, metadata: {})
+        # Try MCP tool first
+        if tool_available?("memory_store")
+          call_tool(name: "memory_store", arguments: { content: content, metadata: metadata })
+        else
+          # Fall back to direct HTTP endpoint
+          http_store(content, metadata)
+        end
+      end
+
+      # Check if connected
+      def connected?
+        @connected
+      end
+
+      # Disconnect from server
+      def disconnect
+        @connected = false
+      end
+
+      private
+
+      def ensure_connected!
+        return if @connected
+
+        connect
+        raise MCPError, "Not connected to MCP server" unless @connected
+      end
+
+      def rpc_call(method, params)
+        @request_id += 1
+
+        request_body = {
+          jsonrpc: "2.0",
+          id: @request_id,
+          method: method,
+          params: params
+        }
+
+        response = client.post("/rpc") do |req|
+          req.body = request_body.to_json
+        end
+
+        raise MCPError, "RPC call failed: HTTP #{response.status}" unless response.success?
+
+        JSON.parse(response.body)
+      rescue Faraday::Error => e
+        raise MCPError, "RPC connection error: #{e.message}"
+      end
+
+      def client
+        @client ||= Faraday.new(url: @endpoint) do |f|
+          f.headers["Content-Type"] = "application/json"
+          f.options.timeout = TIMEOUT
+          f.adapter Faraday.default_adapter
+        end
+      end
+
+      def tool_available?(name)
+        @tools ||= list_tools
+        @tools.any? { |t| t["name"] == name }
+      rescue MCPError
+        false
+      end
+
+      # Direct HTTP endpoints (fallback when not using MCP tools)
+      def http_search(query, limit)
+        response = client.post("/search") do |req|
+          req.body = { query: query, limit: limit }.to_json
+        end
+
+        return nil unless response.success?
+
+        JSON.parse(response.body)
+      rescue StandardError
+        nil
+      end
+
+      def http_store(content, metadata)
+        response = client.post("/store") do |req|
+          req.body = { content: content, metadata: metadata }.to_json
+        end
+
+        return false unless response.success?
+
+        true
+      rescue StandardError
+        false
+      end
+    end
+  end
+end

data/lib/pocketrb/mcp/memory_tool.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module Pocketrb
+  module MCP
+    # Tool for interacting with memory via MCP
+    class MemoryTool < Tools::Base
+      def initialize(context = {})
+        super
+        @client = context[:mcp_client] || Client.new
+      end
+
+      def name
+        "memory"
+      end
+
+      def description
+        "Interact with long-term memory. Search for relevant information or store new knowledge for future reference."
+      end
+
+      def parameters
+        {
+          type: "object",
+          properties: {
+            action: {
+              type: "string",
+              enum: %w[search store],
+              description: "Action to perform: 'search' to find information, 'store' to save new knowledge"
+            },
+            query: {
+              type: "string",
+              description: "For search: the query to search for"
+            },
+            content: {
+              type: "string",
+              description: "For store: the content to save to memory"
+            },
+            tags: {
+              type: "array",
+              items: { type: "string" },
+              description: "For store: tags to associate with the content"
+            },
+            limit: {
+              type: "integer",
+              description: "For search: maximum number of results (default: 5)"
+            }
+          },
+          required: ["action"]
+        }
+      end
+
+      def available?
+        @client.connected? || @client.connect
+      rescue StandardError
+        false
+      end
+
+      def execute(action:, query: nil, content: nil, tags: nil, limit: 5)
+        case action
+        when "search"
+          execute_search(query, limit)
+        when "store"
+          execute_store(content, tags)
+        else
+          error("Unknown action: #{action}. Use 'search' or 'store'.")
+        end
+      end
+
+      private
+
+      def execute_search(query, limit)
+        return error("Query is required for search") if query.nil? || query.empty?
+
+        results = @client.search(query: query, limit: limit)
+
+        return "No relevant memories found for: #{query}" if results.nil? || results.empty?
+
+        format_search_results(results, query)
+      rescue MCPError => e
+        error("Memory search failed: #{e.message}")
+      end
+
+      def execute_store(content, tags)
+        return error("Content is required for store") if content.nil? || content.empty?
+
+        metadata = {}
+        metadata[:tags] = tags if tags && !tags.empty?
+        metadata[:timestamp] = Time.now.iso8601
+        metadata[:source] = "pocketrb"
+
+        result = @client.store(content: content, metadata: metadata)
+
+        if result
+          success("Stored to memory: #{content[0..100]}#{"..." if content.length > 100}")
+        else
+          error("Failed to store to memory")
+        end
+      rescue MCPError => e
+        error("Memory store failed: #{e.message}")
+      end
+
+      def format_search_results(results, query)
+        output = ["Memory search results for: #{query}\n"]
+
+        if results.is_a?(String)
+          # Direct text response from MCP
+          output << results
+        elsif results.is_a?(Array)
+          results.each_with_index do |result, idx|
+            output << format_result(result, idx + 1)
+          end
+        elsif results.is_a?(Hash) && results["results"]
+          results["results"].each_with_index do |result, idx|
+            output << format_result(result, idx + 1)
+          end
+        end
+
+        output.join("\n")
+      end
+
+      def format_result(result, index)
+        content = result["content"] || result["text"] || result.to_s
+        score = result["score"]
+        tags = result["tags"] || result.dig("metadata", "tags")
+
+        parts = ["#{index}. #{content[0..500]}"]
+        parts << "   Score: #{score.round(3)}" if score
+        parts << "   Tags: #{tags.join(", ")}" if tags && !tags.empty?
+
+        parts.join("\n")
+      end
+    end
+  end
+end

data/lib/pocketrb/media/processor.rb

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+
+require "base64"
+require "fileutils"
+require "tmpdir"
+
+module Pocketrb
+  module Media
+    # Handles media processing: downloading, encoding, type detection
+    class Processor
+      # Supported image MIME types for vision models
+      VISION_IMAGE_TYPES = %w[
+        image/jpeg
+        image/png
+        image/gif
+        image/webp
+      ].freeze
+
+      # Audio types that can be transcribed
+      AUDIO_TYPES = %w[
+        audio/ogg
+        audio/mpeg
+        audio/mp3
+        audio/wav
+        audio/webm
+        audio/m4a
+      ].freeze
+
+      # Max file size for inline encoding (5MB)
+      MAX_INLINE_SIZE = 5 * 1024 * 1024
+
+      attr_reader :cache_dir
+
+      def initialize(cache_dir: nil)
+        @cache_dir = cache_dir || default_cache_dir
+        ensure_cache_dir!
+      end
+
+      # Download media from URL and return Media object
+      # @param url [String] URL to download
+      # @param filename [String, nil] Original filename
+      # @param mime_type [String, nil] Known MIME type
+      # @return [Bus::Media]
+      def download(url, filename: nil, mime_type: nil)
+        require "faraday"
+
+        response = Faraday.get(url)
+        raise MediaError, "Failed to download: HTTP #{response.status}" unless response.success?
+
+        content_type = mime_type || response.headers["content-type"]&.split(";")&.first || "application/octet-stream"
+        filename ||= extract_filename(url, content_type)
+
+        # Save to cache
+        cache_path = cache_file_path(filename)
+        File.binwrite(cache_path, response.body)
+
+        type = detect_type(content_type)
+        data = encode_if_small(response.body, content_type)
+
+        Bus::Media.new(
+          type: type,
+          path: cache_path,
+          mime_type: content_type,
+          filename: filename,
+          data: data
+        )
+      end
+
+      # Process a local file into a Media object
+      # @param path [String] File path
+      # @param mime_type [String, nil] Override MIME type
+      # @return [Bus::Media]
+      def from_file(path, mime_type: nil)
+        raise MediaError, "File not found: #{path}" unless File.exist?(path)
+
+        content = File.binread(path)
+        content_type = mime_type || detect_mime_type(path)
+        filename = File.basename(path)
+        type = detect_type(content_type)
+        data = encode_if_small(content, content_type)
+
+        Bus::Media.new(
+          type: type,
+          path: path,
+          mime_type: content_type,
+          filename: filename,
+          data: data
+        )
+      end
+
+      # Encode raw bytes into a Media object
+      # @param bytes [String] Raw binary data
+      # @param mime_type [String] MIME type
+      # @param filename [String, nil] Filename
+      # @return [Bus::Media]
+      def from_bytes(bytes, mime_type:, filename: nil)
+        type = detect_type(mime_type)
+        filename ||= "media_#{Time.now.to_i}.#{extension_for(mime_type)}"
+
+        # Save to cache
+        cache_path = cache_file_path(filename)
+        File.binwrite(cache_path, bytes)
+
+        data = encode_if_small(bytes, mime_type)
+
+        Bus::Media.new(
+          type: type,
+          path: cache_path,
+          mime_type: mime_type,
+          filename: filename,
+          data: data
+        )
+      end
+
+      # Check if media is a vision-compatible image
+      # @param media [Bus::Media]
+      # @return [Boolean]
+      def vision_compatible?(media)
+        VISION_IMAGE_TYPES.include?(media.mime_type)
+      end
+
+      # Check if media is audio that can be transcribed
+      # @param media [Bus::Media]
+      # @return [Boolean]
+      def audio?(media)
+        AUDIO_TYPES.include?(media.mime_type) || media.type == :audio
+      end
+
+      # Get base64 data for media (loads from file if needed)
+      # @param media [Bus::Media]
+      # @return [String] Base64 encoded data
+      def get_base64(media)
+        return media.data if media.data
+
+        content = File.binread(media.path)
+        Base64.strict_encode64(content)
+      end
+
+      # Format media for Anthropic vision API
+      # @param media [Bus::Media]
+      # @return [Hash] Anthropic image content block
+      def format_for_anthropic(media)
+        unless vision_compatible?(media)
+          return { type: "text", text: "[Attached file: #{media.filename} (#{media.mime_type})]" }
+        end
+
+        {
+          type: "image",
+          source: {
+            type: "base64",
+            media_type: media.mime_type,
+            data: get_base64(media)
+          }
+        }
+      end
+
+      # Clean up old cached files
+      # @param older_than [Integer] Age in seconds
+      def cleanup_cache(older_than: 86_400)
+        return unless @cache_dir.exist?
+
+        cutoff = Time.now - older_than
+        Dir.glob(@cache_dir.join("*")).each do |file|
+          File.delete(file) if File.mtime(file) < cutoff
+        rescue StandardError
+          # Ignore cleanup errors
+        end
+      end
+
+      private
+
+      def default_cache_dir
+        Pathname.new(Dir.tmpdir).join("pocketrb-media")
+      end
+
+      def ensure_cache_dir!
+        FileUtils.mkdir_p(@cache_dir)
+      end
+
+      def cache_file_path(filename)
+        # Sanitize filename and add timestamp to avoid conflicts
+        safe_name = filename.gsub(/[^a-zA-Z0-9._-]/, "_")
+        @cache_dir.join("#{Time.now.to_i}_#{safe_name}")
+      end
+
+      def detect_type(mime_type)
+        case mime_type
+        when %r{^image/}
+          :image
+        when %r{^audio/}
+          :audio
+        when %r{^video/}
+          :video
+        else
+          :file
+        end
+      end
+
+      def detect_mime_type(path)
+        ext = File.extname(path).downcase
+        MIME_TYPES[ext] || "application/octet-stream"
+      end
+
+      def encode_if_small(content, mime_type)
+        return nil if content.bytesize > MAX_INLINE_SIZE
+        return nil unless VISION_IMAGE_TYPES.include?(mime_type)
+
+        Base64.strict_encode64(content)
+      end
+
+      def extract_filename(url, content_type)
+        # Try to get filename from URL
+        uri_path = begin
+          URI.parse(url).path
+        rescue StandardError
+          ""
+        end
+        name = File.basename(uri_path)
+
+        if name.empty? || !name.include?(".")
+          ext = extension_for(content_type)
+          name = "download_#{Time.now.to_i}.#{ext}"
+        end
+
+        name
+      end
+
+      def extension_for(mime_type)
+        EXTENSIONS[mime_type] || "bin"
+      end
+
+      MIME_TYPES = {
+        ".jpg" => "image/jpeg",
+        ".jpeg" => "image/jpeg",
+        ".png" => "image/png",
+        ".gif" => "image/gif",
+        ".webp" => "image/webp",
+        ".mp3" => "audio/mpeg",
+        ".ogg" => "audio/ogg",
+        ".wav" => "audio/wav",
+        ".m4a" => "audio/m4a",
+        ".mp4" => "video/mp4",
+        ".webm" => "video/webm",
+        ".pdf" => "application/pdf",
+        ".txt" => "text/plain",
+        ".json" => "application/json"
+      }.freeze
+
+      EXTENSIONS = MIME_TYPES.invert.merge(
+        "image/jpeg" => "jpg",
+        "audio/mpeg" => "mp3",
+        "audio/ogg" => "ogg"
+      ).freeze
+    end
+
+    class MediaError < Pocketrb::Error; end
+  end
+end