muxr 0.1.10 → 0.2.0

data/lib/muxr/history_row.rb

@@ -0,0 +1,264 @@
+module Muxr
+  class HistoryRow
+    include Enumerable
+
+    CACHE_LIMIT = 256
+    NO_CELLS = [].freeze
+
+    class << self
+      def pack(cells, last)
+        return EMPTY if last.nil?
+        new(cells, last + 1)
+      end
+
+      def retain(row)
+        @retained[row] = true
+        evict_oldest while @retained.size > CACHE_LIMIT
+      end
+
+      private
+
+      def evict_oldest
+        oldest, = @retained.first
+        @retained.delete(oldest)
+        oldest.release!
+      end
+    end
+    @retained = {}
+
+    def initialize(cells, count)
+      @count = count
+      @cells = count.zero? ? NO_CELLS : nil
+      pack_from(cells, count)
+    end
+
+    def length
+      @count
+    end
+    alias size length
+
+    def empty?
+      @count.zero?
+    end
+
+    def [](c)
+      return nil if c >= @count
+      (@cells || materialize)[c]
+    end
+
+    def each(&block)
+      return to_enum(:each) unless block
+      (@cells || materialize).each(&block)
+      self
+    end
+
+    def search_text(cols)
+      return padded_text(cols), nil unless @lengths
+      line = String.new(capacity: @text.bytesize + cols)
+      col_at = []
+      limit = [@count, cols].min
+      each_char_cell do |c, char|
+        break if c >= limit
+        next if char.empty?
+        char.each_char { col_at << c }
+        line << char
+      end
+      (limit...cols).each do |c|
+        line << Terminal::BLANK_CHAR
+        col_at << c
+      end
+      [line, col_at]
+    end
+
+    def to_ansi
+      last = nil
+      each_styled_cell { |c, char, fg, bg, attrs, link| last = c if significant?(char, fg, bg, attrs, link) }
+      return "" if last.nil?
+      out = +""
+      sgr = nil
+      link_open = nil
+      pen = nil
+      skip = 0
+      each_styled_cell do |c, char, fg, bg, attrs, link|
+        break if c > last
+        if skip.positive?
+          skip -= 1
+          next
+        end
+        unless pen && pen[0] == fg && pen[1] == bg && pen[2] == attrs
+          if (s = Terminal.sgr_for(fg, bg, attrs)) != sgr
+            out << s
+            sgr = s
+          end
+          pen = [fg, bg, attrs]
+        end
+        if link != link_open
+          out << "\e]8;;\e\\" if link_open
+          out << "\e]#{link}\e\\" if link
+          link_open = link
+        end
+        if char.empty?
+          out << Terminal::BLANK_CHAR
+        else
+          out << char
+          skip = 1 if Terminal.char_width(char.codepoints.first) == 2
+        end
+      end
+      out << "\e]8;;\e\\" if link_open
+      out
+    end
+
+    def repack!
+      return if @count.zero? || @cells.nil?
+      pack_from(@cells, @count)
+    end
+
+    def release!
+      @cells = nil
+    end
+
+    private
+
+    def pack_from(cells, count)
+      text = String.new(capacity: count)
+      lengths = nil
+      runs = nil
+      run_len = 0
+      fg = nil
+      bg = nil
+      attrs = 0
+      link = nil
+      i = 0
+      while i < count
+        cell = cells[i]
+        ch = cell ? cell.char : Terminal::BLANK_CHAR
+        n = ch.length
+        lengths ||= Array.new(i, 1) unless n == 1
+        lengths << n if lengths
+        text << ch
+        cell_fg = cell ? cell.fg : nil
+        cell_bg = cell ? cell.bg : nil
+        cell_attrs = cell ? cell.attrs.to_i : 0
+        cell_link = cell ? cell.hyperlink : nil
+        if run_len.positive? && cell_attrs == attrs && cell_fg == fg &&
+           cell_bg == bg && cell_link == link
+          run_len += 1
+        else
+          runs = push_run(runs, run_len, fg, bg, attrs, link)
+          run_len = 1
+          fg = cell_fg
+          bg = cell_bg
+          attrs = cell_attrs
+          link = cell_link
+        end
+        i += 1
+      end
+      runs = push_run(runs, run_len, fg, bg, attrs, link)
+      @text = text.freeze
+      @lengths = lengths
+      @runs = unstyled?(runs) ? nil : runs
+    end
+
+    def push_run(runs, len, fg, bg, attrs, link)
+      return runs unless len.positive?
+      (runs || []).push(len, fg, bg, attrs, link)
+    end
+
+    def unstyled?(runs)
+      runs.nil? ||
+        (runs.length == 5 && runs[1].nil? && runs[2].nil? && runs[3].zero? && runs[4].nil?)
+    end
+
+    def padded_text(cols)
+      pad = cols - @count
+      return @text if pad.zero?
+      return @text[0, cols] if pad.negative?
+      @text + (Terminal::BLANK_CHAR * pad)
+    end
+
+    def significant?(char, fg, bg, attrs, link)
+      return true if fg || bg || link || !attrs.zero?
+      char != Terminal::BLANK_CHAR && !char.empty?
+    end
+
+    def each_char_cell
+      if @lengths
+        chars = @text.chars
+        pos = 0
+        @count.times do |i|
+          n = @lengths[i]
+          ch = case n
+               when 0 then Terminal::CONTINUATION_CHAR
+               when 1 then Terminal.intern_char(chars[pos])
+               else chars[pos, n].join
+               end
+          pos += n
+          yield i, ch
+        end
+      elsif @text.ascii_only?
+        @count.times { |i| yield i, Terminal::ASCII_CHARS[@text.getbyte(i)] }
+      else
+        i = 0
+        @text.each_char do |ch|
+          yield i, Terminal.intern_char(ch)
+          i += 1
+        end
+      end
+    end
+
+    def each_styled_cell
+      runs = @runs
+      j = 0
+      left = runs ? runs[0] : @count
+      each_char_cell do |c, char|
+        while left.zero? && runs && j + 5 < runs.length
+          j += 5
+          left = runs[j]
+        end
+        left -= 1
+        if runs
+          yield c, char, runs[j + 1], runs[j + 2], runs[j + 3], runs[j + 4]
+        else
+          yield c, char, nil, nil, 0, nil
+        end
+      end
+    end
+
+    def materialize
+      cells = Array.new(@count)
+      each_char_cell { |i, ch| cells[i] = Terminal::Cell.new(ch, nil, nil, 0, nil) }
+      apply_runs(cells)
+      @cells = cells
+      self.class.retain(self)
+      cells
+    end
+
+    def apply_runs(cells)
+      runs = @runs
+      return if runs.nil?
+      col = 0
+      j = 0
+      while j < runs.length
+        len = runs[j]
+        fg = runs[j + 1]
+        bg = runs[j + 2]
+        attrs = runs[j + 3]
+        link = runs[j + 4]
+        if fg || bg || link || !attrs.zero?
+          len.times do |k|
+            cell = cells[col + k]
+            next unless cell
+            cell.fg = fg
+            cell.bg = bg
+            cell.attrs = attrs
+            cell.hyperlink = link
+          end
+        end
+        col += len
+        j += 5
+      end
+    end
+
+    EMPTY = new(NO_CELLS, 0).freeze
+  end
+end

