rubyn-code 0.5.0 → 0.7.0

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module IDE
+    module Handlers
+      # Handles "plan/interview/answer" — feeds the user's answer into the
+      # active InterviewSession, emits the next question OR the final plan
+      # via notifications, and returns an empty ack to the extension.
+      class PlanInterviewAnswerHandler
+        SESSION_NOT_FOUND_CODE = -32_011
+        INVALID_INTERVIEW_CODE = -32_010
+
+        def initialize(server)
+          @server = server
+        end
+
+        def call(params)
+          session_id  = params['sessionId'].to_s
+          question_id = params['questionId'].to_s
+          answer      = params['answer'].to_s
+
+          session = @server.lookup_interview_session(session_id)
+          unless session
+            raise Protocol::JsonRpcError.new(SESSION_NOT_FOUND_CODE,
+                                             "Unknown interview session: #{session_id}")
+          end
+
+          outcome = session.answer(question_id, answer)
+          emit_outcome(session, outcome)
+          {}
+        rescue Megaplan::InterviewSession::InvalidAnswerError => e
+          raise Protocol::JsonRpcError.new(Protocol::INVALID_PARAMS, e.message)
+        rescue Megaplan::InterviewSession::MalformedResponseError,
+               Megaplan::PlanProposer::InvalidProposalError => e
+          warn "[PlanInterviewAnswerHandler] interview failed: #{e.message}"
+          @server.notify('plan/interview/error', {
+                           'sessionId' => params['sessionId'],
+                           'message' => e.message
+                         })
+          @server.drop_interview_session(params['sessionId'].to_s)
+          raise Protocol::JsonRpcError.new(INVALID_INTERVIEW_CODE, e.message)
+        end
+
+        private
+
+        def emit_outcome(session, outcome)
+          if outcome.is_a?(Megaplan::InterviewSession::Question)
+            @server.notify('plan/interview/question', {
+                             'sessionId' => session.session_id,
+                             'questionId' => outcome.id,
+                             'text' => outcome.text,
+                             'options' => outcome.options
+                           })
+          else
+            @server.notify('plan/interview/done', {
+                             'sessionId' => session.session_id,
+                             'plan' => outcome
+                           })
+            @server.drop_interview_session(session.session_id)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module IDE
+    module Handlers
+      # Handles "plan/interview/cancel" — drops the named InterviewSession.
+      # Notification handler (no id), so it never sends a response. Unknown
+      # sessionIds are no-ops; the extension treats cancel as best-effort.
+      class PlanInterviewCancelHandler
+        def initialize(server)
+          @server = server
+        end
+
+        def call(params)
+          session_id = params['sessionId'].to_s
+          @server.drop_interview_session(session_id)
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module IDE
+    module Handlers
+      # Handles "plan/interview/start" — kicks off a megaplan interview
+      # session. Creates the InterviewSession, fires the first LLM turn,
+      # and emits either a plan/interview/question or plan/interview/done
+      # notification before returning the new sessionId to the extension.
+      class PlanInterviewStartHandler
+        INVALID_INTERVIEW_CODE = -32_010
+
+        def initialize(server, factory: nil)
+          @server = server
+          @factory = factory || lambda { |workspace_path:|
+            Megaplan::InterviewSession.new(workspace_path: workspace_path)
+          }
+        end
+
+        def call(_params)
+          session = @factory.call(workspace_path: @server.workspace_path || Dir.pwd)
+          @server.register_interview_session(session)
+          outcome = session.start
+          emit_outcome(session, outcome)
+          { 'sessionId' => session.session_id }
+        rescue Megaplan::InterviewSession::MalformedResponseError,
+               Megaplan::PlanProposer::InvalidProposalError => e
+          warn "[PlanInterviewStartHandler] interview failed: #{e.message}"
+          raise Protocol::JsonRpcError.new(INVALID_INTERVIEW_CODE, e.message)
+        end
+
+        private
+
+        def emit_outcome(session, outcome)
+          if outcome.is_a?(Megaplan::InterviewSession::Question)
+            @server.notify('plan/interview/question', {
+                             'sessionId' => session.session_id,
+                             'questionId' => outcome.id,
+                             'text' => outcome.text,
+                             'options' => outcome.options
+                           })
+          else
+            @server.notify('plan/interview/done', {
+                             'sessionId' => session.session_id,
+                             'plan' => outcome
+                           })
+            @server.drop_interview_session(session.session_id)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module RubynCode
+  module IDE
+    module Handlers
+      # Handles the "plan/propose" JSON-RPC request.
+      #
+      # Synchronous: blocks until the LLM returns a structured plan or
+      # raises. The extension shows a progress spinner during the call;
+      # plan generation typically takes 5-30s.
+      #
+      # Response shape mirrors what the extension's PlanManager.toPlan
+      # expects: { slug, feature, phases: [{ number, name, slug, summary,
+      # requirements_md, design_md, tasks_md }] }.
+      class PlanProposeHandler
+        # JSON-RPC error code: a clear signal to the extension that the
+        # LLM produced an unparseable / malformed plan_proposal. The
+        # extension surfaces this with the actual error message.
+        INVALID_PROPOSAL_CODE = -32_001
+
+        def initialize(server, proposer: nil)
+          @server = server
+          @proposer = proposer
+        end
+
+        def call(params)
+          feature = params['feature'].to_s.strip
+          raise Protocol::JsonRpcError.new(Protocol::INVALID_PARAMS, 'feature is required') if feature.empty?
+
+          proposer = @proposer || Megaplan::PlanProposer.new
+          proposer.propose(feature)
+        rescue Megaplan::PlanProposer::InvalidProposalError => e
+          warn "[PlanProposeHandler] invalid proposal: #{e.message}"
+          raise Protocol::JsonRpcError.new(INVALID_PROPOSAL_CODE, e.message)
+        end
+      end
+    end
+  end
+end

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

