muxr 0.1.6 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8ef82a33d0eab76d850265772196a2d405e7e03b1161496973f4e88369b0e628
-  data.tar.gz: 86a621eaef858c02317431a57ac109dea309c3f2f450f0f28b2d30bd71f4d145
+  metadata.gz: 03650b7088c85aa8fbe993dbfe17e7f8aac8334f617c3ff148589964d83bb701
+  data.tar.gz: 9b878beb1c05f1c83273f3f1c8e51944be7c75b3fdcd13935c96f851a2aa8405
 SHA512:
-  metadata.gz: '0958e09357a6a80965128c0b90e7348a86d8b1bddb63b6891718a34a01703a3bb8d8b8281b9e8c0e2094b8824c3cc64c2b255bbeab0919531848ee46e39e1180'
-  data.tar.gz: ab9d8f51cfa56e0e550bd9b608cebaa6a85fcd80871f1018917ef498efbca89f0c8a1a0885bdafafcf2fc1e6a2922b13c977e2a13f98561acd41e21b38c74c11
+  metadata.gz: 91ccd01254428f3a2333e3abe94cd3d039598813c484730a4819c938f9f0d733ab611bd9c975314ca5bfb0af07c243c69814ed918fc02315e7652436454170b8
+  data.tar.gz: c58966f41d4a62978e3bfd7560d72ef132b6fcbdededddf129cf94216d77689b1f1f52c44cf7660cab9780a7ec8f3180fe138a9f2f75f8ec741548595c415665

data/CHANGELOG.md

