rubyn-code 0.3.0 → 0.5.0

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,218 @@
+# 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
+
+        # -- orchestrates agent lifecycle with notifications
+        def run_agent(session_id, text, context)
+          @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
+
+        # -- assembles context parts from multiple optional fields
+        def build_enriched_input(text, context)
+          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,127 @@
+# frozen_string_literal: true
+
+require_relative '../../skills/pack_context'
+
+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/MethodLength -- review lifecycle with finding notifications
+          @server.notify('agent/status', {
+                           'sessionId' => session_id,
+                           'status' => 'reviewing'
+                         })
+
+          workspace = @server.workspace_path || Dir.pwd
+          pack_context = build_pack_context(workspace)
+          review_tool = Tools::ReviewPr.new(project_root: workspace)
+          result = review_tool.execute(base_branch: base_branch, focus: focus, pack_context: pack_context)
+
+          # 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
+
+        # Fetch skill pack context for gems detected in the repo's Gemfile.
+        # Returns nil on any failure — pack context is best-effort and must never
+        # block the review from running.
+        #
+        # @param workspace [String] absolute path to the repository
+        # @return [String, nil] formatted context block or nil
+        def build_pack_context(workspace)
+          context = Skills::PackContext.for_repo(project_root: workspace)
+          block = context.build_context_block
+          block.empty? ? nil : block
+        rescue StandardError
+          nil
+        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

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