rubyn-code 0.3.0 → 0.4.0

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module RubynCode
+  module IDE
+    module Handlers
+      # Handles the "session/fork" JSON-RPC request.
+      #
+      # Loads an existing session, truncates its messages at the given index,
+      # and saves the truncated history as a brand-new session. The original
+      # session is left untouched.
+      class SessionForkHandler
+        def initialize(server)
+          @server = server
+        end
+
+        def call(params)
+          session_id = params['sessionId']
+          message_index = params['messageIndex']
+
+          return { 'forked' => false, 'error' => 'Missing sessionId' } unless session_id
+          return { 'forked' => false, 'error' => 'Missing messageIndex' } unless message_index
+
+          persistence = @server.session_persistence
+          return { 'forked' => false, 'error' => 'Session persistence not available' } unless persistence
+
+          data = persistence.load_session(session_id)
+          return { 'forked' => false, 'error' => 'Session not found' } unless data
+
+          messages = data[:messages] || []
+          truncated = messages[0, message_index.to_i]
+
+          new_session_id = SecureRandom.uuid
+          persistence.save_session(
+            session_id: new_session_id,
+            project_path: data[:project_path] || '',
+            messages: truncated,
+            title: data[:title] ? "Fork of #{data[:title]}" : nil,
+            model: data[:model],
+            metadata: { message_count: truncated.size, forked_from: session_id }
+          )
+
+          { 'forked' => true, 'newSessionId' => new_session_id }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module IDE
+    module Handlers
+      # Handles the "session/list" JSON-RPC request.
+      #
+      # Returns a list of past sessions from SessionPersistence, optionally
+      # filtered by project path. If SessionPersistence is not available
+      # (e.g. no database configured), returns an empty sessions array.
+      class SessionListHandler
+        def initialize(server)
+          @server = server
+        end
+
+        def call(params)
+          persistence = @server.session_persistence
+          unless persistence
+            return { 'sessions' => [] }
+          end
+
+          project_path = params['projectPath']
+          limit = params['limit'] || 20
+
+          summaries = persistence.list_sessions(project_path: project_path, limit: limit)
+
+          sessions = summaries.map do |s|
+            {
+              'id' => s[:id],
+              'title' => s[:title],
+              'updatedAt' => s[:updated_at],
+              'messageCount' => (s[:metadata] || {})[:message_count] || 0
+            }
+          end
+
+          { 'sessions' => sessions }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module IDE
+    module Handlers
+      # Handles the "session/reset" JSON-RPC request.
+      #
+      # Called when the user clicks "New Session" in the chat UI. Delegates
+      # to PromptHandler#reset_session which cancels any in-flight agent
+      # thread for that sessionId and drops the cached Agent::Conversation,
+      # so the next prompt starts with empty message history — parity with
+      # the CLI REPL's `/new` command.
+      class SessionResetHandler
+        def initialize(server)
+          @server = server
+        end
+
+        def call(params)
+          session_id = params['sessionId']
+          return { 'reset' => false, 'error' => 'Missing sessionId' } unless session_id
+
+          prompt = @server.handler_instance(:prompt)
+          return { 'reset' => false, 'error' => 'Prompt handler not available' } unless prompt
+
+          prompt.reset_session(session_id)
+          { 'reset' => true, 'sessionId' => session_id }
+        end
+      end
+    end
+  end
+end

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

data/lib/rubyn_code/index/codebase_index.rb

@@ -9,9 +9,10 @@ module RubynCode
     # Stores classes, modules, methods, associations, and Rails edges in a
     # JSON file for fast session startup. First build scans all .rb files;
     # incremental updates re-index only changed files.
-    class CodebaseIndex
+    class CodebaseIndex # rubocop:disable Metrics/ClassLength -- structural summary methods
       INDEX_DIR = '.rubyn-code'
       INDEX_FILE = 'codebase_index.json'
+      CHARS_PER_TOKEN = 4
 
       attr_reader :nodes, :edges, :index_path
 
@@ -103,6 +104,20 @@ module RubynCode
         lines.join("\n")
       end
 
+      # Structural map for system prompt: model names with associations,
+      # controllers, and service objects. Capped to stay within token budget.
+      def to_structural_summary(max_tokens: 500)
+        budget = max_tokens * CHARS_PER_TOKEN
+        lines = ['Codebase Structure:']
+
+        append_model_section(lines)
+        append_controller_section(lines)
+        append_service_section(lines)
+        append_stats_section(lines)
+
+        truncate_to_budget(lines, budget)
+      end
+
       def stats
         {
           files_indexed: @file_mtimes.size,
@@ -113,6 +128,57 @@ module RubynCode
 
       private
 
+      def append_model_section(lines)
+        models = @nodes.select { |n| n['type'] == 'model' && (n['name'] || '').match?(/\A[A-Z]/) }
+        return if models.empty?
+
+        lines << 'Models:'
+        models.each do |model|
+          assocs = associations_for_file(model['file'])
+          desc = assocs.empty? ? model['name'] : "#{model['name']} #{assocs.join(', ')}"
+          lines << "  #{desc}"
+        end
+      end
+
+      def append_controller_section(lines)
+        controllers = @nodes.select { |n| n['type'] == 'controller' && (n['name'] || '').match?(/\A[A-Z]/) }
+        return if controllers.empty?
+
+        lines << 'Controllers:'
+        controllers.each { |c| lines << "  #{c['name']} (#{c['file']})" }
+      end
+
+      def append_service_section(lines)
+        services = @nodes.select { |n| n['type'] == 'service' && (n['name'] || '').match?(/\A[A-Z]/) }
+        return if services.empty?
+
+        lines << 'Services:'
+        services.each { |s| lines << "  #{s['name']} (#{s['file']})" }
+      end
+
+      def append_stats_section(lines)
+        counts = node_type_counts
+        lines << "Stats: #{counts['class'] || 0} classes, #{counts['method'] || 0} methods, #{@edges.size} edges"
+      end
+
+      def associations_for_file(file)
+        @edges.select { |e| e['from'] == file && e['relationship'] == 'association' }
+              .map { |e| "#{e['type']} :#{e['to']}" }
+      end
+
+      def truncate_to_budget(lines, budget)
+        result = []
+        total = 0
+        lines.each do |line|
+          line_size = line.bytesize + 1 # +1 for newline
+          break if total + line_size > budget
+
+          result << line
+          total += line_size
+        end
+        result.join("\n")
+      end
+
       def edges_involving(names)
         @edges.select do |e|
           names.include?(e['from']) || names.include?(e['to'])