@@ -6,6 +6,30 @@ follow [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [0.1.7] - 2026-05-20
+
+### Added
+- Scrollback search via `/` (forward) and `?` (backward). Enter commits
+  the query, `n` / `N` cycle through matches with wrap. Smart-case
+  matching scans both scrollback and the live buffer; the chosen match
+  is centered in the viewport and every match is highlighted in yellow
+  until the user exits scrollback.
+- Arrow / page keys in scrollback. `↑`/`↓` scroll a line, `PgUp`/`PgDn`
+  half-page, `Home`/`End` jump to top/bottom. `InputHandler#feed` now
+  peeks for CSI escape sequences so a bare `Esc` still exits scrollback
+  the way it always has.
+- Shift-`H`/`J`/`K`/`L` swaps the focused pane with the spatial
+  neighbor in that direction (linear next/prev fallback in monocle).
+  Focus tracks the moved pane so you can keep dragging it; swapping
+  into position 0 of tall/grid promotes it to master.
+
+### Changed
+- Pane close is now confirmed. The close binding moved from `K` to
+  `x` (in both normal mode and the Ctrl-a prefix) so shift-`HJKL` is
+  free for the new move action. Close routes through a `:confirm_close`
+  state that flashes `close pane? (y/n)` — drawer hide stays
+  prompt-free since it's reversible.
+
 ## [0.1.6] - 2026-05-15
 
 ### Added

data/README.md

@@ -88,8 +88,9 @@ bin/muxr                 # same flags as the installed `muxr` executable
 muxr has two top-level input modes, modeled on vim:
 
 - **Normal** (default at startup) — single keys act on the multiplexer.
-  `hjkl` moves focus between panes, `c`/`K` create/kill panes,
-  `t`/`g`/`m` set the layout, etc. No prefix needed.
+  `hjkl` moves focus between panes, `HJKL` moves the focused pane
+  itself, `c`/`x` create/close panes, `t`/`g`/`m` set the layout, etc.
+  No prefix needed.
 - **Passthrough** (entered with `i`) — every keystroke is forwarded to
   the focused pane, exactly like a regular terminal. muxr commands are
   reached via the historical `Ctrl-a` prefix. `Ctrl-a Esc` returns to
@@ -98,18 +99,20 @@ muxr has two top-level input modes, modeled on vim:
 The active mode appears as a `[MODE]` chip in the top-right corner of
 the focused pane (and the leftmost slot of the status bar). The
 focused pane's border is colored by mode — cyan for normal, green for
-passthrough, orange for scrollback, magenta for selection, yellow for
-the command prompt, red during the kill-session confirmation, blue
-while help is open. Unfocused panes always render with the grey
-unfocused border, regardless of mode.
+passthrough, orange for scrollback (and its `/` search prompt),
+magenta for selection, yellow for the command prompt, red during the
+kill-session or close-pane confirmation, blue while help is open.
+Unfocused panes always render with the grey unfocused border,
+regardless of mode.
 
 ### Normal mode
 
 | Keys                 | Action                                              |
 |----------------------|-----------------------------------------------------|
 | `h` / `j` / `k` / `l`| focus pane left / down / up / right (spatial)       |
+| `H` / `J` / `K` / `L`| move focused pane left / down / up / right          |
 | `i`                  | drop into passthrough mode                          |
-| `c` / `K`            | new / close focused pane                            |
+| `c` / `x`            | new / close focused pane (close asks `y/n`)         |
 | `t` / `g` / `m`      | layout: tall / grid / monocle                       |
 | `Tab` / `Enter`      | cycle layout / promote focused to master            |
 | `a` / `1` … `9`      | toggle last pane / jump to pane by number           |
@@ -125,6 +128,12 @@ direction. In monocle (where every pane occupies the full area) it
 falls back to linear next/previous so the keys still do something
 useful.
 
+`H`/`J`/`K`/`L` swap the focused pane with the spatial neighbor in
+that direction, then keep focus on the moved pane so you can keep
+dragging it. Swapping into position 0 of `tall`/`grid` promotes the
+pane to master (the layout master is always `panes[0]`). In monocle
+the move falls back to linear next/prev shuffling.
+
 ### Passthrough mode (`Ctrl-a` prefix)
 
 | Keys           | Action                                                  |
@@ -134,7 +143,7 @@ useful.
 | `C-a n` / `p`  | focus next / previous pane (linear)                     |
 | `C-a a`        | toggle last (previously focused) pane                   |
 | `C-a 1` … `9`  | jump to pane by its label                               |
-| `C-a K`        | close focused pane (or hide drawer)                     |
+| `C-a x`        | close focused pane (asks `y/n`; hides drawer with no prompt) |
 | `C-a Tab`      | cycle layout (`tall` → `grid` → `monocle`)              |
 | `C-a Enter`    | promote focused pane to master                          |
 | `C-a ~`        | toggle drawer (shell)                                   |
@@ -157,12 +166,19 @@ navigation; the status bar shows a key hint and the pane title gains
 
 | Keys                    | Action                              |
 |-------------------------|-------------------------------------|
-| `j` / `k`               | scroll one line                     |
-| `d` / `u` (or `C-d`/`C-u`) | half page                        |
+| `j` / `k` or `↓` / `↑`  | scroll one line                     |
+| `d` / `u` (or `C-d`/`C-u`, `PgDn`/`PgUp`) | half page             |
 | `f` / Space (or `C-f`/`C-b`) | full page                      |
-| `g` / `G`               | top / bottom                        |
+| `g` / `G` (or `Home` / `End`) | top / bottom                  |
+| `/` *query* `Enter`     | search forward (toward newer); `?` searches backward |
+| `n` / `N`               | next / previous match in the search direction (wraps) |
 | `q` / `Esc` / `C-c`     | exit back to normal mode            |
 
+Search uses smart-case (case-insensitive unless the query has an
+uppercase letter), scans both scrollback and the live buffer, and
+centers the chosen match in the viewport. Matches stay highlighted in
+yellow while you're in scrollback; exiting clears the highlight.
+
 Press `v` inside scrollback to enter a movable-cursor selection mode.
 Vim-style motions are supported:
 

data/lib/muxr/application.rb

@@ -177,6 +177,37 @@ module Muxr
       invalidate
     end
 
+    # Swap the focused pane with its spatial neighbor in `direction`. Bound
+    # to shift-HJKL in normal mode. Mirrors focus_direction's geometry-aware
+    # lookup so the same "what does my arrow point at" intuition decides
+    # which neighbor gets bumped. Monocle has no spatial layout, so HJKL
+    # falls back to reordering by linear next/prev — useful for shuffling
+    # the master before flipping back to tall/grid.
+    def move_direction(direction)
+      return if @session.window.panes.empty?
+      # The drawer isn't part of the tiled pane list; HJKL while focused on
+      # it would be ambiguous. No-op.
+      return if @session.focus_drawer && @session.drawer&.visible?
+
+      win = @session.window
+      idx = LayoutManager.neighbor(current_pane_rects, win.focused_index, direction)
+      if idx.nil? && win.layout == :monocle
+        target = case direction
+                 when :right, :down then (win.focused_index + 1) % win.panes.length
+                 when :left, :up    then (win.focused_index - 1) % win.panes.length
+                 end
+        if target && target != win.focused_index
+          win.move_focused_to(target)
+          invalidate
+        end
+        return
+      end
+
+      return unless idx
+      win.move_focused_to(idx)
+      invalidate
+    end
+
     # Explicit layout set, used by the normal-mode t/g/m bindings and the
     # `:layout <name>` command.
     def set_layout(layout)
@@ -202,6 +233,31 @@ module Muxr
       invalidate
     end
 
+    # Two-step close — same shape as the quit flow. Hiding the drawer is
+    # cheap and reversible, so we skip the prompt for the drawer case.
+    def request_close
+      if @session.focus_drawer && @session.drawer&.visible?
+        hide_drawer
+        return
+      end
+      return unless focused_pane
+      return if @input.state == :confirm_close
+      @input.enter_confirm_close
+      flash("close pane? (y/n)")
+      invalidate
+    end
+
+    def confirm_close
+      close_focused
+    end
+
+    def cancel_close
+      @message = nil
+      @message_expires = nil
+      flash("cancelled")
+      invalidate
+    end
+
     def close_focused
       if @session.focus_drawer && @session.drawer&.visible?
         hide_drawer
@@ -337,11 +393,63 @@ module Muxr
     def exit_scrollback
       target = focused_target
       target&.terminal&.clear_selection
+      target&.terminal&.clear_search
       target&.terminal&.scroll_to_bottom
       @renderer.reset_frame!
       invalidate
     end
 
+    # Bound to `/` (forward) and `?` (backward) in scrollback mode. Drops
+    # the user into a buffered prompt; commit_search / cancel_search exit
+    # back to scrollback.
+    def enter_search(direction: :forward)
+      @input.enter_search_mode(direction: direction)
+      invalidate
+    end
+
+    def commit_search(query)
+      target = focused_target
+      return unless target
+      term = target.terminal
+      direction = @input.search_direction
+      count = term.search(query, direction: direction)
+      if query.empty?
+        # Empty query just dismisses the prompt; leave the prior search
+        # state alone (term.search already cleared it though).
+      elsif count.zero?
+        flash("not found: #{query}")
+      else
+        flash("#{count} match#{count == 1 ? "" : "es"} (n/N to navigate)")
+      end
+      @renderer.reset_frame!
+      invalidate
+    end
+
+    def cancel_search
+      @renderer.reset_frame!
+      invalidate
+    end
+
+    def find_next
+      step_search(@input.search_direction)
+    end
+
+    def find_prev
+      step_search(@input.search_direction == :forward ? :backward : :forward)
+    end
+
+    def step_search(direction)
+      target = focused_target
+      return unless target
+      term = target.terminal
+      if term.search_matches.empty?
+        flash("no search active")
+        return
+      end
+      term.find_in_direction(direction)
+      invalidate
+    end
+
     def scroll_focused(action)
       target = focused_target
       return unless target
@@ -834,6 +942,8 @@ module Muxr
         @session,
         input_state: @input.state,
         command_buffer: @input.command_buffer,
+        search_buffer: @input.search_buffer,
+        search_direction: @input.search_direction,
         message: @message,
         help: @help_visible
       )