@@ -57,7 +57,15 @@ module RubynCode
           return unless thread&.alive?
 
           thread.raise(Interrupt)
-          thread.join(2) # give it a moment to clean up
+          begin
+            thread.join(2) # give it a moment to clean up
+          rescue Interrupt
+            # We asked the thread to stop, so its Interrupt is expected. If it
+            # lands before the agent installs its own rescue, Thread#join would
+            # otherwise re-raise it into the caller (the cancel path) and, in
+            # tests, escape the example and abort the whole run.
+            nil
+          end
         end
 
         private

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

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module RubynCode
+  module IDE
+    module Handlers
+      # Handles the "recover_ci" JSON-RPC request.
+      #
+      # Takes the recovery context the extension packaged (failing log,
+      # phase docs, branch, attempt counts) and runs the agent against
+      # it. Returns the recovery_outcome { kind, commit_sha?, summary? }.
+      #
+      # The handler spawns the actual agent work in a background thread
+      # so the JSON-RPC reply can include a sessionId immediately. The
+      # extension watches the session via the existing agent/status
+      # notifications + a terminal recovery/outcome notification carrying
+      # the structured result.
+      class RecoverCiHandler
+        def initialize(server, recovery: nil)
+          @server = server
+          @recovery = recovery
+        end
+
+        def call(params)
+          context = normalize_params(params)
+          return error_response('context required') if context.nil?
+
+          session_id = params['sessionId'] || SecureRandom.uuid
+          Thread.new do
+            run_recovery(session_id, context)
+          end
+          { 'accepted' => true, 'sessionId' => session_id }
+        end
+
+        private
+
+        def run_recovery(session_id, context)
+          notify_recovering(session_id, context)
+
+          recovery = @recovery || Megaplan::CiRecovery.new(
+            agent_invoker: build_invoker(session_id)
+          )
+          outcome = recovery.recover(context)
+
+          notify_outcome(session_id, context, outcome)
+          @server.notify('agent/status', {
+                           'sessionId' => session_id,
+                           'status' => 'done',
+                           'summary' => outcome['summary']
+                         })
+        rescue StandardError => e
+          warn "[RecoverCiHandler] error: #{e.message}"
+          notify_error(session_id, context, e)
+        end
+
+        def notify_recovering(session_id, context)
+          @server.notify('agent/status', {
+                           'sessionId' => session_id,
+                           'status' => 'recovering',
+                           'phaseNumber' => context['phase_number'],
+                           'attemptNumber' => context['attempt_number']
+                         })
+        end
+
+        def notify_outcome(session_id, context, outcome)
+          @server.notify('recovery/outcome', {
+                           'sessionId' => session_id,
+                           'planId' => context['plan_id'],
+                           'phaseNumber' => context['phase_number'],
+                           'kind' => outcome['kind'],
+                           'commitSha' => outcome['commit_sha'],
+                           'summary' => outcome['summary']
+                         })
+        end
+
+        def notify_error(session_id, context, error)
+          @server.notify('recovery/outcome', {
+                           'sessionId' => session_id,
+                           'planId' => context['plan_id'],
+                           'phaseNumber' => context['phase_number'],
+                           'kind' => 'errored',
+                           'summary' => error.message
+                         })
+          @server.notify('agent/status', {
+                           'sessionId' => session_id,
+                           'status' => 'error',
+                           'error' => error.message
+                         })
+        end
+
+        # Build an agent invoker that routes the recovery prompt through
+        # the same Agent::Loop the existing PromptHandler uses, but with
+        # the streaming text wired back as agent/status notifications
+        # tagged with the recovery session id.
+        def build_invoker(session_id)
+          lambda do |prompt, _context|
+            llm_client = LLM::Client.new
+            response = llm_client.chat(
+              messages: [{ role: 'user', content: prompt }],
+              on_text: lambda { |text|
+                @server.notify('stream/text', {
+                                 'sessionId' => session_id,
+                                 'text' => text,
+                                 'final' => false
+                               })
+              }
+            )
+            response.is_a?(Hash) ? response : { 'text' => response.to_s }
+          end
+        end
+
+        def normalize_params(params)
+          return nil unless params.is_a?(Hash)
+
+          # Accept both snake_case and camelCase keys — the extension
+          # produces camelCase, but the LLM-side service uses snake_case
+          # internally. Normalize once at the boundary.
+          mapping = {
+            'planId' => 'plan_id',
+            'phaseNumber' => 'phase_number',
+            'prNumber' => 'pr_number',
+            'failingCheckName' => 'failing_check_name',
+            'fullLog' => 'full_log',
+            'trimmedLog' => 'trimmed_log',
+            'commitSha' => 'commit_sha',
+            'attemptNumber' => 'attempt_number',
+            'maxAttempts' => 'max_attempts'
+          }
+          out = params.dup
+          mapping.each do |camel, snake|
+            out[snake] = out.delete(camel) if out.key?(camel) && !out.key?(snake)
+          end
+          out
+        end
+
+        def error_response(message, code: -32_602)
+          { 'error' => { 'code' => code, 'message' => message } }
+        end
+      end
+    end
+  end
+end

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

