rubyn-code 0.1.0

data/lib/rubyn_code/mcp/stdio_transport.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require "json"
+require "open3"
+require "timeout"
+
+module RubynCode
+  module MCP
+    # Communicates with an MCP server via subprocess stdin/stdout using JSON-RPC 2.0.
+    #
+    # The server process is spawned with Open3.popen3 and kept alive for the
+    # duration of the session. Requests are written as newline-delimited JSON
+    # to stdin, and responses are read line-by-line from stdout.
+    class StdioTransport
+      DEFAULT_TIMEOUT = 30 # seconds
+
+      TransportError = Class.new(RubynCode::Error)
+      TimeoutError = Class.new(TransportError)
+
+      # @param command [String] executable to spawn
+      # @param args [Array<String>] arguments for the command
+      # @param env [Hash<String, String>] additional environment variables
+      # @param timeout [Integer] default timeout in seconds per request
+      def initialize(command:, args: [], env: {}, timeout: DEFAULT_TIMEOUT)
+        @command = command
+        @args = args
+        @env = env
+        @timeout = timeout
+        @request_id = 0
+        @mutex = Mutex.new
+        @stdin = nil
+        @stdout = nil
+        @stderr = nil
+        @wait_thread = nil
+      end
+
+      # Spawns the MCP server subprocess.
+      #
+      # @return [void]
+      # @raise [TransportError] if the process fails to start
+      def start!
+        raise TransportError, "Transport already started" if alive?
+
+        @stdin, @stdout, @stderr, @wait_thread = Open3.popen3(@env, @command, *@args)
+      rescue Errno::ENOENT => e
+        raise TransportError, "Failed to start MCP server: #{e.message}"
+      end
+
+      # Sends a JSON-RPC 2.0 request and waits for the correlated response.
+      #
+      # @param method [String] the JSON-RPC method name
+      # @param params [Hash] parameters for the request
+      # @return [Hash] the parsed JSON-RPC response result
+      # @raise [TransportError] on protocol or server errors
+      # @raise [TimeoutError] if the response is not received within the timeout
+      def send_request(method, params = {})
+        raise TransportError, "Transport is not running" unless alive?
+
+        id = next_request_id
+        request = {
+          jsonrpc: "2.0",
+          id: id,
+          method: method,
+          params: params
+        }
+
+        write_request(request)
+        read_response(id)
+      end
+
+      # Sends a JSON-RPC 2.0 notification (no response expected).
+      #
+      # @param method [String] the JSON-RPC method name
+      # @param params [Hash] parameters for the notification
+      # @return [void]
+      def send_notification(method, params = {})
+        raise TransportError, "Transport is not running" unless alive?
+
+        notification = {
+          jsonrpc: "2.0",
+          method: method,
+          params: params
+        }
+
+        write_request(notification)
+      end
+
+      # Gracefully shuts down the MCP server and cleans up resources.
+      #
+      # @return [void]
+      def stop!
+        return unless alive?
+
+        begin
+          send_notification("notifications/cancelled")
+          @stdin&.close
+        rescue IOError, Errno::EPIPE
+          # Process may already be gone
+        end
+
+        begin
+          @wait_thread&.join(5)
+        rescue StandardError
+          # Best-effort wait
+        end
+
+        force_kill if alive?
+      ensure
+        close_streams
+      end
+
+      # Checks whether the subprocess is still running.
+      #
+      # @return [Boolean]
+      def alive?
+        return false unless @wait_thread
+
+        @wait_thread.alive?
+      end
+
+      private
+
+      def next_request_id
+        @mutex.synchronize { @request_id += 1 }
+      end
+
+      def write_request(request)
+        @mutex.synchronize do
+          data = JSON.generate(request)
+          @stdin.write("#{data}\n")
+          @stdin.flush
+        end
+      rescue IOError, Errno::EPIPE => e
+        raise TransportError, "Failed to write to MCP server: #{e.message}"
+      end
+
+      def read_response(expected_id)
+        Timeout.timeout(@timeout, TimeoutError, "MCP server did not respond within #{@timeout}s") do
+          loop do
+            line = @stdout.gets
+            raise TransportError, "MCP server closed stdout unexpectedly" if line.nil?
+
+            line = line.strip
+            next if line.empty?
+
+            message = parse_json(line)
+            next unless message
+
+            # Skip notifications (no id field)
+            next unless message.key?("id")
+
+            # Skip responses for other requests
+            next unless message["id"] == expected_id
+
+            if message.key?("error")
+              err = message["error"]
+              raise TransportError, "MCP error (#{err['code']}): #{err['message']}"
+            end
+
+            return message["result"]
+          end
+        end
+      end
+
+      def parse_json(line)
+        JSON.parse(line)
+      rescue JSON::ParserError
+        nil
+      end
+
+      def force_kill
+        return unless @wait_thread
+
+        pid = @wait_thread.pid
+        Process.kill("TERM", pid)
+        sleep(0.5)
+        Process.kill("KILL", pid) if @wait_thread.alive?
+      rescue Errno::ESRCH, Errno::EPERM
+        # Process already gone or we lack permissions
+      end
+
+      def close_streams
+        [@stdin, @stdout, @stderr].each do |stream|
+          stream&.close unless stream&.closed?
+        rescue IOError
+          # Already closed
+        end
+
+        @stdin = nil
+        @stdout = nil
+        @stderr = nil
+        @wait_thread = nil
+      end
+    end
+  end
+end

