rubyn-code 0.2.2 → 0.4.0

data/lib/rubyn_code/ide/handlers/session_resume_handler.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module IDE
+    module Handlers
+      # Handles the "session/resume" JSON-RPC request.
+      #
+      # Loads a previously persisted session from SessionPersistence and
+      # pre-populates the PromptHandler's conversation cache so that the
+      # next prompt continues from where the session left off.
+      class SessionResumeHandler
+        def initialize(server)
+          @server = server
+        end
+
+        def call(params)
+          session_id = params['sessionId']
+          return { 'resumed' => false, 'error' => 'Missing sessionId' } unless session_id
+
+          persistence = @server.session_persistence
+          return { 'resumed' => false, 'error' => 'Session persistence not available' } unless persistence
+
+          data = persistence.load_session(session_id)
+          return { 'resumed' => false, 'error' => 'Session not found' } unless data
+
+          messages = data[:messages] || []
+
+          # Pre-populate the prompt handler's conversation cache so the next
+          # prompt picks up from the restored history.
+          prompt = @server.handler_instance(:prompt)
+          if prompt
+            conversation = Agent::Conversation.new
+            messages.each { |msg| conversation.messages << msg }
+            prompt.inject_conversation(session_id, conversation)
+          end
+
+          { 'resumed' => true, 'sessionId' => session_id, 'messages' => messages }
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/ide/handlers/shutdown_handler.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module IDE
+    module Handlers
+      # Handles the "shutdown" JSON-RPC request.
+      #
+      # Triggers session persistence, signals the server to stop its
+      # read loop, and returns confirmation.
+      class ShutdownHandler
+        def initialize(server)
+          @server = server
+        end
+
+        def call(_params)
+          warn '[ShutdownHandler] shutdown requested'
+
+          save_session!
+          @server.stop!
+
+          { 'shutdown' => true }
+        end
+
+        private
+
+        def save_session!
+          return unless defined?(RubynCode::Memory::SessionPersistence)
+
+          persistence = @server.session_persistence
+          persistence&.save
+        rescue StandardError => e
+          warn "[ShutdownHandler] session save failed: #{e.message}"
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/ide/handlers.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative 'handlers/initialize_handler'
+require_relative 'handlers/prompt_handler'
+require_relative 'handlers/cancel_handler'
+require_relative 'handlers/review_handler'
+require_relative 'handlers/approve_tool_use_handler'
+require_relative 'handlers/accept_edit_handler'
+require_relative 'handlers/shutdown_handler'
+require_relative 'handlers/config_get_handler'
+require_relative 'handlers/config_set_handler'
+require_relative 'handlers/models_list_handler'
+require_relative 'handlers/session_reset_handler'
+require_relative 'handlers/session_list_handler'
+require_relative 'handlers/session_resume_handler'
+require_relative 'handlers/session_fork_handler'
+
+module RubynCode
+  module IDE
+    module Handlers
+      # Method name => Handler class mapping.
+      REGISTRY = {
+        'initialize' => InitializeHandler,
+        'prompt' => PromptHandler,
+        'cancel' => CancelHandler,
+        'review' => ReviewHandler,
+        'approveToolUse' => ApproveToolUseHandler,
+        'acceptEdit' => AcceptEditHandler,
+        'shutdown' => ShutdownHandler,
+        'config/get' => ConfigGetHandler,
+        'config/set' => ConfigSetHandler,
+        'models/list' => ModelsListHandler,
+        'session/reset' => SessionResetHandler,
+        'session/list' => SessionListHandler,
+        'session/resume' => SessionResumeHandler,
+        'session/fork' => SessionForkHandler
+      }.freeze
+
+      # Short name => method name mapping (for handler_instance lookups).
+      SHORT_NAMES = {
+        prompt: 'prompt',
+        cancel: 'cancel',
+        review: 'review',
+        approve_tool_use: 'approveToolUse',
+        accept_edit: 'acceptEdit',
+        shutdown: 'shutdown',
+        initialize: 'initialize',
+        config_get: 'config/get',
+        config_set: 'config/set',
+        models_list: 'models/list',
+        session_reset: 'session/reset',
+        session_list: 'session/list',
+        session_resume: 'session/resume',
+        session_fork: 'session/fork'
+      }.freeze
+
+      # Register all handlers on the given server instance.
+      #
+      # @param server [RubynCode::IDE::Server] the IDE server
+      def self.register_all(server)
+        instances = {}
+
+        REGISTRY.each do |method, handler_class|
+          handler = handler_class.new(server)
+          instances[method] = handler
+
+          server.on(method) do |params, _id|
+            handler.call(params)
+          end
+        end
+
+        server.handler_instances = instances
+      end
+    end
+  end
+end