data/lib/muxr/image_store.rb

@@ -0,0 +1,61 @@
+require "fileutils"
+require "securerandom"
+require "zlib"
+
+module Muxr
+  class ImageStore
+    IMAGES_DIR = File.join(Dir.home, ".muxr", "images").freeze
+    KEEP_RECENT = 200
+    PNG_MAGIC = "\x89PNG\r\n\x1a\n".b.freeze
+
+    def initialize(dir: IMAGES_DIR, keep: KEEP_RECENT)
+      @dir = dir
+      @keep = keep
+    end
+
+    def write(bytes)
+      FileUtils.mkdir_p(@dir)
+      path = File.join(@dir, "#{Time.now.strftime('%Y%m%d-%H%M%S')}-#{SecureRandom.hex(3)}.png")
+      File.binwrite(path, bytes)
+      prune
+      path
+    end
+
+    def self.png?(bytes)
+      bytes.byteslice(0, PNG_MAGIC.bytesize) == PNG_MAGIC
+    end
+
+    def self.png_dimensions(bytes)
+      return nil unless png?(bytes) && bytes.bytesize >= 24
+      return nil unless bytes.byteslice(12, 4) == "IHDR"
+      bytes.byteslice(16, 8).unpack("NN")
+    end
+
+    def self.encode_png(pixels, width, height, channels)
+      return nil if width <= 0 || height <= 0
+      stride = width * channels
+      return nil if pixels.bytesize < stride * height
+      scanlines = +"".b
+      height.times { |y| scanlines << "\x00".b << pixels.byteslice(y * stride, stride) }
+      header = [width, height].pack("NN") << [8, channels == 4 ? 6 : 2, 0, 0, 0].pack("C5")
+      +"".b << PNG_MAGIC <<
+        png_chunk("IHDR", header) <<
+        png_chunk("IDAT", Zlib::Deflate.deflate(scanlines)) <<
+        png_chunk("IEND", +"".b)
+    end
+
+    def self.png_chunk(type, data)
+      body = type.b << data.b
+      +"".b << [data.bytesize].pack("N") << body << [Zlib.crc32(body)].pack("N")
+    end
+    private_class_method :png_chunk
+
+    private
+
+    def prune
+      entries = Dir.glob(File.join(@dir, "*.png"))
+      return if entries.length <= @keep
+      FileUtils.rm_f(entries.sort_by { |p| File.mtime(p) }.first(entries.length - @keep))
+    end
+  end
+end