@@ -30,7 +30,7 @@ module RubynCode
           prompt = @server.handler_instance(:prompt)
           if prompt
             conversation = Agent::Conversation.new
-            messages.each { |msg| conversation.messages << msg }
+            conversation.replace!(messages.dup)
             prompt.inject_conversation(session_id, conversation)
           end
 

data/lib/rubyn_code/ide/handlers.rb

@@ -14,6 +14,11 @@ require_relative 'handlers/session_reset_handler'
 require_relative 'handlers/session_list_handler'
 require_relative 'handlers/session_resume_handler'
 require_relative 'handlers/session_fork_handler'
+require_relative 'handlers/plan_propose_handler'
+require_relative 'handlers/plan_interview_start_handler'
+require_relative 'handlers/plan_interview_answer_handler'
+require_relative 'handlers/plan_interview_cancel_handler'
+require_relative 'handlers/recover_ci_handler'
 
 module RubynCode
   module IDE
@@ -33,7 +38,12 @@ module RubynCode
         'session/reset' => SessionResetHandler,
         'session/list' => SessionListHandler,
         'session/resume' => SessionResumeHandler,
-        'session/fork' => SessionForkHandler
+        'session/fork' => SessionForkHandler,
+        'plan/propose' => PlanProposeHandler,
+        'plan/interview/start' => PlanInterviewStartHandler,
+        'plan/interview/answer' => PlanInterviewAnswerHandler,
+        'plan/interview/cancel' => PlanInterviewCancelHandler,
+        'recover_ci' => RecoverCiHandler
       }.freeze
 
       # Short name => method name mapping (for handler_instance lookups).
@@ -51,7 +61,12 @@ module RubynCode
         session_reset: 'session/reset',
         session_list: 'session/list',
         session_resume: 'session/resume',
-        session_fork: 'session/fork'
+        session_fork: 'session/fork',
+        plan_propose: 'plan/propose',
+        plan_interview_start: 'plan/interview/start',
+        plan_interview_answer: 'plan/interview/answer',
+        plan_interview_cancel: 'plan/interview/cancel',
+        recover_ci: 'recover_ci'
       }.freeze
 
       # Register all handlers on the given server instance.

data/lib/rubyn_code/ide/protocol.rb

@@ -21,6 +21,21 @@ module RubynCode
       SESSION_NOT_FOUND = -2
       BUDGET_EXCEEDED   = -3
 
+      # Raise from a handler to emit a JSON-RPC error response with a
+      # specific code. The dispatcher catches this and converts it to a
+      # proper `error` envelope — handlers don't have to know how to write
+      # to the wire. Use this instead of returning `{ 'error' => ... }` as
+      # the handler result, which the dispatcher would otherwise serialize
+      # as a successful `result` payload (the very bug this class fixes).
+      class JsonRpcError < StandardError
+        attr_reader :code
+
+        def initialize(code, message)
+          super(message)
+          @code = code
+        end
+      end
+
       module_function
 
       # Parse a JSON string into a request hash.

data/lib/rubyn_code/ide/server.rb

@@ -21,7 +21,7 @@ module RubynCode
                     :permission_mode
       attr_reader :ide_client
 
-      def initialize(permission_mode: :default, yolo: false)
+      def initialize(permission_mode: :default, yolo: false, workspace_path: nil)
         @permission_mode = yolo ? :bypass : permission_mode.to_sym
         @running = false
         @write_mutex = Mutex.new
