rubyn-code 0.3.0 → 0.5.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,112 @@
+# 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.
+      # -- JSON-RPC validation checks
+      def parse(line)
+        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'])
@@ -194,7 +260,8 @@ module RubynCode
         end
       end
 
-      def classify_node(file, type) # rubocop:disable Metrics/CyclomaticComplexity -- Rails directory mapping
+      # -- Rails directory mapping
+      def classify_node(file, type)
         return 'model' if file.include?('app/models/')
         return 'controller' if file.include?('app/controllers/')
         return 'service' if file.include?('app/services/')

data/lib/rubyn_code/learning/extractor.rb

@@ -82,7 +82,8 @@ module RubynCode
           messages.map { |m| format_turn(m) }.join("\n\n")
         end
 
-        def format_turn(msg) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity -- content polymorphism
+        # -- content polymorphism
+        def format_turn(msg)
           role = (msg[:role] || msg['role'] || 'unknown').capitalize
           content = msg[:content] || msg['content']
           text = if content.is_a?(Array)
@@ -121,7 +122,8 @@ module RubynCode
           )
         end
 
-        def parse_response(response) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity -- response parsing with multiple fallbacks
+        # -- response parsing with multiple fallbacks
+        def parse_response(response)
           return [] if response.nil?
 
           text = if response.respond_to?(:content)

data/lib/rubyn_code/llm/adapters/anthropic.rb

@@ -48,6 +48,10 @@ module RubynCode
 
         private
 
+        def api_url
+          API_URL
+        end
+
         # -- Auth ---------------------------------------------------------
 
         def oauth_token?
@@ -88,7 +92,7 @@ module RubynCode
         end
 
         def post_request(body)
-          connection.post(API_URL) do |req|
+          connection.post(api_url) do |req|
             apply_headers(req)
             req.body = JSON.generate(body)
           end
@@ -113,7 +117,7 @@ module RubynCode
           streamer = build_streamer(on_text)
           error_chunks = []
 
-          response = streaming_connection.post(API_URL) do |req|
+          response = streaming_connection.post(api_url) do |req|
             apply_headers(req)
             req.body = JSON.generate(body)
             req.options.on_data = on_data_proc(streamer, error_chunks)

data/lib/rubyn_code/llm/adapters/anthropic_compatible.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module LLM
+    module Adapters
+      # Adapter for Anthropic-compatible providers that use the Messages API format.
+      #
+      # Inherits all Anthropic logic but overrides the base URL, provider name,
+      # available models, and API key resolution.
+      class AnthropicCompatible < Anthropic
+        def initialize(provider:, base_url:, api_key: nil, available_models: [])
+          super()
+          @provider = provider
+          @base_url = base_url
+          @api_key = api_key
+          @available_models = available_models.freeze
+        end
+
+        def provider_name
+          @provider
+        end
+
+        def models
+          @available_models
+        end
+
+        private
+
+        def api_url
+          "#{@base_url}/messages"
+        end
+
+        def ensure_valid_token!
+          resolve_api_key # raises if missing
+        end
+
+        def oauth_token?
+          false
+        end
+
+        def access_token
+          resolve_api_key
+        end
+
+        def resolve_api_key
+          return @api_key if @api_key
+
+          stored = Auth::TokenStore.load_provider_key(@provider)
+          return stored if stored
+
+          env_key = "#{@provider.upcase.tr('-', '_')}_API_KEY"
+          ENV.fetch(env_key) do
+            raise Client::AuthExpiredError,
+                  "No #{@provider} API key configured. Set with: /provider set-key #{@provider} <key>"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/llm/adapters/openai_compatible.rb

@@ -27,11 +27,15 @@ module RubynCode
         def resolve_api_key
           return @api_key if @api_key
 
-          env_key = "#{@provider.upcase}_API_KEY"
+          stored = Auth::TokenStore.load_provider_key(@provider)
+          return stored if stored
+
+          env_key = "#{@provider.upcase.tr('-', '_')}_API_KEY"
           ENV.fetch(env_key) do
             return 'no-key-required' if local_provider?
 
-            raise Client::AuthExpiredError, "No #{@provider} API key configured. Set #{env_key}."
+            raise Client::AuthExpiredError,
+                  "No #{@provider} API key configured. Set with: /provider set-key #{@provider} <key>"
           end
         end