data/lib/muxr/command_dispatcher.rb

@@ -26,7 +26,7 @@ module Muxr
       when "new", "c"
         @app.new_pane
       when "close", "kill", "k"
-        @app.close_focused
+        @app.request_close
       when "next"    then @app.focus_next
       when "prev"    then @app.focus_prev
       when "master"  then @app.promote_master

data/lib/muxr/input_handler.rb

@@ -11,7 +11,8 @@ module Muxr
   #                 normal mode.
   #
   # Plus the sub-states pre-existing from before modes existed:
-  #   :prefix, :command, :confirm_quit, :help, :scrollback, :selection.
+  #   :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
@@ -28,7 +29,7 @@ module Muxr
     #   [:symbol, *args]   → @app.public_send(:symbol, *args)
     NORMAL_BINDINGS = {
       "c"  => :new_pane,
-      "K"  => :close_focused,
+      "x"  => :request_close,
       "t"  => [:set_layout, :tall],
       "g"  => [:set_layout, :grid],
       "m"  => [:set_layout, :monocle],
@@ -39,6 +40,10 @@ module Muxr
       "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,
@@ -55,7 +60,7 @@ module Muxr
       "n"    => :focus_next,
       "p"    => :focus_prev,
       "a"    => :focus_last,
-      "K"    => :close_focused,
+      "x"    => :request_close,
       "\t"   => :cycle_layout,
       "\r"   => :promote_master,
       "\n"   => :promote_master,
@@ -85,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 = {
@@ -124,13 +143,15 @@ module Muxr
 
     DIGIT_RE = /\A[1-9]\z/.freeze
 
-    attr_reader :state, :command_buffer, :base_mode
+    attr_reader :state, :command_buffer, :search_buffer, :search_direction, :base_mode
 
     def initialize(app)
       @app = app
       @state = :normal
       @base_mode = :normal
       @command_buffer = +""
+      @search_buffer = +""
+      @search_direction = :forward
     end
 
     def feed(data)
@@ -151,6 +172,21 @@ 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
@@ -161,12 +197,16 @@ module Muxr
           @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
@@ -181,10 +221,20 @@ 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
@@ -268,8 +318,8 @@ module Muxr
         @state = @base_mode
       when action
         @app.public_send(action)
-        # The action may have set a new state (confirm_quit, scrollback,
-        # help). Only revert to base mode if we're still in :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 base mode silently.
@@ -286,6 +336,15 @@ 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)
         enter_idle_mode
@@ -296,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)