@@ -33,10 +33,45 @@ module RubynCode
         @session_persistence = nil
         @tool_output_adapter = nil
         @ide_client = Client.new(self)
+        @interview_sessions = {}
+
+        apply_initial_workspace(workspace_path)
 
         Handlers.register_all(self)
       end
 
+      # ── Interview session registry ──────────────────────────────────
+      # Owned by the IDE Server so handlers can look up the same session
+      # across start / answer / cancel JSON-RPC calls.
+
+      def register_interview_session(session)
+        @interview_sessions[session.session_id] = session
+      end
+
+      def lookup_interview_session(session_id)
+        @interview_sessions[session_id]
+      end
+
+      def drop_interview_session(session_id)
+        @interview_sessions.delete(session_id)
+      end
+
+      # Adopt a workspace path supplied on the command line (--dir). Done
+      # before the `initialize` JSON-RPC handshake so tools that resolve
+      # their project_root at construction time don't fall back to Dir.pwd
+      # — which in some launch contexts (Docker, double-clicked VS Code on
+      # macOS) is something useless like `/app` or `/`.
+      def apply_initial_workspace(path)
+        return unless path && !path.empty?
+
+        if Dir.exist?(path)
+          Dir.chdir(path)
+          @workspace_path = path
+        else
+          warn "[IDE::Server] --dir path does not exist, ignoring: #{path}"
+        end
+      end
+
       # Backward-compatible reader: true when permission_mode is :bypass.
       def yolo
         @permission_mode == :bypass
@@ -107,6 +142,9 @@ module RubynCode
         end
 
         dispatch(msg)
+      rescue Protocol::JsonRpcError => e
+        id = msg.is_a?(Hash) ? msg['id'] : nil
+        write(Protocol.error(id, e.code, e.message)) if id
       rescue StandardError => e
         warn "[IDE::Server] error handling message: #{e.message}"
         warn e.backtrace&.first(5)&.join("\n")

data/lib/rubyn_code/index/codebase_index.rb

@@ -2,6 +2,7 @@
 
 require 'json'
 require 'fileutils'
+require 'open3'
 
 module RubynCode
   module Index
@@ -42,7 +43,9 @@ module RubynCode
 
         data = JSON.parse(File.read(@index_path))
         @nodes = data['nodes'] || []
-        @edges = data['edges'] || []
+        # uniq drops duplicate edges accumulated by older versions, which
+        # appended tests edges on every update! without dedup.
+        @edges = (data['edges'] || []).uniq
         @file_mtimes = data['file_mtimes'] || {}
         self
       rescue StandardError
@@ -69,6 +72,19 @@ module RubynCode
         self
       end
 
+      # Incremental update for a single known-changed file (e.g. after a
+      # write_file/edit_file tool call). Avoids the full-tree scan in update!.
+      def update_file!(path)
+        absolute = File.expand_path(path, @project_root)
+        return self unless absolute.start_with?("#{@project_root}/")
+
+        remove_nodes_for(absolute)
+        index_file(absolute) if File.exist?(absolute)
+        extract_rails_edges
+        save!
+        self
+      end
+
       # Query the index for symbols matching a search term.
       def query(term)
         pattern = term.to_s.downcase
@@ -192,6 +208,26 @@ module RubynCode
       end
 
       def ruby_files
+        git_ruby_files || glob_ruby_files
+      end
+
+      # Prefer git's file list when available: it skips ignored dirs
+      # (tmp/, log/, coverage/, db/) the glob would index. --others picks up
+      # untracked-but-not-ignored files so freshly created ones still appear.
+      def git_ruby_files
+        return nil unless File.exist?(File.join(@project_root, '.git'))
+
+        stdout, status = Open3.capture2(
+          'git', '-C', @project_root, 'ls-files', '-z', '--cached', '--others', '--exclude-standard', '--', '*.rb'
+        )
+        return nil unless status.success?
+
+        stdout.split("\0").map { |f| File.join(@project_root, f) }.select { |f| File.file?(f) }
+      rescue StandardError
+        nil
+      end
+
+      def glob_ruby_files
         Dir.glob(File.join(@project_root, '**', '*.rb'))
            .reject { |f| f.include?('/vendor/') || f.include?('/node_modules/') }
       end
@@ -253,6 +289,8 @@ module RubynCode
       end
 
       def extract_rails_edges
+        # Rebuild tests edges from scratch so repeated updates stay idempotent.
+        @edges.reject! { |e| e['relationship'] == 'tests' }
         spec_files = @file_mtimes.keys.select { |f| f.include?('spec/') || f.include?('test/') }
         spec_files.each do |spec_file|
           source = spec_file.sub(%r{spec/}, 'app/').sub(/_spec\.rb$/, '.rb')