data/lib/muxr/input_handler.rb

@@ -1,3 +1,5 @@
+require "muxr/command_dispatcher"
+
 module Muxr
   # Translates raw keystrokes into either commands or pane input. Two top-level
   # modes:
@@ -12,13 +14,22 @@ module Muxr
   #
   # Plus the sub-states pre-existing from before modes existed:
   #   :prefix, :command, :confirm_quit, :confirm_close, :help, :scrollback,
-  #   :search, :selection.
+  #   :search, :selection, :pane_picker.
   #
   # 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.
+  #
+  # Scrollback is effectively pane-bound. Ctrl-a is honored from inside
+  # :scrollback and :selection — it drops into :prefix (with @prefix_return
+  # = :scrollback) so a pane switch keeps you in scrollback on the pane you
+  # move to, while the pane you left keeps its own scroll position. Coming
+  # the other way, the Application re-enters scrollback whenever you focus a
+  # pane that was left scrolled back. `i` from scrollback drops to insert
+  # (passthrough) without snapping to the bottom; only `q`/Esc returns the
+  # pane to the live bottom.
   class InputHandler
     PREFIX = "\x01".freeze # Ctrl-a
 
@@ -39,9 +50,15 @@ module Muxr
       "f"  => [:set_layout, :spiral],
       "e"  => [:set_layout, :centered],
       "S"  => [:set_layout, :stack],
+      "F"  => [:set_layout, :auto],
       "\t" => :cycle_layout,
       "\r" => :promote_master,
       "\n" => :promote_master,
+      "<"  => :shrink_master,
+      ">"  => :grow_master,
+      ","  => :remove_master,
+      "."  => :add_master,
+      "z"  => :toggle_zoom,
       "h"  => [:focus_direction, :left],
       "j"  => [:focus_direction, :down],
       "k"  => [:focus_direction, :up],
@@ -51,10 +68,12 @@ module Muxr
       "K"  => [:move_direction, :up],
       "L"  => [:move_direction, :right],
       "a"  => :focus_last,