data/lib/muxr/renderer.rb

@@ -23,11 +23,19 @@ module Muxr
       prefix:       [:c256, 42].freeze,   # green (passthrough sub-state)
       command:      [:c256, 226].freeze,  # yellow
       scrollback:   [:c256, 214].freeze,  # orange
+      search:       [:c256, 214].freeze,  # orange (scrollback sub-state)
       selection:    [:c256, 201].freeze,  # magenta
-      confirm_quit: [:c256, 196].freeze,  # red
-      help:         [:c256, 39].freeze    # blue
+      confirm_quit:  [:c256, 196].freeze, # red
+      confirm_close: [:c256, 196].freeze, # red
+      help:          [:c256, 39].freeze   # blue
     }.freeze
 
+    # Background applied to cells that match the active scrollback search.
+    # Bright enough to stand out over typical foreground SGRs while leaving
+    # the original glyph readable.
+    SEARCH_MATCH_BG = [:c256, 226].freeze # yellow
+    SEARCH_MATCH_FG = [:c256, 16].freeze  # black
+
     HORIZONTAL = "─".freeze
     VERTICAL   = "│".freeze
     TL         = "┌".freeze
@@ -66,7 +74,7 @@ module Muxr
       @prev = nil
     end
 
-    def render(session, input_state: :normal, command_buffer: "", message: nil, help: false)
+    def render(session, input_state: :normal, command_buffer: "", search_buffer: "", search_direction: :forward, message: nil, help: false)
       w = session.width
       h = session.height
       return if w < 4 || h < 3
@@ -75,10 +83,17 @@ module Muxr
 
       compose_panes(frame, session, input_state: input_state)
       compose_drawer(frame, session, input_state: input_state) if session.drawer&.visible?
-      compose_status_bar(frame, session, input_state: input_state, command_buffer: command_buffer, message: message)
+      compose_status_bar(
+        frame, session,
+        input_state: input_state,
+        command_buffer: command_buffer,
+        search_buffer: search_buffer,
+        search_direction: search_direction,
+        message: message
+      )
       compose_help(frame, session) if help
 
-      emit_frame(frame, session, input_state: input_state, command_buffer: command_buffer)
+      emit_frame(frame, session, input_state: input_state, command_buffer: command_buffer, search_buffer: search_buffer)
     end
 
     private
@@ -216,14 +231,16 @@ module Muxr
       when :prefix       then "^A"
       when :command      then "CMD"
       when :scrollback   then "SCROLL"
+      when :search       then "SEARCH"
       when :selection    then "SEL"
-      when :confirm_quit then "QUIT?"
-      when :help         then "HELP"
+      when :confirm_quit  then "QUIT?"
+      when :confirm_close then "CLOSE?"
+      when :help          then "HELP"
       else                    "?"
       end
     end
 