data/lib/rubyn_code/mcp/tool_bridge.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module MCP
+    # Wraps MCP tools as native RubynCode tools by dynamically creating
+    # tool classes that delegate execution to the MCP client.
+    #
+    # Each bridged tool:
+    # - Has TOOL_NAME prefixed with "mcp_"
+    # - Has RISK_LEVEL = :external
+    # - Delegates #execute to the MCP client's #call_tool
+    # - Registers itself with Tools::Registry
+    module ToolBridge
+      class << self
+        # Discovers tools from an MCP client and creates corresponding
+        # RubynCode tool classes.
+        #
+        # @param mcp_client [MCP::Client] a connected MCP client
+        # @return [Array<Class>] the dynamically created tool classes
+        def bridge(mcp_client)
+          tools = mcp_client.tools
+          return [] if tools.nil? || tools.empty?
+
+          tools.map do |tool_def|
+            build_tool_class(mcp_client, tool_def)
+          end
+        end
+
+        private
+
+        # Builds a single tool class for an MCP tool definition.
+        #
+        # @param mcp_client [MCP::Client] the MCP client to delegate to
+        # @param tool_def [Hash] tool definition with "name", "description", "inputSchema"
+        # @return [Class] the newly created and registered tool class
+        def build_tool_class(mcp_client, tool_def)
+          remote_name = tool_def["name"]
+          tool_name = "mcp_#{sanitize_name(remote_name)}"
+          description = tool_def["description"] || "MCP tool: #{remote_name}"
+          input_schema = tool_def["inputSchema"] || {}
+          parameters = build_parameters_from_schema(input_schema)
+
+          klass = Class.new(Tools::Base) do
+            const_set(:TOOL_NAME, tool_name)
+            const_set(:DESCRIPTION, description)
+            const_set(:PARAMETERS, parameters)
+            const_set(:RISK_LEVEL, :external)
+            const_set(:REQUIRES_CONFIRMATION, true)
+
+            define_method(:mcp_client) { mcp_client }
+            define_method(:remote_tool_name) { remote_name }
+
+            def execute(**params)
+              result = mcp_client.call_tool(remote_tool_name, params)
+              format_result(result)
+            end
+
+            private
+
+            define_method(:format_result) do |result|
+              case result
+              when Hash
+                if result.key?("content")
+                  extract_content(result["content"])
+                else
+                  JSON.generate(result)
+                end
+              when String
+                result
+              else
+                result.to_s
+              end
+            end
+
+            define_method(:extract_content) do |content|
+              Array(content).map do |block|
+                case block["type"]
+                when "text"
+                  block["text"]
+                when "image"
+                  "[image: #{block['mimeType']}]"
+                when "resource"
+                  block.dig("resource", "text") || "[resource: #{block.dig('resource', 'uri')}]"
+                else
+                  block.to_s
+                end
+              end.join("\n")
+            end
+          end
+
+          # Build parameter definitions from JSON Schema
+          klass.define_singleton_method(:build_parameters) do |schema|
+            properties = schema["properties"] || {}
+            required = schema["required"] || []
+
+            properties.each_with_object({}) do |(name, prop), params|
+              params[name.to_sym] = {
+                type: map_json_type(prop["type"]),
+                description: prop["description"] || "",
+                required: required.include?(name)
+              }
+            end
+          end
+
+          klass.define_singleton_method(:map_json_type) do |json_type|
+            case json_type
+            when "string"  then :string
+            when "integer" then :integer
+            when "number"  then :number
+            when "boolean" then :boolean
+            when "array"   then :array
+            when "object"  then :object
+            else :string
+            end
+          end
+
+          Tools::Registry.register(klass)
+          klass
+        end
+
+        # Builds parameter definitions from a JSON Schema.
+        #
+        # @param schema [Hash] JSON Schema with "properties" and "required"
+        # @return [Hash]
+        def build_parameters_from_schema(schema)
+          properties = schema["properties"] || {}
+          required = schema["required"] || []
+
+          properties.each_with_object({}) do |(name, prop), params|
+            params[name.to_sym] = {
+              type: map_json_type(prop["type"]),
+              description: prop["description"] || "",
+              required: required.include?(name)
+            }
+          end
+        end
+
+        # Maps a JSON Schema type string to a Ruby symbol.
+        #
+        # @param json_type [String]
+        # @return [Symbol]
+        def map_json_type(json_type)
+          case json_type
+          when "string"  then :string
+          when "integer" then :integer
+          when "number"  then :number
+          when "boolean" then :boolean
+          when "array"   then :array
+          when "object"  then :object
+          else :string
+          end
+        end
+
+        # Sanitizes a tool name for use as a Ruby-friendly identifier.
+        #
+        # @param name [String] the original tool name
+        # @return [String] sanitized name
+        def sanitize_name(name)
+          name.to_s.gsub(/[^a-zA-Z0-9_]/, "_").gsub(/_+/, "_").downcase
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/memory/models.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module Memory
+    VALID_TIERS = %w[short medium long].freeze
+    VALID_CATEGORIES = %w[code_pattern user_preference project_convention error_resolution decision].freeze
+
+    # Immutable value object representing a single memory record.
+    #
+    # Tiers control retention and decay:
+    #   - "short"  : ephemeral, decays quickly, session-scoped
+    #   - "medium" : moderate retention, project-scoped
+    #   - "long"   : persistent, rarely decays
+    #
+    # Categories classify the kind of knowledge stored:
+    #   - "code_pattern"        : recurring code patterns or idioms
+    #   - "user_preference"     : how the user likes things done
+    #   - "project_convention"  : project-specific conventions
+    #   - "error_resolution"    : known error/fix pairs
+    #   - "decision"            : architectural or design decisions
+    MemoryRecord = Data.define(
+      :id, :project_path, :tier, :category, :content,
+      :relevance_score, :access_count, :last_accessed_at,
+      :expires_at, :metadata, :created_at
+    ) do
+      # @return [Boolean]
+      def expired?
+        return false if expires_at.nil?
+
+        Time.parse(expires_at.to_s) < Time.now
+      rescue ArgumentError
+        false
+      end
+
+      # @return [Boolean]
+      def short? = tier == "short"
+
+      # @return [Boolean]
+      def medium? = tier == "medium"
+
+      # @return [Boolean]
+      def long? = tier == "long"
+
+      # @return [Hash]
+      def to_h
+        {
+          id: id,
+          project_path: project_path,
+          tier: tier,
+          category: category,
+          content: content,
+          relevance_score: relevance_score,
+          access_count: access_count,
+          last_accessed_at: last_accessed_at,
+          expires_at: expires_at,
+          metadata: metadata,
+          created_at: created_at
+        }
+      end
+    end
+  end
+end