+      "r"  => :refresh_focused,
       "~"  => :toggle_drawer,
       "C"  => :toggle_claude_drawer,
       "P"  => :toggle_private_focused,
       "d"  => :detach,
+      "A"  => :open_pane_picker,
       "?"  => :show_help,
       "q"  => :quit_immediate,
       "s"  => :enter_scrollback,
@@ -66,14 +85,21 @@ module Muxr
       "n"    => :focus_next,
       "p"    => :focus_prev,
       "a"    => :focus_last,
+      "r"    => :refresh_focused,
       "x"    => :request_close,
       "\t"   => :cycle_layout,
       "\r"   => :promote_master,
       "\n"   => :promote_master,
+      "<"    => :shrink_master,
+      ">"    => :grow_master,
+      ","    => :remove_master,
+      "."    => :add_master,
+      "z"    => :toggle_zoom,
       "~"    => :toggle_drawer,
       "C"    => :toggle_claude_drawer,
       "P"    => :toggle_private_focused,
       "d"    => :detach,
+      "A"    => :open_pane_picker,
       "?"    => :show_help,
       "q"    => :quit_immediate,
       "["    => :enter_scrollback,
@@ -111,6 +137,7 @@ module Muxr
     }.freeze
 
     SCROLLBACK_EXITS = ["q", "\e", "\x03"].freeze # q, Esc, Ctrl-c
+    SCROLL_SOURCE_TOGGLE = "\t"
 
     SELECTION_BINDINGS = {
       "h"    => :left,
@@ -144,20 +171,57 @@ module Muxr
       # `v` so the right thumb has a one-key way to anchor/release.
     }.freeze
 
+    # Attach overlay. Navigation mirrors scrollback's j/k plus the arrow keys
+    # (peeled off by the same CSI lookahead), Enter attaches, and every quit
+    # gesture the other one-shot overlays accept backs out.
+    PICKER_BINDINGS = {
+      "j"    => 1,
+      "k"    => -1,
+      "\x0e" => 1,  # Ctrl-n
+      "\x10" => -1  # Ctrl-p
+    }.freeze
+
+    PICKER_CSI = {
+      "\e[A" => -1, # Up
+      "\e[B" => 1   # Down
+    }.freeze
+
+    PICKER_CANCEL = ["q", "\e", "\x03"].freeze # q, Esc, Ctrl-c
+    PICKER_CONFIRM = ["\r", "\n", " "].freeze
+    # `m` takes the pane instead of sharing it: it leaves the session it came
+    # from and this one owns the shell afterwards.
+    PICKER_MOVE = ["m"].freeze
+
     SELECTION_YANK = ["\r", "\n", "y"].freeze
     SELECTION_CANCEL = ["q", "\e", "\x03"].freeze # q, Esc, Ctrl-c
 
     DIGIT_RE = /\A[1-9]\z/.freeze
 
-    attr_reader :state, :command_buffer, :search_buffer, :search_direction, :base_mode
+    attr_reader :state, :command_buffer, :command_completions, :search_buffer, :search_direction, :base_mode, :scroll_source, :prefix
 
     def initialize(app)
       @app = app
       @state = :normal
       @base_mode = :normal
+      @scroll_source = :ring
       @command_buffer = +""
+      # Ambiguous Tab-completion candidates for the current command buffer,
+      # shown as a hint in the prompt. nil when there's nothing to disambiguate.
+      @command_completions = nil
       @search_buffer = +""
       @search_direction = :forward
+      # When the prefix state is entered from scrollback/selection (Ctrl-a),
+      # this records :scrollback so that a pane switch lands you back in
+      # scrollback on the newly-focused pane instead of dropping to the base
+      # mode. nil means "use @base_mode" (the normal passthrough behavior).
+      @prefix_return = nil
+      configure(nil)
+    end
+
+    def configure(config)
+      @prefix = config ? config.prefix : PREFIX
+      @normal_bindings = NORMAL_BINDINGS.merge(config ? config.normal_keys : {})
+      @prefix_bindings = PREFIX_BINDINGS.merge(config ? config.prefix_keys : {})
     end
 
     def feed(data)
