muxr 0.1.5 → 0.1.7

data/lib/muxr/input_handler.rb

@@ -1,17 +1,66 @@
 module Muxr
-  # Translates raw keystrokes into either commands (when the Ctrl-a prefix is
-  # active) or passthrough bytes to the focused pane. The handler is a small
-  # state machine: :idle → :prefix → :idle, with a separate :command branch
-  # for the ":"-driven mini-command line.
+  # Translates raw keystrokes into either commands or pane input. Two top-level
+  # modes:
+  #
+  #   :normal       Default. Single-key bindings (hjkl navigation, t/g/m for
+  #                 layouts, c/K for create/kill, etc.) act directly without
+  #                 any prefix. `i` drops into passthrough.
+  #
+  #   :passthrough  Historical mode: every key is forwarded to the focused
+  #                 pane unless prefixed by Ctrl-a. `Ctrl-a Esc` returns to
+  #                 normal mode.
+  #
+  # Plus the sub-states pre-existing from before modes existed:
+  #   :prefix, :command, :confirm_quit, :confirm_close, :help, :scrollback,
+  #   :search, :selection.
+  #
+  # One-shot sub-states (prefix, command, confirm_quit, help) return to
+  # @base_mode (whichever of :normal/:passthrough is active) when they
+  # finish. :scrollback and :selection also return to @base_mode so that
+  # exiting back from a scroll/yank lands you back in passthrough if that's
+  # where you came from.
   class InputHandler
     PREFIX = "\x01".freeze # Ctrl-a
 
+    # Single-key bindings in normal mode. Same actions as their Ctrl-a-
+    # prefixed counterparts in passthrough, just without the prefix.
+    # Value forms:
+    #   :symbol            → @app.public_send(:symbol)
+    #   [:symbol, *args]   → @app.public_send(:symbol, *args)
+    NORMAL_BINDINGS = {
+      "c"  => :new_pane,
+      "x"  => :request_close,
+      "t"  => [:set_layout, :tall],
+      "g"  => [:set_layout, :grid],
+      "m"  => [:set_layout, :monocle],
+      "\t" => :cycle_layout,
+      "\r" => :promote_master,
+      "\n" => :promote_master,
+      "h"  => [:focus_direction, :left],
+      "j"  => [:focus_direction, :down],
+      "k"  => [:focus_direction, :up],
+      "l"  => [:focus_direction, :right],
+      "H"  => [:move_direction, :left],
+      "J"  => [:move_direction, :down],
+      "K"  => [:move_direction, :up],
+      "L"  => [:move_direction, :right],
+      "a"  => :focus_last,
+      "~"  => :toggle_drawer,
+      "C"  => :toggle_claude_drawer,
+      "P"  => :toggle_private_focused,
+      "d"  => :detach,
+      "?"  => :show_help,
+      "q"  => :quit_immediate,
+      "s"  => :enter_scrollback,
+      "]"  => :paste_from_buffer
+    }.freeze
+
     PREFIX_BINDINGS = {
       "c"    => :new_pane,
       "n"    => :focus_next,
       "p"    => :focus_prev,
       "a"    => :focus_last,
-      "k"    => :close_focused,
+      "x"    => :request_close,
       "\t"   => :cycle_layout,
       "\r"   => :promote_master,
       "\n"   => :promote_master,
@@ -41,6 +90,20 @@ module Muxr
       "G"    => :bottom
     }.freeze
 
+    # CSI sequences (arrow / page keys) recognized in scrollback mode. Built
+    # for terminal raw-mode emission: arrow keys come through as ESC `[`
+    # followed by a single final letter, PageUp/PageDown as ESC `[5~` /
+    # `[6~`. Lookahead in #feed peels these off as one chunk so a bare ESC
+    # still exits scrollback the way it always has.
+    SCROLLBACK_CSI = {
+      "\e[A"  => :line_back,    # Up
+      "\e[B"  => :line_forward, # Down
+      "\e[5~" => :half_back,    # PageUp
+      "\e[6~" => :half_forward, # PageDown
+      "\e[H"  => :top,          # Home
+      "\e[F"  => :bottom        # End
+    }.freeze
+
     SCROLLBACK_EXITS = ["q", "\e", "\x03"].freeze # q, Esc, Ctrl-c
 
     SELECTION_BINDINGS = {
@@ -69,8 +132,10 @@ module Muxr
       "u"    => :half_up,
       "\x06" => :full_down, # Ctrl-f
       "\x02" => :full_up,   # Ctrl-b
-      "f"    => :full_down,
-      " "    => :full_down
+      "f"    => :full_down
+      # NOTE: space is intentionally absent here — it's a top-level toggle
+      # for linear selection (see handle_selection_input), mirroring vim's
+      # `v` so the right thumb has a one-key way to anchor/release.
     }.freeze
 
     SELECTION_YANK = ["\r", "\n", "y"].freeze