data/lib/rubyn_code/ide/protocol.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module RubynCode
+  module IDE
+    # JSON-RPC 2.0 protocol layer for the IDE server.
+    # Pure data — no side effects, no I/O beyond JSON serialisation.
+    module Protocol
+      JSONRPC_VERSION = '2.0'
+
+      # ── Standard JSON-RPC 2.0 error codes ──────────────────────────────
+      PARSE_ERROR      = -32_700
+      INVALID_REQUEST  = -32_600
+      METHOD_NOT_FOUND = -32_601
+      INVALID_PARAMS   = -32_602
+      INTERNAL_ERROR   = -32_603
+
+      # ── Custom error codes ─────────────────────────────────────────────
+      AGENT_BUSY        = -1
+      SESSION_NOT_FOUND = -2
+      BUDGET_EXCEEDED   = -3
+
+      module_function
+
+      # Parse a JSON string into a request hash.
+      # Returns either a valid request hash or an error response hash.
+      def parse(line) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity -- JSON-RPC validation checks
+        begin
+          data = JSON.parse(line)
+        rescue JSON::ParserError
+          return error(nil, PARSE_ERROR, 'Parse error: invalid JSON')
+        end
+
+        return error(nil, INVALID_REQUEST, 'Invalid request: expected JSON object') unless data.is_a?(Hash)
+
+        unless data['jsonrpc'] == JSONRPC_VERSION
+          return error(data['id'], INVALID_REQUEST, 'Invalid request: missing or wrong "jsonrpc" version')
+        end
+
+        # Response objects (containing "result" or "error") are valid
+        # JSON-RPC 2.0 messages that don't carry a "method".
+        is_response = data.key?('result') || data.key?('error')
+
+        unless is_response || data['method'].is_a?(String)
+          return error(data['id'], INVALID_REQUEST, 'Invalid request: "method" must be a string')
+        end
+
+        if data.key?('params') && !data['params'].is_a?(Hash) && !data['params'].is_a?(Array)
+          return error(data['id'], INVALID_PARAMS, 'Invalid params: "params" must be an object or array')
+        end
+
+        data
+      end
+
+      # Build a success response hash.
+      def response(id, result)
+        {
+          'jsonrpc' => JSONRPC_VERSION,
+          'id' => id,
+          'result' => stringify_keys_deep(result)
+        }
+      end
+
+      # Build an error response hash.
+      def error(id, code, message)
+        {
+          'jsonrpc' => JSONRPC_VERSION,
+          'id' => id,
+          'error' => {
+            'code' => code,
+            'message' => message
+          }
+        }
+      end
+
+      # Build a notification hash (no id).
+      def notification(method, params)
+        {
+          'jsonrpc' => JSONRPC_VERSION,
+          'method' => method,
+          'params' => stringify_keys_deep(params)
+        }
+      end
+
+      # Serialise a hash to a JSON string terminated by a newline.
+      def serialize(hash)
+        "#{JSON.generate(hash)}\n"
+      end
+
+      # ── Helpers ────────────────────────────────────────────────────────
+
+      # Recursively convert symbol keys to strings so every hash that
+      # leaves this module uses string keys for JSON compatibility.
+      def stringify_keys_deep(obj)
+        case obj
+        when Hash
+          obj.each_with_object({}) do |(k, v), memo|
+            memo[k.to_s] = stringify_keys_deep(v)
+          end
+        when Array
+          obj.map { |v| stringify_keys_deep(v) }
+        else
+          obj
+        end
+      end
+
+      private_class_method :stringify_keys_deep
+    end
+  end
+end

