rubyn-code 0.3.0 → 0.4.0

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module IDE
+    module Handlers
+      # Handles the "approveToolUse" JSON-RPC request.
+      #
+      # The extension sends this after the user approves or denies a tool
+      # invocation surfaced with requiresApproval=true. All pending-approval
+      # state lives in the per-session ToolOutput adapter; this handler is a
+      # thin delegate so the server has something registered at the method name.
+      class ApproveToolUseHandler
+        def initialize(server)
+          @server = server
+        end
+
+        def call(params)
+          request_id = params['requestId']
+          approved   = params['approved']
+
+          return { 'resolved' => false, 'error' => 'Missing requestId' } unless request_id
+
+          adapter = @server.tool_output_adapter
+          return { 'resolved' => false, 'error' => 'No active session' } unless adapter
+
+          resolved = adapter.resolve_approval(request_id, approved ? true : false)
+          return { 'resolved' => false, 'error' => "No pending request: #{request_id}" } unless resolved
+
+          { 'resolved' => true, 'requestId' => request_id }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module IDE
+    module Handlers
+      # Handles the "cancel" JSON-RPC request.
+      #
+      # Signals the agent loop thread for the given session to stop,
+      # then returns confirmation.
+      class CancelHandler
+        def initialize(server)
+          @server = server
+        end
+
+        def call(params)
+          session_id = params['sessionId']
+
+          return { 'cancelled' => false, 'error' => 'Missing sessionId' } unless session_id
+
+          # Delegate to the PromptHandler which owns the session threads
+          prompt_handler = @server.handler_instance(:prompt)
+          prompt_handler&.cancel_session(session_id)
+
+          # Fire the stop hook so extensions can react to session cancellation
+          fire_stop_hook(session_id)
+
+          { 'cancelled' => true, 'sessionId' => session_id }
+        end
+
+        private
+
+        def fire_stop_hook(session_id)
+          hook_registry = Hooks::Registry.new
+          hook_runner = Hooks::Runner.new(registry: hook_registry)
+          Hooks::BuiltIn.register_all!(hook_registry)
+          hook_runner.fire(:stop, session_id: session_id)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module IDE
+    module Handlers
+      # Handles "config/get" JSON-RPC requests from the IDE extension.
+      #
+      # When a key is provided, returns that single setting with its source.
+      # When no key is provided, returns all configurable settings plus
+      # provider definitions so the extension can populate its UI.
+      class ConfigGetHandler
+        EXPOSED_KEYS = %w[
+          provider model model_mode max_iterations max_sub_agent_iterations max_output_chars
+          context_threshold_tokens session_budget_usd daily_budget_usd permission_mode
+        ].freeze
+
+        def initialize(server)
+          @server = server
+        end
+
+        def call(params)
+          settings = Config::Settings.new
+          key = params['key']
+
+          if key
+            single_key_response(settings, key)
+          else
+            all_settings_response(settings)
+          end
+        end
+
+        private
+
+        def single_key_response(settings, key)
+          unless EXPOSED_KEYS.include?(key.to_s)
+            return { 'key' => key, 'value' => nil, 'source' => 'unknown',
+                     'error' => "Unknown config key: #{key}" }
+          end
+
+          value = settings.get(key)
+          source = settings.data.key?(key.to_s) ? 'config_file' : 'default'
+
+          { 'key' => key, 'value' => value, 'source' => source }
+        end
+
+        def all_settings_response(settings)
+          result = {}
+
+          EXPOSED_KEYS.each do |key|
+            sym = key.to_sym
+            value = settings.get(key)
+            default = Config::Settings::DEFAULT_MAP[sym]
+            result[key] = { 'value' => value, 'default' => default }
+          end
+
+          providers = settings.data['providers'] || {}
+
+          { 'settings' => result, 'providers' => providers }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require_relative '../../config/validator'
+
+module RubynCode
+  module IDE
+    module Handlers
+      # Handles "config/set" JSON-RPC requests from the IDE extension.
+      #
+      # Validates the key is in the allowed list, coerces types as needed,
+      # persists the change, and notifies the client via config/changed.
+      class ConfigSetHandler
+        EXPOSED_KEYS = ConfigGetHandler::EXPOSED_KEYS
+
+        NUMERIC_KEYS = %w[
+          max_iterations max_sub_agent_iterations max_output_chars
+          context_threshold_tokens session_budget_usd daily_budget_usd
+        ].freeze
+
+        STRING_KEYS = %w[provider model model_mode].freeze
+
+        VALID_PERMISSION_MODES = %w[default accept_edits plan_only auto dont_ask bypass].freeze
+
+        def initialize(server)
+          @server = server
+        end
+
+        def call(params)
+          key = params['key'].to_s
+          value = params['value']
+
+          return { 'updated' => false, 'error' => "Unknown config key: #{key}" } unless EXPOSED_KEYS.include?(key)
+
+          # permission_mode is a runtime-only setting on the server, not persisted to config.
+          if key == 'permission_mode'
+            mode = value.to_s
+            unless VALID_PERMISSION_MODES.include?(mode)
+              return { 'updated' => false,
+                       'error' => "Invalid permission mode: #{mode}. " \
+                                  "Valid modes: #{VALID_PERMISSION_MODES.join(', ')}" }
+            end
+
+            @server.permission_mode = mode.to_sym
+            @server.tool_output_adapter&.permission_mode = mode.to_sym
+            @server.notify('config/changed', { 'key' => key, 'value' => mode })
+            return { 'updated' => true, 'key' => key, 'value' => mode }
+          end
+
+          value = coerce(key, value)
+
+          result = Config::Validator.new.validate(key, value)
+          unless result[:valid]
+            return { 'updated' => false, 'error' => result[:errors].join('; ') }
+          end
+
+          settings = Config::Settings.new
+          settings.set(key, value)
+          settings.save!
+
+          @server.notify('config/changed', { 'key' => key, 'value' => value })
+
+          { 'updated' => true, 'key' => key, 'value' => value }
+        end
+
+        private
+
+        def coerce(key, value)
+          if NUMERIC_KEYS.include?(key)
+            numeric_value(value)
+          else
+            value.to_s
+          end
+        end
+
+        def numeric_value(value)
+          return value if value.is_a?(Numeric)
+
+          str = value.to_s
+          str.include?('.') ? Float(str) : Integer(str)
+        rescue ArgumentError, TypeError
+          value
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module IDE
+    module Handlers
+      # Handles the "initialize" JSON-RPC request from the IDE extension.
+      #
+      # Accepts workspace path, extension metadata, and client capabilities.
+      # Sets the working directory and returns server capabilities so the
+      # extension knows what features are available.
+      class InitializeHandler
+        def initialize(server)
+          @server = server
+        end
+
+        def call(params) # rubocop:disable Metrics/MethodLength -- builds full capability handshake response
+          workspace = params['workspacePath']
+          extension_version = params['extensionVersion']
+          client_caps = params['capabilities'] || {}
+
+          if workspace && Dir.exist?(workspace)
+            Dir.chdir(workspace)
+            @server.workspace_path = workspace
+          end
+
+          @server.extension_version = extension_version
+          @server.client_capabilities = client_caps
+
+          tool_count  = tool_count!
+          skill_count = skill_count!
+
+          {
+            'serverVersion' => RubynCode::VERSION,
+            'protocolVersion' => '1.0',
+            'workspacePath' => Dir.pwd,
+            'capabilities' => {
+              'tools' => tool_count,
+              'skills' => skill_count,
+              'streaming' => true,
+              'review' => true,
+              'memory' => true,
+              'teams' => true,
+              'toolApproval' => true,
+              'editApproval' => true
+            }
+          }
+        end
+
+        private
+
+        def tool_count!
+          Tools::Registry.load_all!
+          Tools::Registry.tool_names.size
+        rescue StandardError
+          0
+        end
+
+        def skill_count!
+          dirs = default_skill_dirs
+          catalog = Skills::Catalog.new(dirs)
+          catalog.available.size
+        rescue StandardError
+          0
+        end
+
+        def default_skill_dirs
+          dirs = [File.expand_path('../../../../skills', __dir__)]
+          if @server.workspace_path
+            project_skills = File.join(@server.workspace_path, '.rubyn-code', 'skills')
+            dirs << project_skills if Dir.exist?(project_skills)
+          end
+          user_skills = File.join(Config::Defaults::HOME_DIR, 'skills')
+          dirs << user_skills if Dir.exist?(user_skills)
+          dirs
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module IDE
+    module Handlers
+      class ModelsListHandler
+        def initialize(server)
+          @server = server
+        end
+
+        def call(_params)
+          settings = Config::Settings.new
+          providers = settings.data['providers'] || {}
+
+          {
+            'models' => collect_models(providers),
+            'activeProvider' => settings.provider,
+            'activeModel' => settings.model,
+            'modelMode' => settings.get('model_mode', 'auto')
+          }
+        end
+
+        private
+
+        def collect_models(providers)
+          models = []
+          providers.each do |name, cfg|
+            next unless cfg.is_a?(Hash) && cfg['models'].is_a?(Hash)
+
+            cfg['models'].each do |tier, model_name|
+              models << { 'provider' => name, 'model' => model_name, 'tier' => tier }
+            end
+          end
+          models
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module RubynCode
+  module IDE
+    module Handlers
+      # Handles the "prompt" JSON-RPC request — the main chat entry point.
+      #
+      # Returns immediately with { "accepted" => true } and spawns a
+      # background thread that runs the agent loop. As the agent works,
+      # it emits stream/text, tool/use, tool/result, and agent/status
+      # notifications over the JSON-RPC transport.
+      class PromptHandler
+        def initialize(server)
+          @server = server
+          @sessions = {}       # sessionId => Thread
+          @conversations = {}  # sessionId => Agent::Conversation (persists across prompts)
+          @started_sessions = Set.new # tracks which sessions have fired session_start
+        end
+
+        # Called by SessionResumeHandler to inject a restored conversation
+        # into the cache so the next prompt continues from the loaded history.
+        def inject_conversation(session_id, conversation)
+          cancel_session(session_id)
+          @conversations[session_id] = conversation
+        end
+
+        # Called by SessionResetHandler when the user clicks "New Session"
+        # in the chat UI. Drops the cached conversation for this session so
+        # the next prompt starts fresh — parity with the CLI's `/new`.
+        def reset_session(session_id)
+          cancel_session(session_id)
+          @conversations.delete(session_id)
+          @started_sessions.delete(session_id)
+        end
+
+        def call(params)
+          text       = params['text'] || ''
+          context    = params['context'] || {}
+          session_id = params['sessionId'] || SecureRandom.uuid
+
+          # Cancel any existing agent thread for this session
+          cancel_session(session_id)
+
+          # Spawn the agent loop in a background thread
+          @sessions[session_id] = Thread.new do
+            run_agent(session_id, text, context)
+          end
+
+          { 'accepted' => true, 'sessionId' => session_id }
+        end
+
+        # Called by CancelHandler to stop a running session.
+        def cancel_session(session_id)
+          thread = @sessions.delete(session_id)
+          return unless thread&.alive?
+
+          thread.raise(Interrupt)
+          thread.join(2) # give it a moment to clean up
+        end
+
+        private
+
+        def run_agent(session_id, text, context) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- orchestrates agent lifecycle with notifications
+          @server.notify('agent/status', {
+                           'sessionId' => session_id,
+                           'status' => 'thinking'
+                         })
+
+          # Fire IDE hooks for prompt lifecycle
+          ide_hook_runner = build_ide_hook_runner
+          unless @started_sessions.include?(session_id)
+            @started_sessions.add(session_id)
+            ide_hook_runner.fire(:session_start, session_id: session_id)
+          end
+          ide_hook_runner.fire(:user_prompt_submit, session_id: session_id, text: text)
+
+          workspace = context['workspacePath'] || @server.workspace_path || Dir.pwd
+          agent_loop = build_agent_loop(session_id, workspace)
+
+          enriched_input = build_enriched_input(text, context)
+
+          @server.notify('agent/status', {
+                           'sessionId' => session_id,
+                           'status' => 'streaming'
+                         })
+
+          response = agent_loop.send_message(enriched_input)
+
+          @server.notify('agent/status', {
+                           'sessionId' => session_id,
+                           'status' => 'done'
+                         })
+
+          @server.notify('stream/text', {
+                           'sessionId' => session_id,
+                           'text' => response,
+                           'final' => true
+                         })
+        rescue Interrupt
+          @server.notify('agent/status', {
+                           'sessionId' => session_id,
+                           'status' => 'cancelled'
+                         })
+        rescue StandardError => e
+          warn "[PromptHandler] error: #{e.message}"
+          warn e.backtrace&.first(5)&.join("\n")
+          @server.notify('agent/status', {
+                           'sessionId' => session_id,
+                           'status' => 'error',
+                           'error' => e.message
+                         })
+        ensure
+          @sessions.delete(session_id)
+        end
+
+        def build_agent_loop(session_id, workspace)
+          llm_client      = LLM::Client.new
+          # Reuse the conversation across prompts in the same session so the
+          # model has multi-turn memory — same model the CLI REPL uses. A
+          # fresh Agent::Loop is built per prompt (cheap, bundle of refs),
+          # but the conversation (messages array) persists. `session/reset`
+          # drops the cached entry; the next prompt starts a fresh one.
+          conversation    = @conversations[session_id] ||= Agent::Conversation.new
+
+          # Register IDE-only tools (diagnostics, symbols) when running in IDE mode.
+          Tools::Registry.load_ide_tools! if @server.ide_client
+
+          tool_executor   = Tools::Executor.new(project_root: workspace, ide_client: @server.ide_client)
+          context_manager = Context::Manager.new(llm_client: llm_client)
+          hook_registry   = Hooks::Registry.new
+          hook_runner     = Hooks::Runner.new(registry: hook_registry)
+          stall_detector  = Agent::LoopDetector.new
+
+          Hooks::BuiltIn.register_all!(hook_registry)
+
+          tool_executor.llm_client = llm_client
+
+          adapter = build_tool_output_adapter
+          tool_wrapper = lambda do |name, input, &blk|
+            adapter.wrap_execution(name, input, &blk)
+          end
+
+          Agent::Loop.new(
+            llm_client: llm_client,
+            tool_executor: tool_executor,
+            context_manager: context_manager,
+            hook_runner: hook_runner,
+            conversation: conversation,
+            # Gating happens in the ToolOutput adapter (per-tool, via JSON-RPC).
+            # The policy tier must not intercept — it has no way to prompt the
+            # user in IDE mode and would otherwise fall back to the TTY prompter
+            # which corrupts the JSON-RPC stream on stdout.
+            permission_tier: :unrestricted,
+            deny_list: Permissions::DenyList.new,
+            stall_detector: stall_detector,
+            tool_wrapper: tool_wrapper,
+            on_text: build_text_callback(session_id),
+            project_root: workspace,
+            ide_client: @server.ide_client
+          )
+        end
+
+        # Install a ToolOutput adapter on the server so AcceptEdit /
+        # ApproveToolUse handlers can route responses back to this session.
+        def build_tool_output_adapter
+          adapter = IDE::Adapters::ToolOutput.new(@server, permission_mode: @server.permission_mode, hook_runner: build_ide_hook_runner)
+          @server.tool_output_adapter = adapter
+          adapter
+        end
+
+        def build_text_callback(session_id)
+          lambda { |text|
+            @server.notify('agent/status', {
+                             'sessionId' => session_id,
+                             'status' => 'streaming'
+                           })
+            @server.notify('stream/text', {
+                             'sessionId' => session_id,
+                             'text' => text,
+                             'final' => false
+                           })
+          }
+        end
+
+        def build_ide_hook_runner
+          registry = Hooks::Registry.new
+          Hooks::BuiltIn.register_all!(registry)
+          Hooks::Runner.new(registry: registry)
+        end
+
+        def build_enriched_input(text, context) # rubocop:disable Metrics/AbcSize -- assembles context parts from multiple optional fields
+          parts = []
+
+          parts << "[Active file: #{context['activeFile']}]" if context['activeFile']
+
+          if context['selection']
+            sel = context['selection']
+            range = "lines #{sel['startLine']}-#{sel['endLine']}"
+            parts << "[Selection (#{range}):\n#{sel['text']}\n]"
+          end
+
+          parts << "[Open files: #{context['openFiles'].join(', ')}]" if context['openFiles']&.any?
+
+          if parts.any?
+            "#{parts.join("\n")}\n\n#{text}"
+          else
+            text
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module IDE
+    module Handlers
+      # Handles the "review" JSON-RPC request.
+      #
+      # Delegates to the existing ReviewPr tool, running it in a
+      # background thread. Emits review/finding notifications as
+      # findings are extracted from the review output.
+      class ReviewHandler
+        def initialize(server)
+          @server = server
+        end
+
+        def call(params)
+          base_branch = params['baseBranch'] || 'main'
+          focus       = params['focus'] || 'all'
+          session_id  = params['sessionId'] || SecureRandom.uuid
+
+          Thread.new do
+            run_review(session_id, base_branch, focus)
+          end
+
+          { 'accepted' => true, 'sessionId' => session_id }
+        end
+
+        # Extract structured findings from the raw review text.
+        # Looks for severity markers like [critical], [warning], etc.
+        SEVERITY_PATTERN = /\[(critical|warning|suggestion|nitpick)\]/i
+
+        private
+
+        def run_review(session_id, base_branch, focus) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- review lifecycle with finding notifications
+          @server.notify('agent/status', {
+                           'sessionId' => session_id,
+                           'status' => 'reviewing'
+                         })
+
+          workspace = @server.workspace_path || Dir.pwd
+          review_tool = Tools::ReviewPr.new(project_root: workspace)
+          result = review_tool.execute(base_branch: base_branch, focus: focus)
+
+          # Parse the review output into individual findings and emit them
+          findings = extract_findings(result)
+          findings.each_with_index do |finding, idx|
+            @server.notify('review/finding', {
+                             'sessionId' => session_id,
+                             'index' => idx,
+                             'severity' => finding[:severity],
+                             'message' => finding[:message],
+                             'file' => finding[:file],
+                             'line' => finding[:line]
+                           })
+          end
+
+          @server.notify('agent/status', {
+                           'sessionId' => session_id,
+                           'status' => 'done',
+                           'summary' => "Review complete: #{findings.size} finding(s)"
+                         })
+        rescue StandardError => e
+          warn "[ReviewHandler] error: #{e.message}"
+          @server.notify('agent/status', {
+                           'sessionId' => session_id,
+                           'status' => 'error',
+                           'error' => e.message
+                         })
+        end
+
+        def extract_findings(review_text)
+          return [] unless review_text.is_a?(String)
+
+          findings = []
+          current_finding = nil
+
+          review_text.each_line do |line|
+            if (match = line.match(SEVERITY_PATTERN))
+              # Save previous finding
+              findings << current_finding if current_finding
+
+              current_finding = {
+                severity: match[1].downcase,
+                message: line.strip,
+                file: extract_file_reference(line),
+                line: extract_line_number(line)
+              }
+            elsif current_finding
+              # Append continuation lines to the current finding
+              current_finding[:message] = "#{current_finding[:message]}\n#{line.rstrip}"
+            end
+          end
+
+          findings << current_finding if current_finding
+          findings
+        end
+
+        def extract_file_reference(line)
+          match = line.match(%r{(?:^|\s)([\w/\-_.]+\.\w+)})
+          match ? match[1] : nil
+        end
+
+        def extract_line_number(line)
+          match = line.match(/(?:line\s+|L)(\d+)/i)
+          match ? match[1].to_i : nil
+        end
+      end
+    end
+  end
+end