@@ -78,22 +143,24 @@ module Muxr
 
     DIGIT_RE = /\A[1-9]\z/.freeze
 
-    attr_reader :state, :command_buffer
+    attr_reader :state, :command_buffer, :search_buffer, :search_direction, :base_mode
 
     def initialize(app)
       @app = app
-      @state = :idle
+      @state = :normal
+      @base_mode = :normal
       @command_buffer = +""
+      @search_buffer = +""
+      @search_direction = :forward
     end
 
     def feed(data)
       remaining = data
       until remaining.empty?
-        if @state == :idle
-          # Fast path for pass-through: forward everything up to the next
-          # Ctrl-a as a single chunk so a large paste doesn't turn into one
-          # PTY write per byte. PREFIX is single-byte ASCII (\x01) and never
-          # appears mid-UTF-8, so byte/char index match.
+        if @state == :passthrough
+          # Fast path: batch everything up to the next Ctrl-a as one chunk so
+          # a large paste doesn't turn into one PTY write per byte. PREFIX is
+          # single-byte ASCII (\x01) and never appears mid-UTF-8.
           idx = remaining.index(PREFIX)
           if idx.nil?
             @app.send_to_focused(remaining)
@@ -105,20 +172,41 @@ module Muxr
           next
         end
 
+        # Multi-byte CSI lookahead for scrollback / search: arrow / page
+        # keys arrive as `\e[<final>` and would otherwise trip the
+        # bare-Esc-exits behavior. In :scrollback we map them to scroll
+        # actions; in :search we silently consume them so a stray arrow
+        # doesn't kick the user out of the prompt. An incomplete `\e[…`
+        # (rare in raw-mode TTY) falls through and the bare `\e` exits as
+        # before.
+        if (@state == :scrollback || @state == :search) && remaining.start_with?("\e[")
+          consumed = consume_csi_escape(remaining)
+          if consumed > 0
+            remaining = remaining[consumed..] || ""
+            next
+          end
+        end
+
         ch = remaining[0]
         remaining = remaining[1..] || ""
         case @state
+        when :normal
+          handle_normal(ch)
         when :help
           @app.dismiss_help
-          @state = :idle
+          @state = @base_mode
         when :confirm_quit
           handle_confirm_quit(ch)
+        when :confirm_close
+          handle_confirm_close(ch)
         when :prefix
           handle_prefix(ch)
         when :command
           handle_command_input(ch)
         when :scrollback
           handle_scrollback_input(ch)
+        when :search
+          handle_search_input(ch)
         when :selection
           handle_selection_input(ch)
         end
@@ -133,48 +221,114 @@ module Muxr
       @state = :confirm_quit
     end
 
+    def enter_confirm_close
+      @state = :confirm_close
+    end
+
     def enter_scrollback_mode
       @state = :scrollback
     end
 
+    def enter_search_mode(direction: :forward)
+      @state = :search
+      @search_direction = direction
+      @search_buffer = +""
+    end
+
     def enter_selection_mode
       @state = :selection
     end
 
+    # Drop into passthrough — every key reaches the focused pane until the
+    # user issues Ctrl-a Esc.
+    def enter_passthrough_mode
+      @state = :passthrough
+      @base_mode = :passthrough
+    end
+
+    # Return to normal mode. Used by the `Ctrl-a Esc` binding from
+    # passthrough — explicitly resets @base_mode so the user genuinely
+    # leaves passthrough.
+    def enter_normal_mode
+      @state = :normal
+      @base_mode = :normal
+    end
+
+    # Exit a sub-state (scrollback, selection-yank) and resume the mode the
+    # user was in before they entered scrollback. Preserves @base_mode so
+    # a passthrough → scrollback → exit round-trip lands back in passthrough.
     def enter_idle_mode
-      @state = :idle
+      @state = @base_mode
     end
 
     def cancel
-      @state = :idle
+      @state = @base_mode
       @command_buffer = +""
     end
 
     private
 