data/lib/rubyn_code/ide/server.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require 'json'
+require_relative 'protocol'
+require_relative 'client'
+require_relative 'handlers'
+
+module RubynCode
+  module IDE
+    # JSON-RPC 2.0 server for the VS Code extension.
+    #
+    # Reads newline-delimited JSON from $stdin, dispatches each request
+    # to a handler, and writes JSON-RPC responses/notifications to $stdout.
+    # All debug output goes to $stderr — never protocol data.
+    #
+    # Processes one request at a time on the main thread.
+    class Server
+      # Attributes set by handlers during the session lifecycle.
+      attr_accessor :workspace_path, :extension_version, :client_capabilities,
+                    :session_persistence, :handler_instances, :tool_output_adapter,
+                    :permission_mode
+      attr_reader :ide_client
+
+      def initialize(permission_mode: :default, yolo: false)
+        @permission_mode = yolo ? :bypass : permission_mode.to_sym
+        @running = false
+        @write_mutex = Mutex.new
+        @handlers = {}
+        @handler_instances = {}
+        @workspace_path = nil
+        @extension_version = nil
+        @client_capabilities = {}
+        @session_persistence = nil
+        @tool_output_adapter = nil
+        @ide_client = Client.new(self)
+
+        Handlers.register_all(self)
+      end
+
+      # Backward-compatible reader: true when permission_mode is :bypass.
+      def yolo
+        @permission_mode == :bypass
+      end
+
+      def run
+        @running = true
+        setup_signal_traps!
+
+        warn "[IDE::Server] started (pid=#{Process.pid})"
+        $stdout.sync = true
+
+        read_loop
+      ensure
+        graceful_shutdown!
+      end
+
+      # ── Public helpers ──────────────────────────────────────────────
+
+      # Send a JSON-RPC notification (no id) to stdout.
+      def notify(method, params = {})
+        write(Protocol.notification(method, params))
+      end
+
+      # Register a handler for a given JSON-RPC method.
+      # The block receives (params, id) and must return a result hash.
+      def on(method, &block)
+        @handlers[method] = block
+      end
+
+      # Look up a handler instance by its short name (e.g. :prompt, :cancel).
+      # Returns nil if the handler is not registered.
+      def handler_instance(short_name)
+        method_name = Handlers::SHORT_NAMES[short_name.to_sym]
+        return nil unless method_name
+
+        @handler_instances[method_name]
+      end
+
+      # Signal the server to stop its read loop.
+      def stop!
+        @running = false
+      end
+
+      private
+
+      # ── Main loop ───────────────────────────────────────────────────
+
+      def read_loop
+        while @running
+          line = $stdin.gets
+          break if line.nil? # EOF — client disconnected
+
+          line = line.strip
+          next if line.empty?
+
+          handle_line(line)
+        end
+      end
+
+      def handle_line(line)
+        msg = Protocol.parse(line)
+
+        # Protocol.parse returns an error response hash when parsing fails.
+        if msg.key?('error')
+          write(msg)
+          return
+        end
+
+        dispatch(msg)
+      rescue StandardError => e
+        warn "[IDE::Server] error handling message: #{e.message}"
+        warn e.backtrace&.first(5)&.join("\n")
+
+        id = msg.is_a?(Hash) ? msg['id'] : nil
+        write(Protocol.error(id, Protocol::INTERNAL_ERROR, "Internal error: #{e.message}"))
+      end
+
+      # ── Dispatch ────────────────────────────────────────────────────
+
+      def dispatch(msg)
+        # Response messages from the extension (for our outbound requests via ide_client).
+        # These have id + (result or error) but no method.
+        if !msg.key?('method') && msg.key?('id') && (msg.key?('result') || msg.key?('error'))
+          @ide_client.resolve(
+            msg['id'],
+            result: msg['result'],
+            error: msg['error']
+          )
+          return
+        end
+
+        method = msg['method']
+        params = msg['params'] || {}
+        id     = msg['id']
+
+        handler = @handlers[method]
+
+        unless handler
+          write(Protocol.error(id, Protocol::METHOD_NOT_FOUND, "Method not found: #{method}")) if id
+          return
+        end
+
+        result = handler.call(params, id)
+
+        # Only send a response for requests (those with an id).
+        # Notifications (no id) do not get responses.
+        write(Protocol.response(id, result)) if id
+      end
+
+      # ── Wire output ─────────────────────────────────────────────────
+
+      def write(hash)
+        serialized = Protocol.serialize(hash)
+        @write_mutex.synchronize do
+          $stdout.write(serialized)
+          $stdout.flush
+        end
+      end
+
+      # ── Signal handling ─────────────────────────────────────────────
+
+      def setup_signal_traps!
+        %w[TERM INT].each do |sig|
+          trap(sig) do
+            warn "[IDE::Server] received SIG#{sig}, shutting down"
+            @running = false
+          end
+        end
+      end
+
+      # ── Shutdown ────────────────────────────────────────────────────
+
+      def graceful_shutdown!
+        warn '[IDE::Server] shutting down'
+        save_session!
+      end
+
+      def save_session!
+        # Delegate to Memory::SessionPersistence if available.
+        @session_persistence.save if defined?(RubynCode::Memory::SessionPersistence) && @session_persistence
+      rescue StandardError => e
+        warn "[IDE::Server] session save failed: #{e.message}"
+      end
+    end
+  end
+end