rubyn-code 0.1.0

data/lib/rubyn_code/llm/streaming.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module LLM
+    class Streaming
+      ParseError = Class.new(RubynCode::Error)
+      OverloadError = Class.new(RubynCode::Error)
+
+      Event = Data.define(:type, :data)
+
+      def initialize(&block)
+        @callback = block
+        @buffer = +""
+        @response_id = nil
+        @content_blocks = []
+        @current_block_index = nil
+        @current_text = +""
+        @current_tool_input_json = +""
+        @stop_reason = nil
+        @usage = nil
+      end
+
+      # Feed raw SSE data chunk from the HTTP response body.
+      def feed(chunk)
+        @buffer << chunk
+        consume_events
+      end
+
+      # Returns the fully assembled Response once the stream completes.
+      def finalize
+        Response.new(
+          id: @response_id,
+          content: build_content_blocks,
+          stop_reason: @stop_reason,
+          usage: @usage
+        )
+      end
+
+      private
+
+      def consume_events
+        while (idx = @buffer.index("\n\n"))
+          raw_event = @buffer.slice!(0..idx + 1)
+          parse_sse(raw_event)
+        end
+      end
+
+      def parse_sse(raw)
+        event_type = nil
+        data_lines = []
+
+        raw.each_line do |line|
+          line = line.chomp
+          case line
+          when /\Aevent:\s*(.+)/
+            event_type = ::Regexp.last_match(1).strip
+          when /\Adata:\s*(.*)/
+            data_lines << ::Regexp.last_match(1)
+          end
+        end
+
+        return if data_lines.empty? && event_type.nil?
+
+        data_str = data_lines.join("\n")
+        data = data_str.empty? ? {} : parse_json(data_str)
+
+        dispatch(event_type, data)
+      end
+
+      def dispatch(event_type, data)
+        case event_type
+        when "message_start"
+          handle_message_start(data)
+        when "content_block_start"
+          handle_content_block_start(data)
+        when "content_block_delta"
+          handle_content_block_delta(data)
+        when "content_block_stop"
+          handle_content_block_stop(data)
+        when "message_delta"
+          handle_message_delta(data)
+        when "message_stop"
+          handle_message_stop
+        when "ping"
+          # ignore
+        when "error"
+          handle_error(data)
+        end
+      end
+
+      def handle_message_start(data)
+        message = data.dig("message") || data
+        @response_id = message["id"]
+
+        if (u = message["usage"])
+          @usage = Usage.new(input_tokens: u["input_tokens"].to_i, output_tokens: u["output_tokens"].to_i)
+        end
+
+        emit(:message_start, data)
+      end
+
+      def handle_content_block_start(data)
+        @current_block_index = data["index"]
+        block = data["content_block"] || {}
+
+        case block["type"]
+        when "text"
+          @current_text = +(block["text"] || "")
+        when "tool_use"
+          @current_tool_id = block["id"]
+          @current_tool_name = block["name"]
+          @current_tool_input_json = +""
+        end
+
+        emit(:content_block_start, data)
+      end
+
+      def handle_content_block_delta(data)
+        delta = data["delta"] || {}
+
+        case delta["type"]
+        when "text_delta"
+          text = delta["text"] || ""
+          @current_text << text
+          emit(:text_delta, { index: data["index"], text: text })
+        when "input_json_delta"
+          json_chunk = delta["partial_json"] || ""
+          @current_tool_input_json << json_chunk
+          emit(:input_json_delta, { index: data["index"], partial_json: json_chunk })
+        end
+
+        emit(:content_block_delta, data)
+      end
+
+      def handle_content_block_stop(data)
+        index = data["index"].to_i
+
+        if @current_tool_id
+          input = parse_json(@current_tool_input_json)
+          @content_blocks[index] = ToolUseBlock.new(
+            id: @current_tool_id,
+            name: @current_tool_name,
+            input: input || {}
+          )
+          @current_tool_id = nil
+          @current_tool_name = nil
+          @current_tool_input_json = +""
+        else
+          @content_blocks[index] = TextBlock.new(text: @current_text.dup)
+          @current_text = +""
+        end
+
+        emit(:content_block_stop, data)
+      end
+
+      def handle_message_delta(data)
+        delta = data["delta"] || {}
+        @stop_reason = delta["stop_reason"] if delta["stop_reason"]
+
+        if (u = data["usage"])
+          @usage = Usage.new(
+            input_tokens: (@usage&.input_tokens || 0),
+            output_tokens: u["output_tokens"].to_i
+          )
+        end
+
+        emit(:message_delta, data)
+      end
+
+      def handle_message_stop
+        emit(:message_stop, {})
+      end
+
+      def handle_error(data)
+        error = data.dig("error") || data
+        error_type = error["type"] || "unknown"
+        message = error["message"] || "Unknown streaming error"
+
+        if error_type == "overloaded_error"
+          raise OverloadError, message
+        end
+
+        raise ParseError, "Streaming error (#{error_type}): #{message}"
+      end
+
+      def emit(type, data)
+        @callback&.call(Event.new(type: type, data: data))
+      end
+
+      def build_content_blocks
+        @content_blocks.compact
+      end
+
+      def parse_json(str)
+        return nil if str.nil? || str.strip.empty?
+
+        JSON.parse(str)
+      rescue JSON::ParserError
+        nil
+      end
+    end
+  end
+end