+    def handle_normal(ch)
+      if ch == "i"
+        # Internal state flip happens here so a bare FakeApp in tests still
+        # transitions; the Application callback redundantly flips state
+        # (idempotent) and adds the user-visible flash.
+        enter_passthrough_mode
+        @app.enter_passthrough_mode
+        return
+      end
+      if ch == ":"
+        @state = :command
+        @command_buffer = +""
+        return
+      end
+      if DIGIT_RE.match?(ch)
+        @app.focus_pane_number(ch.to_i)
+        return
+      end
+
+      action = NORMAL_BINDINGS[ch]
+      case action
+      when Symbol
+        @app.public_send(action)
+      when Array
+        @app.public_send(*action)
+      end
+      # Unknown key: ignore. Avoids accidental side-effects when the user
+      # mistypes — same rationale as scrollback mode.
+    end
+
     def handle_prefix(ch)
       action = PREFIX_BINDINGS[ch]
       case
+      when ch == "\e"
+        # Ctrl-a Esc → return to normal mode. Flip state directly so tests
+        # with a bare FakeApp transition; the Application callback is
+        # idempotent and adds the flash message.
+        enter_normal_mode
+        @app.enter_normal_mode
       when ch == ":"
         @state = :command
         @command_buffer = +""
       when ch == PREFIX
         @app.send_to_focused(PREFIX)
-        @state = :idle
+        @state = @base_mode
       when DIGIT_RE.match?(ch)
         @app.focus_pane_number(ch.to_i)
-        @state = :idle
+        @state = @base_mode
       when action
         @app.public_send(action)
-        @state = :idle if @state == :prefix
+        # The action may have set a new state (confirm_quit, confirm_close,
+        # scrollback, help). Only revert to base mode if we're still in :prefix.
+        @state = @base_mode if @state == :prefix
       else
-        # Unknown prefix-key: return to idle silently.
-        @state = :idle
+        # Unknown prefix key: return to base mode silently.
+        @state = @base_mode
       end
     end
 
     def handle_confirm_quit(ch)
-      @state = :idle
+      @state = @base_mode
       if ch == "y" || ch == "Y"
         @app.confirm_quit
       else
@@ -182,9 +336,18 @@ module Muxr
       end
     end
 
+    def handle_confirm_close(ch)
+      @state = @base_mode
+      if ch == "y" || ch == "Y"
+        @app.confirm_close
+      else
+        @app.cancel_close
+      end
+    end
+
     def handle_scrollback_input(ch)
       if SCROLLBACK_EXITS.include?(ch)
-        @state = :idle
+        enter_idle_mode
         @app.exit_scrollback
         return
       end
@@ -192,12 +355,78 @@ module Muxr
         @app.enter_selection
         return
       end
+      case ch
+      when "/"
+        # Flip state directly so tests with a bare FakeApp transition; the
+        # Application callback redundantly flips state and runs side-effects.
+        enter_search_mode(direction: :forward)
+        @app.enter_search(direction: :forward)
+        return
+      when "?"
+        enter_search_mode(direction: :backward)
+        @app.enter_search(direction: :backward)
+        return
+      when "n"
+        @app.find_next
+        return
+      when "N"
+        @app.find_prev
+        return
+      end
       action = SCROLLBACK_BINDINGS[ch]
       @app.scroll_focused(action) if action
       # Unknown keys: ignored. Avoids accidental shell input when the user
       # mistypes inside scrollback mode.
     end
 
+    def handle_search_input(ch)
+      case ch
+      when "\r", "\n"
+        query = @search_buffer.dup
+        @search_buffer = +""
+        @state = :scrollback
+        @app.commit_search(query)
+      when "\e", "\x03"
+        @search_buffer = +""
+        @state = :scrollback
+        @app.cancel_search
+      when "\x7f", "\b"
+        @search_buffer.chop!
+        @app.invalidate
+      else
+        # Printable ASCII / UTF-8. We treat anything at or above 0x20 as
+        # input; control bytes besides the ones handled above are dropped
+        # to keep stray Ctrl-keys from corrupting the query.
+        @search_buffer << ch if ch.ord >= 0x20
+        @app.invalidate
+      end
+    end
+
+    # Find the final byte of a CSI escape sequence and return the number
+    # of bytes consumed. In :scrollback we map recognized sequences to
+    # scroll actions; in :search we just swallow them so a stray arrow
+    # key doesn't kick the user out of the prompt. Returns 0 only when
+    # the sequence is incomplete in this chunk — the caller falls through
+    # so a bare \e still exits.
+    def consume_csi_escape(remaining)
+      i = 2
+      max = [remaining.bytesize, 16].min
+      while i < max
+        b = remaining.getbyte(i)
+        if b >= 0x40 && b <= 0x7e
+          seq = remaining.byteslice(0, i + 1)
+          if @state == :scrollback
+            action = SCROLLBACK_CSI[seq]
+            @app.scroll_focused(action) if action
+          end
+          return i + 1
+        end
+        return 0 if b < 0x20 || b > 0x7e # malformed; fall through
+        i += 1
+      end
+      0
+    end
+
     def handle_selection_input(ch)
       if SELECTION_YANK.include?(ch)
         @app.exit_selection(yank: true)
