rubik 0.1.0

data/lib/rubik/repl/input_loop.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+module Rubik
+  module REPL
+    # Öneri 3 (Kademe 1): Shell'den ayrılan girdi döngüsü sorumluluğu.
+    # Hem interaktif (Reline) hem stream (pipeline) koşumunun satır düzeyi
+    # ayrıştırması: çoklu-satır tamponu, heredoc modu ve EOF/^C davranışı.
+    # Durum Shell'de yaşar (@running, @reline, @input, @output); bu modül
+    # yalnızca döngü politikasını kodlar.
+    module InputLoop
+      def run_stream(stream)
+        stream.each_line do |line|
+          break unless @running
+
+          process_multiline_or_line(line.chomp)
+        end
+      end
+
+      def run_interactive
+        @running = true
+        multiline_buffer = []
+        heredoc_delimiter = nil
+        last_line_at = nil
+        print_banner
+        Rubik::REPL::InterruptHandler.with_handler do
+          while @running
+            result = read_and_process_line(multiline_buffer, heredoc_delimiter, last_line_at: last_line_at)
+            break if result[:stop]
+
+            multiline_buffer = result[:buffer]
+            heredoc_delimiter = result[:delimiter]
+            last_line_at = result[:last_line_at]
+          end
+        end
+      ensure
+        stop
+      end
+
+      # Plan 91 — Explicit paste mode: `!paste` starts a line-collector
+      # (PasteSupport#read_paste_block); the joined text is dispatched
+      # through the normal prompt path. Executed INSIDE run_interactive
+      # (not read_and_process_line) so the paste reader fully replaces
+      # readline-based collection while the mode is active.
+      def run_paste_mode
+        text = read_paste_block
+        return { stop: false, buffer: [], delimiter: nil } if text.strip.empty?
+
+        execute_input(text)
+        { stop: false, buffer: [], delimiter: nil }
+      end
+
+      # Processes one line of interactive input. Returns a hash with:
+      #   stop:      true if the REPL should exit
+      #   buffer:    updated multiline buffer
+      #   delimiter: updated heredoc delimiter (nil if not in heredoc mode)
+      #   last_line_at: monotonic timestamp of this accepted line (Plan 91)
+      def read_and_process_line(multiline_buffer, heredoc_delimiter, last_line_at: nil)
+        # Plan 91 fix: capture-then-reset BEFORE the early return. Resetting
+        # only on the fall-through path leaked the flag when paste mode was
+        # taken, so every subsequent prompt re-entered run_paste_mode and a
+        # test/piped readline returning nil spun the loop forever.
+        paste_mode = @paste_requested
+        @paste_requested = false
+        return run_paste_mode if paste_mode && heredoc_delimiter.nil? && multiline_buffer.empty?
+
+        flush_subagent_notices! if respond_to?(:flush_subagent_notices!)
+        @terminal_guard&.flush_notices!
+        current_prompt, boxed = prepare_prompt_line(!heredoc_delimiter.nil?)
+        line = safe_readline(current_prompt, add_history: false)
+        @output.puts box_bottom_border if boxed
+        return handle_eof(multiline_buffer, heredoc_delimiter) if line.nil? || line == "\x04" || line == "\x1a"
+
+        # Plan 91 — paste-burst collection: when lines arrive faster than
+        # ui.paste_join_window_ms apart (or Reline reports in_pasting?), the
+        # pasted lines are buffered and submitted as ONE prompt turn instead
+        # of one turn per line. First line still executes immediately if the
+        # burst stops; a lone line typed by hand (or Enter pressed in an
+        # empty prompt) executes as before.
+        #
+        # Gated to REAL interactive consoles only: with stubbed/piped readline
+        # (tests, RUBIK_TEST=1, non-TTY stdin) every stubbed line arrives
+        # "instantly", so an ungated collector would swallow consecutive test
+        # lines like "x = a << 1" + "exit" into one turn (seen in test_repl).
+        now = paste_clock
+        if paste_burst_eligible? && !line.strip.empty? && !heredoc_delimiter &&
+           multiline_buffer.empty? &&
+           (paste_line_fast?(last_line_at, now) || paste_pending?)
+          return collect_paste_burst(line)
+        end
+
+        # Push non-empty command to history
+        @reline::HISTORY.push(line) if !line.strip.empty? && line != begin
+          @reline::HISTORY.to_a.last
+        rescue
+          nil
+        end
+
+        # Plan 109 — reactive wake-up: an empty submitted line while
+        # wake-worthy notices are pending becomes the autonomous notice
+        # turn (both the safe_wakeup!-injected Enter and a user's
+        # Enter-on-empty land here). Heredoc body lines are content,
+        # never a turn; paste bursts and history already exclude empty
+        # lines.
+        if heredoc_delimiter.nil? && line.strip.empty? && respond_to?(:pending_wake_notices?) && pending_wake_notices?
+          execute_subagent_notice_turn!
+          return { stop: false, buffer: [], delimiter: nil, last_line_at: now }
+        end
+
+        result = if heredoc_delimiter
+                   process_heredoc_line(line, multiline_buffer, heredoc_delimiter)
+                 else
+                   process_normal_line(line, multiline_buffer)
+                 end
+        result[:last_line_at] = now
+        result
+      rescue Interrupt
+        @output.puts "^C"
+        Rubik::REPL::InterruptHandler.restore_console_after_interrupt
+        { stop: false, buffer: [], delimiter: nil }
+      rescue StandardError => e
+        @output.puts "[REPL Error] #{e.class}: #{e.message}"
+        { stop: false, buffer: [], delimiter: nil }
+      end
+
+      # Plan 91 — burst collector: keeps reading lines while they arrive
+      # within ui.paste_join_window_ms of each other (or Reline reports
+      # pending paste input); submits the joined block as a single prompt
+      # turn. EOF/Ctrl+D flushes what was collected. Guarded against slow
+      # stdin consumers (run_stream-style piping unaffected — this path
+      # only runs for interactive readline input).
+      def collect_paste_burst(first_line)
+        lines = [first_line]
+        last_at = paste_clock
+        # Plan 109: collection runs with_collecting so a reactive wake
+        # Enter cannot append a blank line inside the pasted block.
+        collector = lambda do
+          loop do
+            line = safe_readline("paste… ", add_history: false)
+            now = paste_clock
+            break if line.nil? || line == "\x04" || line == "\x1a" # EOF flushes the block
+
+            in_paste = paste_line_fast?(last_at, now) || paste_pending?
+            last_at = now
+            break unless in_paste # burst ended -> user is typing again; flush
+
+            lines << line
+          end
+        end
+        if @terminal_guard.respond_to?(:with_collecting)
+          @terminal_guard.with_collecting(&collector)
+        else
+          collector.call
+        end
+        text = lines.join("\n")
+        execute_input(text)
+        # Return the final line timestamp so a following paste burst chain
+        # (copy #2 right after copy #1) is still detected as fast lines.
+        { stop: false, buffer: [], delimiter: nil, last_line_at: last_at }
+      end
+
+      def safe_readline(prompt, add_history: false)
+        if @terminal_guard
+          @terminal_guard.with_reading { @reline.readline(prompt, add_history) }
+        else
+          @reline.readline(prompt, add_history)
+        end
+      end
+
+      def handle_eof(multiline_buffer, heredoc_delimiter)
+        if heredoc_delimiter
+          @output.puts "\n[Rubik] Multiline input cancelled."
+          { stop: false, buffer: [], delimiter: nil }
+        else
+          stop
+          { stop: true, buffer: multiline_buffer, delimiter: heredoc_delimiter }
+        end
+      end
+
+      def process_heredoc_line(line, multiline_buffer, heredoc_delimiter)
+        if line.strip == heredoc_delimiter
+          full_text = multiline_buffer.join("\n")
+          execute_input(full_text)
+          { stop: false, buffer: [], delimiter: nil }
+        else
+          multiline_buffer << line
+          { stop: false, buffer: multiline_buffer, delimiter: heredoc_delimiter }
+        end
+      end
+
+      def process_normal_line(line, _multiline_buffer)
+        # Only trigger heredoc if line explicitly opens a multiline block (e.g. `<<EOF`, `!plan <<EOF`)
+        # NEVER trigger on inline operators like `array << item` or `a << b`
+        heredoc_match = line.match(/^\s*(?:[a-zA-Z0-9_!.-]+\s+)?<<[-~]?['"]?([A-Za-z0-9_]+)['"]?\s*$/)
+        if heredoc_match && !line.strip.start_with?("#")
+          delimiter = heredoc_match[1]
+          prefix = line.sub(/<<[-~]?['"]?#{Regexp.escape(delimiter)}['"]?\s*$/, "").strip
+          buffer = prefix.empty? ? [] : [prefix]
+          { stop: false, buffer: buffer, delimiter: delimiter }
+        elsif ["exit", "quit", "!exit", "!quit"].include?(line.strip.downcase)
+          stop
+          { stop: true, buffer: [], delimiter: nil }
+        else
+          execute_input(line)
+          { stop: false, buffer: [], delimiter: nil }
+        end
+      end
+
+      def process_multiline_or_line(line)
+        execute_input(line)
+      end
+    end
+  end
+end

data/lib/rubik/repl/interrupt_handler.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+require "reline"
+
+module Rubik
+  module REPL
+    # Encapsulates Ctrl+C (SIGINT) handling for the interactive REPL loop.
+    #
+    # On Windows, Reline's default interrupt behavior can leave the line editor
+    # in a wedged state after a Ctrl+C: the next prompt neither echoes input nor
+    # honors EOF (Ctrl+D / Ctrl+Z), so the REPL appears frozen and cannot be
+    # exited. This module installs a SIGINT handler that raises Interrupt (so a
+    # running command -- orchestrator loop, HTTP call -- aborts promptly and
+    # Reline's own teardown restores console mode) and provides a best-effort
+    # line-editor reset to recover an unresponsive prompt.
+    module InterruptHandler
+      # Install a SIGINT handler that raises Interrupt, returning the previous
+      # handler so the caller can restore it on exit. Reline captures this trap
+      # as its @old_trap and calls it, so the Interrupt propagates out of
+      # Reline.readline cleanly.
+      def self.install
+        Signal.trap("INT") { raise Interrupt }
+      end
+
+      # Restore a previously captured SIGINT handler (value from .install).
+      def self.restore(prev_handler)
+        Signal.trap("INT", prev_handler) if prev_handler
+      end
+
+      # Run a block with the Interrupt-raising SIGINT handler installed, always
+      # restoring the previous handler and the console afterwards. Usage:
+      #   Rubik::REPL::InterruptHandler.with_handler { ... loop body ... }
+      def self.with_handler
+        prev = install
+        yield
+      ensure
+        restore(prev)
+        restore_console_after_interrupt
+      end
+
+      # Best-effort reset of Reline's line editor and console state after an interrupt.
+      # On Windows, an interrupted/aborted readline or external command execution can
+      # leave the line editor with dirty input buffers or stale console handles.
+      # Resetting the editor drops any half-entered buffer, clears IOGate input/output
+      # buffers, flushes console input, and refreshes standard handles.
+      def self.restore_console_after_interrupt
+        return unless defined?(Reline)
+
+        if Reline.respond_to?(:line_editor) && (le = Reline.line_editor)
+          begin
+            if le.respond_to?(:reset)
+              # reline's released signature varies across versions (reset(prompt='', encoding: ...) vs reset(prompt=''))
+              begin
+                enc = (Reline.respond_to?(:encoding_system) ? Reline.encoding_system : Encoding.default_external)
+                le.reset("", encoding: enc)
+              rescue ArgumentError
+                begin
+                  le.reset("")
+                rescue ArgumentError
+                  le.reset
+                end
+              end
+            elsif le.respond_to?(:reset_line)
+              le.reset_line
+            end
+          rescue StandardError
+            nil
+          end
+        end
+
+        if defined?(Reline::IOGate) && (io = Reline::IOGate)
+          # Clear internal buffers so unconsumed control characters/interrupt bytes don't bleed into next prompt
+          begin
+            if io.instance_variable_defined?(:@output_buf) && (buf = io.instance_variable_get(:@output_buf)).is_a?(Array)
+              buf.clear
+            end
+            if io.instance_variable_defined?(:@input_buf) && (buf = io.instance_variable_get(:@input_buf)).is_a?(Array)
+              buf.clear
+            end
+            io.instance_variable_set(:@hsg, nil) if io.instance_variable_defined?(:@hsg)
+          rescue StandardError
+            nil
+          end
+
+          # Refresh Windows console handles and flush console buffer if on Windows
+          begin
+            if io.is_a?(Reline::Windows) || (defined?(Reline::Windows) && io.class.name.to_s.include?("Windows"))
+              get_std_handle = io.instance_variable_get(:@GetStdHandle)
+              if get_std_handle
+                new_in = begin
+                  get_std_handle.call(Reline::Windows::STD_INPUT_HANDLE)
+                rescue
+                  nil
+                end
+                io.instance_variable_set(:@hConsoleInputHandle, new_in) if new_in && new_in != 0
+
+                new_out = begin
+                  get_std_handle.call(Reline::Windows::STD_OUTPUT_HANDLE)
+                rescue
+                  nil
+                end
+                io.instance_variable_set(:@hConsoleHandle, new_out) if new_out && new_out != 0
+
+                if new_in && new_in != 0 && defined?(Reline::Windows::Win32API)
+                  flush_func = io.instance_variable_get(:@FlushConsoleInputBuffer) ||
+                               begin
+                                 Reline::Windows::Win32API.new("kernel32", "FlushConsoleInputBuffer", ["L"], "I")
+                               rescue
+                                 nil
+                               end
+                  if flush_func
+                    io.instance_variable_set(:@FlushConsoleInputBuffer, flush_func)
+                    begin
+                      flush_func.call(new_in)
+                    rescue
+                      nil
+                    end
+                  end
+                end
+              end
+            end
+          rescue StandardError
+            nil
+          end
+        end
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end
+
+# Windows Reline Self-Healing Console Input Patch:
+# If external commands or process interruptions invalidate @hConsoleInputHandle,
+# prevent Reline::Windows#check_input_event from entering an infinite spin loop
+# by refreshing the console input handle on WAIT_FAILED (-1 / 0xFFFFFFFF).
+if defined?(Reline::Windows)
+  class Reline::Windows
+    unless method_defined?(:rubik_original_check_input_event)
+      alias rubik_original_check_input_event check_input_event
+
+      def check_input_event
+        if @hConsoleInputHandle.nil? || @hConsoleInputHandle.zero? || @hConsoleInputHandle == -1
+          @hConsoleInputHandle = begin # rubocop:disable Naming/VariableName -- Win32 FFI SDK adlandırması; yalnızca Windows konsol yolu
+            @GetStdHandle.call(STD_INPUT_HANDLE)
+          rescue
+            nil
+          end
+        end
+
+        num_of_events = 0.chr * 8
+        while @output_buf.empty?
+          Reline.core.line_editor.handle_signal
+          wait_res = @WaitForSingleObject.call(@hConsoleInputHandle, 100)
+          if wait_res != 0
+            if [0xFFFFFFFF, 4_294_967_295, -1].include?(wait_res)
+              @hConsoleInputHandle = begin # rubocop:disable Naming/VariableName -- Win32 FFI SDK adlandırması; yalnızca Windows konsol yolu
+                @GetStdHandle.call(STD_INPUT_HANDLE)
+              rescue
+                nil
+              end
+              @hConsoleHandle = begin # rubocop:disable Naming/VariableName -- Win32 FFI SDK adlandırması; yalnızca Windows konsol yolu
+                @GetStdHandle.call(STD_OUTPUT_HANDLE)
+              rescue
+                nil
+              end
+            end
+            @legacy_console = begin
+              getconsolemode.nobits?(ENABLE_VIRTUAL_TERMINAL_PROCESSING)
+            rescue
+              false
+            end
+            next
+          end
+          if @GetNumberOfConsoleInputEvents.call(@hConsoleInputHandle, num_of_events).zero? || num_of_events.unpack1("L").zero?
+            @hConsoleInputHandle = begin # rubocop:disable Naming/VariableName -- Win32 FFI SDK adlandırması; yalnızca Windows konsol yolu
+              @GetStdHandle.call(STD_INPUT_HANDLE)
+            rescue
+              nil
+            end
+            next
+          end
+          input_records = 0.chr * 20 * 80
+          read_event = 0.chr * 4
+          if @ReadConsoleInputW.call(@hConsoleInputHandle, input_records, 80, read_event).zero?
+            @hConsoleInputHandle = begin # rubocop:disable Naming/VariableName -- Win32 FFI SDK adlandırması; yalnızca Windows konsol yolu
+              @GetStdHandle.call(STD_INPUT_HANDLE)
+            rescue
+              nil
+            end
+          else
+            read_events = read_event.unpack1("L") || 0
+            read_events.times do |idx|
+              input_record = input_records[idx * 20, 20]
+              next unless input_record && input_record.bytesize >= 20
+
+              event = input_record[0, 2].unpack1("s*")
+              case event
+              when WINDOW_BUFFER_SIZE_EVENT
+                @winch_handler&.call
+              when KEY_EVENT
+                key_down = input_record[4, 4].unpack1("l*")
+                repeat_count = input_record[8, 2].unpack1("s*")
+                virtual_key_code = input_record[10, 2].unpack1("s*")
+                virtual_scan_code = input_record[12, 2].unpack1("s*")
+                char_code = input_record[14, 2].unpack1("S*")
+                control_key_state = input_record[16, 2].unpack1("S*")
+                is_key_down = !key_down.zero?
+                process_key_event(repeat_count, virtual_key_code, virtual_scan_code, char_code, control_key_state) if is_key_down
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end