data/lib/rubyn_code/mcp/client.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require "json"
+
+module RubynCode
+  module MCP
+    # High-level MCP client that manages the connection lifecycle,
+    # tool discovery, and tool invocation for a single MCP server.
+    class Client
+      INITIALIZE_TIMEOUT = 10
+
+      ClientError = Class.new(RubynCode::Error)
+
+      attr_reader :name, :transport
+
+      # @param name [String] human-readable name for this MCP server connection
+      # @param transport [StdioTransport, SSETransport] the underlying transport
+      def initialize(name:, transport:)
+        @name = name
+        @transport = transport
+        @tools_cache = nil
+        @initialized = false
+      end
+
+      # Starts the transport, performs the MCP initialize handshake,
+      # and discovers available tools.
+      #
+      # @return [void]
+      # @raise [ClientError] if initialization fails
+      def connect!
+        @transport.start!
+        perform_initialize
+        @initialized = true
+      rescue StandardError => e
+        @transport.stop!
+        raise ClientError, "Failed to connect to MCP server '#{@name}': #{e.message}"
+      end
+
+      # Returns the list of tool definitions from the MCP server.
+      # Each tool is a Hash with "name", "description", and "inputSchema" keys.
+      #
+      # @return [Array<Hash>] tool definitions in JSON Schema format
+      def tools
+        @tools_cache ||= discover_tools
+      end
+
+      # Invokes a tool on the MCP server.
+      #
+      # @param tool_name [String] the name of the tool to call
+      # @param arguments [Hash] the arguments to pass to the tool
+      # @return [Hash] the tool's result
+      # @raise [ClientError] if the client is not connected
+      def call_tool(tool_name, arguments = {})
+        ensure_connected!
+
+        @transport.send_request("tools/call", {
+          name: tool_name,
+          arguments: arguments
+        })
+      end
+
+      # Gracefully disconnects from the MCP server.
+      #
+      # @return [void]
+      def disconnect!
+        @transport.stop!
+        @initialized = false
+        @tools_cache = nil
+      end
+
+      # Returns whether the client is connected and the transport is alive.
+      #
+      # @return [Boolean]
+      def connected?
+        @initialized && @transport.alive?
+      end
+
+      class << self
+        # Factory method that creates a Client with the appropriate transport
+        # based on the server configuration.
+        #
+        # Configs with a :url key use SSETransport; all others use StdioTransport.
+        #
+        # @param server_config [Hash] configuration hash with :name, :command/:url, :args, :env
+        # @return [Client]
+        def from_config(server_config)
+          name = server_config[:name]
+
+          transport = if server_config[:url]
+                        SSETransport.new(
+                          url: server_config[:url],
+                          timeout: server_config[:timeout] || SSETransport::DEFAULT_TIMEOUT
+                        )
+                      else
+                        StdioTransport.new(
+                          command: server_config[:command],
+                          args: server_config[:args] || [],
+                          env: server_config[:env] || {},
+                          timeout: server_config[:timeout] || StdioTransport::DEFAULT_TIMEOUT
+                        )
+                      end
+
+          new(name: name, transport: transport)
+        end
+      end
+
+      private
+
+      def perform_initialize
+        result = @transport.send_request("initialize", {
+          protocolVersion: "2024-11-05",
+          capabilities: {
+            tools: {}
+          },
+          clientInfo: {
+            name: "rubyn-code",
+            version: RubynCode::VERSION
+          }
+        })
+
+        @server_info = result&.dig("serverInfo")
+        @server_capabilities = result&.dig("capabilities")
+
+        @transport.send_notification("notifications/initialized") if @transport.respond_to?(:send_notification)
+      end
+
+      def discover_tools
+        ensure_connected!
+
+        result = @transport.send_request("tools/list")
+        result&.fetch("tools", []) || []
+      end
+
+      def ensure_connected!
+        raise ClientError, "Client '#{@name}' is not connected. Call #connect! first." unless @initialized
+      end
+    end
+  end
+end