-    def compose_status_bar(frame, session, input_state:, command_buffer:, message:)
+    def compose_status_bar(frame, session, input_state:, command_buffer:, search_buffer: "", search_direction: :forward, message: nil)
       y = session.height - 1
       w = session.width
       win = session.window
@@ -294,7 +311,25 @@ module Muxr
           c.attrs = 0
         end
       elsif input_state == :scrollback
-        overlay = " SCROLLBACK  j/k line  d/u half  f/b page  g/G top/bot  v select  q quit "
+        overlay = " SCROLLBACK  ↑↓/j/k line  d/u half  f/b page  g/G top/bot  / search  n/N next/prev  v select  q quit "
+        overlay = overlay[0, w]
+        overlay.each_char.with_index do |ch, x|
+          c = frame[y][x]
+          c.char = ch
+          c.fg = [:c256, 232]
+          c.bg = [:c256, 214]
+          c.attrs = Terminal::BOLD
+        end
+        (overlay.length...w).each do |x|
+          c = frame[y][x]
+          c.char = " "
+          c.fg = nil
+          c.bg = [:c256, 214]
+          c.attrs = 0
+        end
+      elsif input_state == :search
+        prefix = search_direction == :backward ? "?" : "/"
+        overlay = "#{prefix}#{search_buffer}"
         overlay = overlay[0, w]
         overlay.each_char.with_index do |ch, x|
           c = frame[y][x]
@@ -353,8 +388,9 @@ module Muxr
       "",
       "NORMAL mode (default; no prefix)",
       "  h / j / k / l   focus pane left / down / up / right",
+      "  H / J / K / L   move pane left / down / up / right",
       "  i               drop into passthrough mode",
-      "  c / K           new / close pane",
+      "  c / x           new / close pane (close asks y/n)",
       "  t / g / m       layout: tall / grid / monocle",
       "  Tab / Enter     cycle layout / promote to master",
       "  a / 1..9        last pane / jump by number",
@@ -365,14 +401,15 @@ module Muxr
       "",
       "PASSTHROUGH mode (keys reach the focused pane; prefix is Ctrl-a)",
       "  C-a Esc         return to normal mode",
-      "  C-a c K t g m   same as normal-mode bindings",
+      "  C-a c x t g m   same as normal-mode bindings",
       "  C-a Tab Enter   cycle layout / promote master",
       "  C-a n / p / a   next / prev / last pane",
       "  C-a [ ]         scrollback / paste buffer",
       "  C-a C-a         send literal Ctrl-a to focused pane",
       "",
       "SCROLLBACK mode (exits to the mode you came from)",
-      "  j/k d/u f/b g/G  scroll  C-b/C-f page  v→cursor",
+      "  j/k ↑/↓ d/u f/b g/G  scroll  C-b/C-f page  v→cursor",
+      "  / search-fwd  ? search-back  n/N next/prev match",
       "  cursor: h/j/k/l 0/^/$ w/e/b W/E/B H/M/L g/G",
       "          v select, C-v block, y/Enter yank, q/Esc cancel",
       "",
@@ -445,6 +482,7 @@ module Muxr
       rows = term.rows
       cols = term.cols
       selection = term.selection_active?
+      search = term.search_active?
       rows.times do |r|
         fy = dst_y + r
         next if fy < 0 || fy >= frame.length
@@ -457,6 +495,13 @@ module Muxr
           dst.fg = src.fg
           dst.bg = src.bg
           dst.attrs = src.attrs
+          if search && term.cell_in_match?(r, c)
+            # Highlight wins over the cell's own bg so matches stay visible
+            # across whatever SGR the underlying program was using. Selection
+            # still applies on top via REVERSE below.
+            dst.fg = SEARCH_MATCH_FG
+            dst.bg = SEARCH_MATCH_BG
+          end
           dst.attrs |= Terminal::REVERSE if selection && term.selected_at_visible?(r, c)
           dst.hyperlink = src.hyperlink
         end
@@ -473,7 +518,7 @@ module Muxr
       c.attrs = attrs
     end
 
-    def emit_frame(frame, session, input_state:, command_buffer:)
+    def emit_frame(frame, session, input_state:, command_buffer:, search_buffer: "")
       # \e[?2026h enters synchronized-output mode so terminals that support it
       # (Ghostty, kitty, iTerm2 ≥3.5, WezTerm, Alacritty ≥0.13, foot) present
       # the whole frame atomically instead of repainting incrementally as bytes