data/lib/rubyn_code/memory/search.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+require "json"
+
+module RubynCode
+  module Memory
+    # Searches memories using SQLite FTS5 full-text search and standard
+    # queries. Every search method automatically increments access_count
+    # and updates last_accessed_at on returned records, reinforcing
+    # frequently-accessed memories against decay.
+    class Search
+      # @param db [DB::Connection] database connection
+      # @param project_path [String] scoping path for searches
+      def initialize(db, project_path:)
+        @db = db
+        @project_path = project_path
+      end
+
+      # Full-text search across memory content using FTS5.
+      #
+      # @param query [String] the search query (FTS5 syntax supported)
+      # @param tier [String, nil] filter by tier
+      # @param category [String, nil] filter by category
+      # @param limit [Integer] maximum results (default 10)
+      # @return [Array<MemoryRecord>]
+      def search(query, tier: nil, category: nil, limit: 10)
+        conditions = ["m.project_path = ?"]
+        params = [@project_path]
+
+        if tier
+          conditions << "m.tier = ?"
+          params << tier
+        end
+
+        if category
+          conditions << "m.category = ?"
+          params << category
+        end
+
+        params << query
+        params << limit
+
+        rows = @db.query(<<~SQL, params).to_a
+          SELECT m.id, m.project_path, m.tier, m.category, m.content,
+                 m.relevance_score, m.access_count, m.last_accessed_at,
+                 m.expires_at, m.metadata, m.created_at
+          FROM memories m
+          WHERE #{conditions.join(' AND ')}
+            AND m.content LIKE '%' || ? || '%'
+          ORDER BY m.relevance_score DESC, m.created_at DESC
+          LIMIT ?
+        SQL
+
+        records = rows.map { |row| build_record(row) }
+        touch_accessed(records)
+        records
+      end
+
+      # Returns the most recently created memories.
+      #
+      # @param limit [Integer] maximum results (default 10)
+      # @return [Array<MemoryRecord>]
+      def recent(limit: 10)
+        rows = @db.query(<<~SQL, [@project_path, limit]).to_a
+          SELECT id, project_path, tier, category, content,
+                 relevance_score, access_count, last_accessed_at,
+                 expires_at, metadata, created_at
+          FROM memories
+          WHERE project_path = ?
+          ORDER BY created_at DESC
+          LIMIT ?
+        SQL
+
+        records = rows.map { |row| build_record(row) }
+        touch_accessed(records)
+        records
+      end
+
+      # Returns memories filtered by category.
+      #
+      # @param category [String]
+      # @param limit [Integer] maximum results (default 10)
+      # @return [Array<MemoryRecord>]
+      def by_category(category, limit: 10)
+        rows = @db.query(<<~SQL, [@project_path, category, limit]).to_a
+          SELECT id, project_path, tier, category, content,
+                 relevance_score, access_count, last_accessed_at,
+                 expires_at, metadata, created_at
+          FROM memories
+          WHERE project_path = ?
+            AND category = ?
+          ORDER BY relevance_score DESC, created_at DESC
+          LIMIT ?
+        SQL
+
+        records = rows.map { |row| build_record(row) }
+        touch_accessed(records)
+        records
+      end
+
+      # Returns memories filtered by tier.
+      #
+      # @param tier [String]
+      # @param limit [Integer] maximum results (default 10)
+      # @return [Array<MemoryRecord>]
+      def by_tier(tier, limit: 10)
+        rows = @db.query(<<~SQL, [@project_path, tier, limit]).to_a
+          SELECT id, project_path, tier, category, content,
+                 relevance_score, access_count, last_accessed_at,
+                 expires_at, metadata, created_at
+          FROM memories
+          WHERE project_path = ?
+            AND tier = ?
+          ORDER BY relevance_score DESC, created_at DESC
+          LIMIT ?
+        SQL
+
+        records = rows.map { |row| build_record(row) }
+        touch_accessed(records)
+        records
+      end
+
+      private
+
+      # Builds a MemoryRecord from a database row.
+      #
+      # @param row [Hash]
+      # @return [MemoryRecord]
+      def build_record(row)
+        metadata = parse_json(row["metadata"])
+
+        MemoryRecord.new(
+          id: row["id"],
+          project_path: row["project_path"],
+          tier: row["tier"],
+          category: row["category"],
+          content: row["content"],
+          relevance_score: row["relevance_score"].to_f,
+          access_count: row["access_count"].to_i,
+          last_accessed_at: row["last_accessed_at"],
+          expires_at: row["expires_at"],
+          metadata: metadata,
+          created_at: row["created_at"]
+        )
+      end
+
+      # Increments access_count and updates last_accessed_at for all
+      # returned records, reinforcing them against decay.
+      #
+      # @param records [Array<MemoryRecord>]
+      # @return [void]
+      def touch_accessed(records)
+        return if records.empty?
+
+        now = Time.now.utc.strftime("%Y-%m-%d %H:%M:%S")
+        ids = records.map(&:id)
+        placeholders = (["?"] * ids.size).join(", ")
+
+        @db.execute(
+          "UPDATE memories SET access_count = access_count + 1, last_accessed_at = ? WHERE id IN (#{placeholders})",
+          [now] + ids
+        )
+      rescue StandardError
+        # Access tracking is best-effort; never fail a search because of it.
+        nil
+      end
+
+      # @param raw [String, Hash, nil]
+      # @return [Hash]
+      def parse_json(raw)
+        case raw
+        when Hash then raw
+        when String then JSON.parse(raw, symbolize_names: true)
+        else {}
+        end
+      rescue JSON::ParserError
+        {}
+      end
+    end
+  end
+end