data/lib/rubyn_code/mcp/config.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "json"
+
+module RubynCode
+  module MCP
+    # Parses MCP server configuration from .rubyn-code/mcp.json in the project directory.
+    #
+    # Expected JSON format:
+    #   {
+    #     "mcpServers": {
+    #       "server-name": {
+    #         "command": "npx",
+    #         "args": ["-y", "@modelcontextprotocol/server-github"],
+    #         "env": { "GITHUB_TOKEN": "${GITHUB_TOKEN}" }
+    #       }
+    #     }
+    #   }
+    module Config
+      CONFIG_FILENAME = ".rubyn-code/mcp.json"
+
+      ENV_VAR_PATTERN = /\$\{([^}]+)\}/
+
+      class << self
+        # Reads and parses the MCP server configuration for a project.
+        #
+        # @param project_path [String] root directory of the project
+        # @return [Array<Hash>] array of server configs with keys :name, :command, :args, :env
+        def load(project_path)
+          config_path = File.join(project_path, CONFIG_FILENAME)
+          return [] unless File.exist?(config_path)
+
+          raw = File.read(config_path)
+          data = JSON.parse(raw)
+          servers = data["mcpServers"] || {}
+
+          servers.map do |name, server_def|
+            {
+              name: name,
+              command: server_def["command"],
+              args: Array(server_def["args"]),
+              env: expand_env(server_def["env"] || {})
+            }
+          end
+        rescue JSON::ParserError => e
+          warn "[MCP::Config] Failed to parse #{config_path}: #{e.message}"
+          []
+        rescue SystemCallError => e
+          warn "[MCP::Config] Could not read #{config_path}: #{e.message}"
+          []
+        end
+
+        private
+
+        # Expands environment variable references (${VAR_NAME}) in config values.
+        #
+        # @param env_hash [Hash<String, String>] raw env key-value pairs
+        # @return [Hash<String, String>] expanded env key-value pairs
+        def expand_env(env_hash)
+          env_hash.each_with_object({}) do |(key, value), result|
+            result[key] = expand_value(value)
+          end
+        end
+
+        # Replaces ${VAR} patterns with actual environment variable values.
+        #
+        # @param value [String] a string potentially containing ${VAR} references
+        # @return [String] the string with env vars expanded
+        def expand_value(value)
+          return value unless value.is_a?(String)
+
+          value.gsub(ENV_VAR_PATTERN) do
+            env_name = ::Regexp.last_match(1)
+            ENV.fetch(env_name) do
+              warn "[MCP::Config] Environment variable #{env_name} is not set"
+              ""
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/mcp/sse_transport.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "json"
+require "uri"
+
+module RubynCode
+  module MCP
+    # Communicates with a remote MCP server via HTTP Server-Sent Events (SSE).
+    #
+    # On #start!, the transport establishes a long-lived GET connection to the
+    # SSE endpoint. The server responds with an `endpoint` event containing
+    # the URL for JSON-RPC POST requests. Subsequent requests are sent via
+    # POST, and responses arrive as SSE events on the GET stream.
+    class SSETransport
+      DEFAULT_TIMEOUT = 30 # seconds
+
+      TransportError = Class.new(RubynCode::Error)
+      TimeoutError = Class.new(TransportError)
+
+      # @param url [String] the SSE endpoint URL of the MCP server
+      # @param timeout [Integer] default timeout in seconds per request
+      def initialize(url:, timeout: DEFAULT_TIMEOUT)
+        @url = url
+        @timeout = timeout
+        @request_id = 0
+        @mutex = Mutex.new
+        @post_endpoint = nil
+        @pending_responses = {}
+        @connected = false
+        @sse_thread = nil
+      end
+
+      # Establishes the SSE connection and waits for the endpoint event.
+      #
+      # @return [void]
+      # @raise [TransportError] if the connection cannot be established
+      def start!
+        raise TransportError, "Transport already started" if @connected
+
+        @pending_responses = {}
+        @sse_thread = Thread.new { run_sse_listener }
+
+        # Wait for the endpoint event with a timeout
+        deadline = Time.now + @timeout
+        sleep(0.1) until @post_endpoint || Time.now > deadline
+
+        unless @post_endpoint
+          stop!
+          raise TransportError, "MCP server did not provide an endpoint within #{@timeout}s"
+        end
+
+        @connected = true
+      end
+
+      # Sends a JSON-RPC 2.0 request via HTTP POST and waits for the response.
+      #
+      # @param method [String] the JSON-RPC method name
+      # @param params [Hash] parameters for the request
+      # @return [Hash] the parsed JSON-RPC result
+      # @raise [TransportError] on protocol or server errors
+      # @raise [TimeoutError] if the response is not received in time
+      def send_request(method, params = {})
+        raise TransportError, "Transport is not connected" unless @connected
+
+        id = next_request_id
+        queue = Queue.new
+        @mutex.synchronize { @pending_responses[id] = queue }
+
+        request = {
+          jsonrpc: "2.0",
+          id: id,
+          method: method,
+          params: params
+        }
+
+        post_request(request)
+        wait_for_response(id, queue)
+      end
+
+      # Closes the SSE connection and cleans up resources.
+      #
+      # @return [void]
+      def stop!
+        @connected = false
+        @sse_thread&.kill
+        @sse_thread = nil
+        @post_endpoint = nil
+        @pending_responses.clear
+      end
+
+      # Checks whether the transport is connected.
+      #
+      # @return [Boolean]
+      def alive?
+        @connected && @sse_thread&.alive?
+      end
+
+      private
+
+      def next_request_id
+        @mutex.synchronize { @request_id += 1 }
+      end
+
+      def base_url
+        uri = URI.parse(@url)
+        "#{uri.scheme}://#{uri.host}#{":#{uri.port}" if uri.port != uri.default_port}"
+      end
+
+      def connection
+        @connection ||= Faraday.new(url: base_url) do |f|
+          f.options.timeout = @timeout
+          f.options.open_timeout = @timeout
+          f.headers["Content-Type"] = "application/json"
+          f.adapter Faraday.default_adapter
+        end
+      end
+
+      def post_request(request)
+        response = connection.post(@post_endpoint) do |req|
+          req.body = JSON.generate(request)
+        end
+
+        unless response.success?
+          raise TransportError, "MCP server returned HTTP #{response.status}: #{response.body}"
+        end
+      rescue Faraday::Error => e
+        raise TransportError, "Failed to send request to MCP server: #{e.message}"
+      end
+
+      def wait_for_response(id, queue)
+        result = nil
+        begin
+          Timeout.timeout(@timeout, TimeoutError, "MCP server did not respond within #{@timeout}s") do
+            result = queue.pop
+          end
+        ensure
+          @mutex.synchronize { @pending_responses.delete(id) }
+        end
+
+        if result.is_a?(Hash) && result.key?("error")
+          err = result["error"]
+          raise TransportError, "MCP error (#{err['code']}): #{err['message']}"
+        end
+
+        result
+      end
+
+      def run_sse_listener
+        sse_connection = Faraday.new(url: base_url) do |f|
+          f.options.timeout = nil # Keep-alive
+          f.options.open_timeout = @timeout
+          f.headers["Accept"] = "text/event-stream"
+          f.adapter Faraday.default_adapter
+        end
+
+        buffer = +""
+
+        sse_connection.get(@url) do |req|
+          req.options.on_data = proc do |chunk, _bytes, _env|
+            buffer << chunk
+            process_sse_buffer(buffer)
+          end
+        end
+      rescue Faraday::Error => e
+        @connected = false
+        warn "[MCP::SSETransport] SSE connection lost: #{e.message}"
+      end
+
+      def process_sse_buffer(buffer)
+        while (idx = buffer.index("\n\n"))
+          raw_event = buffer.slice!(0, idx + 2)
+          event = parse_sse_event(raw_event)
+          handle_sse_event(event) if event
+        end
+      end
+
+      def parse_sse_event(raw)
+        event_type = nil
+        data_lines = []
+
+        raw.each_line do |line|
+          line = line.chomp
+          if line.start_with?("event:")
+            event_type = line.sub("event:", "").strip
+          elsif line.start_with?("data:")
+            data_lines << line.sub("data:", "").strip
+          end
+        end
+
+        return nil if data_lines.empty?
+
+        { type: event_type, data: data_lines.join("\n") }
+      end
+
+      def handle_sse_event(event)
+        case event[:type]
+        when "endpoint"
+          @post_endpoint = event[:data]
+        when "message"
+          dispatch_message(event[:data])
+        else
+          dispatch_message(event[:data])
+        end
+      end
+
+      def dispatch_message(data)
+        message = JSON.parse(data)
+        return unless message.is_a?(Hash) && message.key?("id")
+
+        id = message["id"]
+        queue = @mutex.synchronize { @pending_responses[id] }
+        return unless queue
+
+        if message.key?("error")
+          queue.push(message)
+        else
+          queue.push(message["result"])
+        end
+      rescue JSON::ParserError
+        # Ignore malformed messages
+      end
+    end
+  end
+end