@@ -167,7 +231,7 @@ module Muxr
           # 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)
+          idx = remaining.index(@prefix)
           if idx.nil?
             @app.send_to_focused(remaining)
             return
@@ -185,7 +249,7 @@ module Muxr
         # 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[")
+        if (@state == :scrollback || @state == :search || @state == :pane_picker) && remaining.start_with?("\e[")
           consumed = consume_csi_escape(remaining)
           if consumed > 0
             remaining = remaining[consumed..] || ""
@@ -215,6 +279,8 @@ module Muxr
           handle_search_input(ch)
         when :selection
           handle_selection_input(ch)
+        when :pane_picker
+          handle_pane_picker_input(ch)
         end
       end
     end
@@ -231,8 +297,9 @@ module Muxr
       @state = :confirm_close
     end
 
-    def enter_scrollback_mode
+    def enter_scrollback_mode(source: nil)
       @state = :scrollback
+      @scroll_source = source if source
     end
 
     def enter_search_mode(direction: :forward)
@@ -245,6 +312,10 @@ module Muxr
       @state = :selection
     end
 
+    def enter_pane_picker_mode
+      @state = :pane_picker
+    end
+
     # Drop into passthrough — every key reaches the focused pane until the
     # user issues Ctrl-a Esc.
     def enter_passthrough_mode
@@ -270,6 +341,7 @@ module Muxr
     def cancel
       @state = @base_mode
       @command_buffer = +""
+      @command_completions = nil
     end
 
     private
@@ -286,6 +358,7 @@ module Muxr
       if ch == ":"
         @state = :command
         @command_buffer = +""
+        @command_completions = nil
         return
       end
       if DIGIT_RE.match?(ch)
@@ -293,7 +366,7 @@ module Muxr
         return
       end
 
-      action = NORMAL_BINDINGS[ch]
+      action = @normal_bindings[ch]
       case action
       when Symbol
         @app.public_send(action)
@@ -305,7 +378,13 @@ module Muxr
     end
 
     def handle_prefix(ch)
-      action = PREFIX_BINDINGS[ch]
+      # Where to land once the prefix binding finishes. Normally the base
+      # mode, but :scrollback when we entered the prefix from scrollback /
+      # selection so a pane switch keeps you in scrollback on the new pane.
+      # Consume it immediately so it never leaks into the next prefix.
+      ret = @prefix_return || @base_mode
+      @prefix_return = nil
+      action = @prefix_bindings[ch]
       case
       when ch == "\e"
         # Ctrl-a Esc → return to normal mode. Flip state directly so tests
@@ -316,20 +395,24 @@ module Muxr
       when ch == ":"
         @state = :command
         @command_buffer = +""
-      when ch == PREFIX
-        @app.send_to_focused(PREFIX)
+        @command_completions = nil
+      when ch == @prefix
+        @app.send_to_focused(@prefix)
         @state = @base_mode
       when DIGIT_RE.match?(ch)
         @app.focus_pane_number(ch.to_i)
-        @state = @base_mode
+        # The focus action may auto-enter scrollback (landing on a pane that
+        # was left scrolled). Only fall back to `ret` if it didn't.
+        @state = ret if @state == :prefix
       when action
-        @app.public_send(action)
+        @app.public_send(*Array(action))
         # 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
+        # scrollback via auto-enter, help). Only fall back to `ret` if we're
+        # still in :prefix.
+        @state = ret if @state == :prefix
       else
-        # Unknown prefix key: return to base mode silently.
-        @state = @base_mode
+        # Unknown prefix key: return to where we came from silently.
+        @state = ret
       end
     end
 
@@ -352,6 +435,29 @@ module Muxr
     end
 
     def handle_scrollback_input(ch)