@@ -517,7 +562,7 @@ module Muxr
       end
       out << "\e]8;;\e\\" if cur_hyperlink
       out << "\e[0m"
-      out << cursor_position(session, input_state: input_state, command_buffer: command_buffer)
+      out << cursor_position(session, input_state: input_state, command_buffer: command_buffer, search_buffer: search_buffer)
       out << "\e[?2026l"
       @out.write(out)
       @out.flush
@@ -526,11 +571,15 @@ module Muxr
       @prev_h = frame.length
     end
 
-    def cursor_position(session, input_state:, command_buffer:)
+    def cursor_position(session, input_state:, command_buffer:, search_buffer: "")
       if input_state == :command
         col = 1 + command_buffer.length + 1 # ':' + buffer
         return "\e[#{session.height};#{col}H\e[?25h"
       end
+      if input_state == :search
+        col = 1 + search_buffer.length + 1 # '/' or '?' + buffer
+        return "\e[#{session.height};#{col}H\e[?25h"
+      end
 
       target =
         if session.focus_drawer && session.drawer&.visible? && session.drawer.pane

data/lib/muxr/terminal.rb

@@ -77,6 +77,10 @@ module Muxr
       @sync_pending = false
       @sync_started_at = nil
       @pending_replies = +"".b
+      @search_query = nil
+      @search_direction = :forward
+      @search_matches = []
+      @search_current = nil
     end
 
     # Bytes the emulator owes back to the inner program in response to a
@@ -351,6 +355,81 @@ module Muxr
       @dirty = true
     end
 
+    # ---------- search ----------
+    #
+    # Substring search over the full timeline (scrollback + live buffer).
+    # Smart-case: case-insensitive if the query is all-lowercase, sensitive
+    # otherwise. Matches are kept in timeline coordinates so they stay
+    # anchored to the same text as the user pages history.
+
+    attr_reader :search_query, :search_matches, :search_current, :search_direction
+
+    def search(query, direction: :forward)
+      query = query.to_s
+      if query.empty?
+        clear_search
+        return 0
+      end
+      @search_query = query
+      @search_direction = direction
+      @search_matches = collect_matches(query)
+      if @search_matches.empty?
+        @search_current = nil
+        @dirty = true
+        return 0
+      end
+      @search_current = nearest_match_in_direction(current_search_anchor_row, direction, inclusive: true)
+      @search_current ||= direction == :forward ? 0 : @search_matches.length - 1
+      scroll_view_to_match(@search_current)
+      @dirty = true
+      @search_matches.length
+    end
+
+    # Move to the next/previous match in the given direction, wrapping.
+    # Returns the new current match index, or nil if there are no matches.
+    # Anchors on the current match (not the viewport top) so n always
+    # advances even when scroll_view_to_match has centered the previous
+    # hit and dragged the viewport top behind it.
+    def find_in_direction(direction)
+      return nil if @search_matches.empty?
+      anchor_tr =
+        if @search_current && @search_matches[@search_current]
+          @search_matches[@search_current][0]
+        else
+          current_search_anchor_row
+        end
+      idx = strict_next_in_direction(anchor_tr, direction)
+      if idx.nil?
+        # Wrap: pick the far end depending on direction.
+        idx = direction == :forward ? 0 : @search_matches.length - 1
+      end
+      @search_current = idx
+      scroll_view_to_match(idx)
+      @dirty = true
+      idx
+    end
+
+    def cell_in_match?(visible_r, c)
+      return false if @search_matches.empty?
+      tr = timeline_row_for_visible(visible_r)
+      # Linear scan is fine: SCROLLBACK_MAX caps matches at O(rows*cols), and
+      # the renderer touches each visible cell once per frame. A row-indexed
+      # cache would matter at much larger buffer sizes than ours.
+      @search_matches.any? { |mr, sc, ec| mr == tr && c >= sc && c <= ec }
+    end
+
+    def search_active?
+      !(@search_query.nil? || @search_matches.empty?)
+    end
+
+    def clear_search
+      return if @search_query.nil? && @search_matches.empty?
+      @search_query = nil
+      @search_matches = []
+      @search_current = nil
+      @dirty = true
+    end
+
     def selected_at_visible?(r, c)
       return false unless @selection_anchor
       tr = timeline_row_for_visible(r)