@@ -208,7 +437,7 @@ module Muxr
         return
       end
       case ch
-      when "v"
+      when "v", " "
         @app.toggle_selection(:linear)
         return
       when "\x16" # Ctrl-v
@@ -225,11 +454,11 @@ module Muxr
       when "\r", "\n"
         cmd = @command_buffer.dup
         @command_buffer = +""
-        @state = :idle
+        @state = @base_mode
         @app.run_command(cmd)
       when "\e"
         @command_buffer = +""
-        @state = :idle
+        @state = @base_mode
         @app.invalidate
       when "\x7f", "\b"
         @command_buffer.chop!

data/lib/muxr/layout_manager.rb

@@ -87,5 +87,64 @@ module Muxr
     def monocle(count, area, _focused_index = 0)
       Array.new(count) { Rect.new(area.x, area.y, area.w, area.h) }
     end
+
+    # Return the index of the closest pane in `direction` (:left/:right/:up/:down)
+    # from the focused pane. Pure function over the rect list — does not know
+    # about the layout that produced the rects.
+    #
+    # Selection rule: among panes strictly on the requested side, prefer the
+    # one with the largest perpendicular overlap with the focused pane;
+    # tie-break by smallest axis-distance, then by smallest center offset.
+    # Returns nil when nothing qualifies (e.g. focused is the rightmost pane
+    # and direction is :right, or monocle where every rect is identical).
+    def neighbor(rects, focused_index, direction)
+      return nil if rects.nil? || rects.empty?
+      return nil unless focused_index.is_a?(Integer)
+      return nil unless focused_index.between?(0, rects.length - 1)
+      focused = rects[focused_index]
+      return nil unless focused
+
+      best = nil
+      rects.each_with_index do |rect, idx|
+        next if idx == focused_index || rect.nil?
+
+        case direction
+        when :right
+          next unless rect.x >= focused.x + focused.w
+          axis_dist = rect.x - (focused.x + focused.w)
+          overlap   = overlap_extent(focused.y, focused.h, rect.y, rect.h)
+          center    = ((rect.y + rect.h / 2.0) - (focused.y + focused.h / 2.0)).abs
+        when :left
+          next unless rect.x + rect.w <= focused.x
+          axis_dist = focused.x - (rect.x + rect.w)
+          overlap   = overlap_extent(focused.y, focused.h, rect.y, rect.h)
+          center    = ((rect.y + rect.h / 2.0) - (focused.y + focused.h / 2.0)).abs
+        when :down
+          next unless rect.y >= focused.y + focused.h
+          axis_dist = rect.y - (focused.y + focused.h)
+          overlap   = overlap_extent(focused.x, focused.w, rect.x, rect.w)
+          center    = ((rect.x + rect.w / 2.0) - (focused.x + focused.w / 2.0)).abs
+        when :up
+          next unless rect.y + rect.h <= focused.y
+          axis_dist = focused.y - (rect.y + rect.h)
+          overlap   = overlap_extent(focused.x, focused.w, rect.x, rect.w)
+          center    = ((rect.x + rect.w / 2.0) - (focused.x + focused.w / 2.0)).abs
+        else
+          return nil
+        end
+
+        score = [-overlap, axis_dist, center]
+        if best.nil? || (score <=> best[0]) < 0
+          best = [score, idx]
+        end
+      end
+      best && best[1]
+    end
+
+    def overlap_extent(a_start, a_size, b_start, b_size)
+      finish = [a_start + a_size, b_start + b_size].min
+      start  = [a_start, b_start].max
+      [finish - start, 0].max
+    end
   end
 end

data/lib/muxr/pane.rb

@@ -14,6 +14,11 @@ module Muxr
   class Pane
     attr_reader :id, :terminal, :process
     attr_accessor :rect
+    # Last value written by Application's foreground poller thread. nil when
+    # the shell itself is foreground (the common empty-prompt case) or when
+    # the lookup hasn't run / couldn't read. Renderer surfaces this in the
+    # pane title.
+    attr_accessor :foreground_command
 
     def initialize(id: nil, rows: 24, cols: 80, cwd: nil, command: nil, env_overrides: nil, process: nil)
       @id = id || SecureRandom.hex(3)
@@ -30,6 +35,11 @@ module Muxr
       @rect = nil
       @initial_cwd = cwd || @process.cwd
       @private_flag = false
+      @foreground_command = nil
+    end
+
+    def pid
+      @process.pid
     end
 
     # Private panes are invisible to the MCP control surface — their cwd is