+      if ch == @prefix
+        # Ctrl-a is the escape hatch even from scrollback: drop into the
+        # prefix state so the user can switch panes (Ctrl-a n/p/a/1-9) or
+        # run any other prefix binding without first leaving scrollback.
+        # @prefix_return = :scrollback keeps the user in scrollback on the
+        # pane they switch to; the source pane keeps its scroll position so
+        # it stays put. Scrollback is effectively pane-bound now.
+        @prefix_return = :scrollback
+        @state = :prefix
+        return
+      end
+      if ch == SCROLL_SOURCE_TOGGLE
+        @app.toggle_scroll_source
+        return
+      end
+      if ch == "i"
+        # Drop straight into insert (passthrough) without snapping to the
+        # live bottom — the pane stays where it's scrolled. Mirrors the
+        # normal-mode `i` so "type now" is one key from scrollback too.
+        enter_passthrough_mode
+        @app.enter_passthrough_mode
+        return
+      end
       if SCROLLBACK_EXITS.include?(ch)
         enter_idle_mode
         @app.exit_scrollback
@@ -421,9 +527,13 @@ module Muxr
         b = remaining.getbyte(i)
         if b >= 0x40 && b <= 0x7e
           seq = remaining.byteslice(0, i + 1)
-          if @state == :scrollback
+          case @state
+          when :scrollback
             action = SCROLLBACK_CSI[seq]
             @app.scroll_focused(action) if action
+          when :pane_picker
+            delta = PICKER_CSI[seq]
+            @app.move_pane_picker(delta) if delta
           end
           return i + 1
         end
@@ -434,6 +544,16 @@ module Muxr
     end
 
     def handle_selection_input(ch)
+      if ch == @prefix
+        # Same escape hatch as scrollback: Ctrl-a enters the prefix state so
+        # pane switching (and any other prefix binding) works mid-selection.
+        # We return to :scrollback (not :selection) on the new pane — you
+        # don't want to be mid-select on a pane you just arrived at — while
+        # the source pane keeps its scroll position and selection intact.
+        @prefix_return = :scrollback
+        @state = :prefix
+        return
+      end
       if SELECTION_YANK.include?(ch)
         @app.exit_selection(yank: true)
         return
@@ -455,22 +575,54 @@ module Muxr
       # Unknown keys ignored — same rationale as scrollback mode.
     end
 
+    def handle_pane_picker_input(ch)
+      if PICKER_CONFIRM.include?(ch)
+        @state = @base_mode
+        @app.confirm_pane_picker
+        return
+      end
+      if PICKER_MOVE.include?(ch)
+        @state = @base_mode
+        @app.confirm_pane_picker(move: true)
+        return
+      end
+      if PICKER_CANCEL.include?(ch)
+        @state = @base_mode
+        @app.cancel_pane_picker
+        return
+      end
+      delta = PICKER_BINDINGS[ch]
+      @app.move_pane_picker(delta) if delta
+      # Unknown keys ignored — same rationale as scrollback mode.
+    end
+
     def handle_command_input(ch)
       case ch
       when "\r", "\n"
         cmd = @command_buffer.dup
         @command_buffer = +""
+        @command_completions = nil
         @state = @base_mode
         @app.run_command(cmd)
-      when "\e"
+      when "\e", "\x03" # Esc or Ctrl-c → abandon the command
         @command_buffer = +""
+        @command_completions = nil
         @state = @base_mode
         @app.invalidate
+      when "\t"
+        new_line, candidates = CommandDispatcher.complete(@command_buffer)
+        @command_buffer = +new_line
+        # Only keep the hint list when it's still ambiguous; a unique match
+        # (or none) leaves nothing useful to show.
+        @command_completions = candidates.length > 1 ? candidates : nil
+        @app.invalidate
       when "\x7f", "\b"
         @command_buffer.chop!
+        @command_completions = nil
         @app.invalidate
       else
         @command_buffer << ch if ch.ord >= 0x20
+        @command_completions = nil if ch.ord >= 0x20
         @app.invalidate
       end
     end