@@ -770,6 +849,11 @@ module Muxr
             @selection_anchor[0] = [@selection_anchor[0] - 1, 0].max
             @selection_cursor[0] = [@selection_cursor[0] - 1, 0].max
           end
+          unless @search_matches.empty?
+            @search_matches.each { |m| m[0] -= 1 }
+            @search_matches.reject! { |m| m[0] < 0 }
+            @search_current = nil if @search_current && @search_current >= @search_matches.length
+          end
         end
         # Keep the user's view frozen on the same content when new rows arrive
         # while they're scrolled back.
@@ -873,6 +957,73 @@ module Muxr
       end
     end
 
+    def collect_matches(query)
+      case_sensitive = query.match?(/[A-Z]/)
+      needle = case_sensitive ? query : query.downcase
+      matches = []
+      timeline_size.times do |tr|
+        row = timeline_row(tr)
+        next if row.nil?
+        line = String.new(capacity: @cols)
+        @cols.times { |c| line << (row[c]&.char || " ") }
+        haystack = case_sensitive ? line : line.downcase
+        start = 0
+        while (idx = haystack.index(needle, start))
+          matches << [tr, idx, idx + needle.length - 1]
+          # Advance past the start of this match so overlapping needles
+          # ("aa" in "aaaa") still emit one match per starting position.
+          start = idx + 1
+        end
+      end
+      matches
+    end
+
+    # Top of the current viewport in timeline coordinates. Used as the
+    # reference point for "search from where the user is looking now".
+    def current_search_anchor_row
+      timeline_row_for_visible(0)
+    end
+
+    # Smallest match index whose row is >= anchor_tr (forward) or largest
+    # match index whose row is <= anchor_tr (backward). Used by search() so
+    # the first jump lands on the nearest match in the search direction
+    # without forcing the user to press n.
+    def nearest_match_in_direction(anchor_tr, direction, inclusive:)
+      if direction == :forward
+        @search_matches.each_with_index do |(mr, _, _), i|
+          return i if inclusive ? mr >= anchor_tr : mr > anchor_tr
+        end
+        nil
+      else
+        best = nil
+        @search_matches.each_with_index do |(mr, _, _), i|
+          if (inclusive ? mr <= anchor_tr : mr < anchor_tr)
+            best = i
+          else
+            break
+          end
+        end
+        best
+      end
+    end
+
+    # Strict next match (n/N) — never matches the current row; that would
+    # leave the user stuck on the same line they're already on.
+    def strict_next_in_direction(anchor_tr, direction)
+      nearest_match_in_direction(anchor_tr, direction, inclusive: false)
+    end
+
+    # Center the match in the viewport when possible. set_view_offset clamps
+    # to [0, scrollback.size] so recent matches end up showing the live
+    # buffer at the bottom and very old ones pin to the top.
+    def scroll_view_to_match(idx)
+      match = @search_matches[idx]
+      return unless match
+      tr = match[0]
+      desired = @scrollback.size - tr + (@rows / 2)
+      set_view_offset(desired)
+    end
+
     def ensure_selection_cursor_visible
       return unless @selection_cursor
       tr = @selection_cursor[0]

data/lib/muxr/version.rb

@@ -1,3 +1,3 @@
 module Muxr
-  VERSION = "0.1.6"
+  VERSION = "0.1.7"
 end

data/lib/muxr/window.rb

@@ -86,6 +86,19 @@ module Muxr
       @panes[i], @panes[j] = @panes[j], @panes[i]
     end
 
+    # Swap the focused pane with the pane at `idx` and keep focus on the
+    # moved pane (so HJKL can keep dragging it across the layout). Unlike
+    # `focused_index=`, this does not record a last_focused_pane — the user
+    # is still on the same pane, just at a new index in the array.
+    def move_focused_to(idx)
+      return false if @panes.empty?
+      return false unless idx.is_a?(Integer) && idx >= 0 && idx < @panes.length
+      return false if idx == @focused_index
+      @panes[@focused_index], @panes[idx] = @panes[idx], @panes[@focused_index]
+      @focused_index = idx
+      true
+    end
+
     def cycle_layout
       i = LAYOUTS.index(@layout) || 0
       @layout = LAYOUTS[(i + 1) % LAYOUTS.length]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: muxr
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.7
 platform: ruby
 authors:
 - Roel Bondoc