claude-inbox 0.1.0

data/lib/claude_inbox/terminal.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require "io/console"
+require "tty-cursor"
+require "tty-screen"
+require_relative "renderer"
+
+module ClaudeInbox
+  # The screen the inbox draws on: the alt screen and the mouse and wheel
+  # modes that come and go with it, raw mode on the input, the cached size,
+  # and the Painter that diffs frames onto it. `release` hands the whole
+  # thing to a child that wants the tty and takes it back afterwards.
+  class Terminal
+    ALT_ON = "\e[?1049h"
+    ALT_OFF = "\e[?1049l"
+    # Alternate scroll mode: while the alt screen is up the terminal turns
+    # wheel ticks into cursor keys, so a scroll moves the selection instead of
+    # dragging the scrollback we are covering into view. Terminals that don't
+    # know the mode ignore it and keep scrolling their own history.
+    WHEEL_KEYS_ON = "\e[?1007h"
+    WHEEL_KEYS_OFF = "\e[?1007l"
+    # Real mouse reporting: button events plus the SGR encoding, so clicks
+    # and wheel ticks arrive as escape sequences we parse ourselves (Mouse)
+    # instead of the terminal only ever translating the wheel to arrow
+    # keys. Terminals that don't understand either mode just ignore it and
+    # fall back to WHEEL_KEYS_ON's translation, or their own scrollback.
+    MOUSE_ON = "\e[?1000h\e[?1006h"
+    MOUSE_OFF = "\e[?1006l\e[?1000l"
+    # Bracketed paste: what is pasted arrives fenced off from what is typed
+    # (Paste), and a pasted image, which has no text, arrives as an empty
+    # fence rather than not at all.
+    PASTE_ON = "\e[?2004h"
+    PASTE_OFF = "\e[?2004l"
+
+    def initialize(out, input)
+      @out = out
+      @input = input
+      @painter = Painter.new(out)
+      @restored = true
+      @size = nil
+    end
+
+    def enter
+      @out.print ALT_ON, WHEEL_KEYS_ON, MOUSE_ON, PASTE_ON, TTY::Cursor.hide, TTY::Cursor.clear_screen
+      @out.flush
+      @input.raw! if @input.respond_to?(:raw!) && @input.tty?
+      @restored = false
+      resized
+    end
+
+    # Safe to call twice, and from at_exit: the second call is a no-op.
+    def restore
+      return if @restored
+      @restored = true
+      @input.cooked! if @input.respond_to?(:cooked!) && @input.tty?
+      @out.print TTY::Cursor.show, PASTE_OFF, MOUSE_OFF, WHEEL_KEYS_OFF, ALT_OFF
+      @out.flush
+    rescue
+      nil
+    end
+
+    # Gives the tty to the block, cleared and in cooked mode, and comes back
+    # to a fresh alt screen whatever the block did.
+    def release
+      restore
+      @out.print TTY::Cursor.clear_screen
+      @out.flush
+      yield
+    ensure
+      enter
+    end
+
+    # [cols, rows]. Cached: querying the terminal can fall back to spawning
+    # `tput`, which is far too slow to do on every frame. Refreshed by
+    # `resized`, which WINCH and re-entry both call.
+    def size
+      @size ||= measure
+    end
+
+    def resized
+      @size = nil
+      @painter.invalidate
+    end
+
+    def paint(lines) = @painter.paint(lines)
+
+    # Repaint every row on the next frame.
+    def invalidate = @painter.invalidate
+
+    private
+
+    def measure
+      rows, cols = begin
+        (@out.respond_to?(:winsize) && @out.tty?) ? @out.winsize : TTY::Screen.size
+      rescue
+        TTY::Screen.size
+      end
+      [[cols, 40].max, [rows, 8].max]
+    end
+  end
+end

data/lib/claude_inbox/text.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "unicode/display_width"
+
+module ClaudeInbox
+  # Width-aware string helpers. Never use String#[] on user-facing text:
+  # session names carry emoji and glyphs that break byte/char slicing.
+  module Text
+    ANSI = /\e\[[0-9;?]*[A-Za-z]/
+    ELLIPSIS = "…"
+
+    module_function
+
+    def strip_ansi(s) = s.gsub(ANSI, "")
+
+    def width(s) = Unicode::DisplayWidth.of(strip_ansi(s))
+
+    # Truncate plain (uncolored) text to `w` columns, appending an ellipsis
+    # when anything was cut. Handles wide glyphs by stepping grapheme by grapheme.
+    def truncate(s, w)
+      return "" if w <= 0
+      return s if width(s) <= w
+      take(s, w - width(ELLIPSIS)) << ELLIPSIS
+    end
+
+    # First `n` columns of plain text, no ellipsis.
+    def take(s, n)
+      out = +""
+      used = 0
+      s.each_grapheme_cluster do |g|
+        gw = Unicode::DisplayWidth.of(g)
+        break if used + gw > n
+        out << g
+        used += gw
+      end
+      out
+    end
+
+    # Plain text with its first `n` columns removed.
+    def drop(s, n)
+      used = 0
+      out = +""
+      s.each_grapheme_cluster do |g|
+        if used >= n
+          out << g
+        else
+          used += Unicode::DisplayWidth.of(g)
+        end
+      end
+      out
+    end
+
+    # Right-pad (ANSI-aware) to exactly `w` columns. Truncates if too long.
+    def pad(s, w)
+      cur = width(s)
+      if cur > w
+        s = truncate(strip_ansi(s), w)
+        cur = width(s)
+      end
+      s + (" " * (w - cur))
+    end
+
+    # Greedy word wrap on display width. Words wider than `w` are split.
+    def wrap(s, w) = segments(s, w).map(&:rstrip)
+
+    # Word wrap that keeps every character, so joining the segments back
+    # together returns the original string. An editor needs that: `wrap`
+    # drops the space you just typed, and with it the cursor's place.
+    def segments(s, w)
+      return [s] if w <= 0 || width(s) <= w
+      lines = []
+      line = +""
+      s.split(/(?<= )/).each do |word|
+        if width(line) + width(word.rstrip) > w && !line.empty?
+          lines << line
+          line = +""
+        end
+        while width(word) > w
+          lines << take(word, w)
+          word = word[take(word, w).size..]
+        end
+        line << word
+      end
+      lines << line unless line.empty?
+      lines
+    end
+
+    # "45s", "12m", "3h", "2d"
+    def age(seconds)
+      s = seconds.to_i
+      return "0s" if s <= 0
+      return "#{s}s" if s < 60
+      return "#{s / 60}m" if s < 3600
+      return "#{s / 3600}h" if s < 86_400
+      "#{s / 86_400}d"
+    end
+  end
+end

data/lib/claude_inbox/text_buffer.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+require_relative "text"
+
+module ClaudeInbox
+  # One editable string with a cursor in it. Every edit and all the cursor
+  # arithmetic live here, so callers never index into the text themselves:
+  # they hand over keypresses and ask for something to draw.
+  #
+  # Positions count cells, not bytes or characters. A cell is a grapheme
+  # cluster — prompts and session names carry emoji, and character indexes
+  # cut them in half — or a Chip, an attached image that shows as one
+  # `[Image #1]` token and moves and deletes as one unit, the way Claude
+  # Code's own prompt treats a pasted image.
+  #
+  #   b = TextBuffer.new("ab")
+  #   b.press(:left, "\e[D")
+  #   b.press("X", "X")
+  #   b.to_s                    # => "aXb"
+  class TextBuffer
+    Chip = Struct.new(:n, :path) do
+      def to_s = "[Image ##{n}]"
+    end
+
+    def initialize(text = "")
+      @g = text.grapheme_clusters
+      @cursor = @g.size
+    end
+
+    def to_s = @g.join
+
+    def empty? = @g.empty?
+
+    # Grapheme offset of the cursor. Rendering goes through #row / #view;
+    # this is here for callers that need to reason about position (tests).
+    attr_reader :cursor
+
+    def chips = @g.grep(Chip)
+
+    def expand = @g.map { |c| c.is_a?(Chip) ? yield(c) : c }.join
+
+    # Swaps the whole text out and parks the cursor at the end — what
+    # completion wants after it extends a path.
+    def replace(text)
+      @g = text.grapheme_clusters
+      @cursor = @g.size
+      self
+    end
+
+    # Everything before the cursor, as one string.
+    def head = @g[0...@cursor].join
+
+    # How completion drops a picked command in over the half-typed one.
+    def replace_before(count, text)
+      delete(@cursor - count, count)
+      insert(text)
+    end
+
+    def insert(text)
+      g = text.grapheme_clusters
+      @g.insert(@cursor, *g)
+      @cursor += g.size
+    end
+
+    # Numbered after the chips already in the text, so a second image is
+    # `[Image #2]` even after the first was deleted, as Claude Code does.
+    def attach(path)
+      chip = Chip.new(@next_chip = (@next_chip || 0) + 1, path)
+      @g.insert(@cursor, chip)
+      @cursor += 1
+      chip
+    end
+
+    # Handles one keypress — readline's editing keys, plus printable text —
+    # or returns false when the key is not ours and the caller should deal
+    # with it (Tab, Enter, Escape, anything else unprintable).
+    def press(name, raw)
+      case name
+      when :left then @cursor = [@cursor - 1, 0].max
+      when :right then @cursor = [@cursor + 1, @g.size].min
+      when :home, :ctrl_a then @cursor = 0
+      when :end, :ctrl_e then @cursor = @g.size
+      when :backspace, :ctrl_h then delete(@cursor - 1, 1)
+      when :delete then delete(@cursor, 1)
+      when :ctrl_u then delete(0, @cursor)
+      when :ctrl_k then delete(@cursor, @g.size - @cursor)
+      when :ctrl_w then delete_word
+      else
+        return false unless raw.is_a?(String) && raw.match?(/\A[[:print:]]+\z/)
+        insert(raw)
+      end
+      true
+    end
+
+    # The text as a single row of at most `width` columns, scrolled right so
+    # that the cursor stays in view on a value longer than the box. `cursor`
+    # paints the one cell under it; pass nil for an unfocused field, which
+    # gets plain truncated text instead.
+    def row(width, cursor: nil)
+      return Text.truncate(to_s, width) unless cursor
+      first = 0
+      first += 1 while width_of(@g[first...@cursor]) > width - 1
+      cells = []
+      @g[first..].each do |c|
+        break if width_of(cells) + width_of([c]) > width
+        cells << c
+      end
+      paint(cells, @cursor - first, cursor)
+    end
+
+    # The visible slice of a multi-line editor: word-wrapped to `width`, at
+    # most `height` rows, plus how many rows are hidden above them. Shows the
+    # end of the text, which is where typing happens; walk the cursor up out
+    # of that window and the window follows it instead. `chip` paints each
+    # attached image's token; without it they read as plain text.
+    def view(width, height, cursor: nil, chip: nil)
+      rows = wrapped(width)
+      at = cursor_row(rows)
+      first = [rows.size - height, 0].max
+      first = at if at < first
+      slice = rows[first, height]
+      lines = slice.map { |cells, _| paint(cells, nil, nil, chip) }
+      if cursor
+        cells, start = slice[at - first]
+        lines[at - first] = paint(cells, @cursor - start, cursor, chip)
+      end
+      [lines, first]
+    end
+
+    private
+
+    def width_of(cells) = cells.sum { |c| Text.width(c.to_s) }
+
+    def paint(cells, offset, cursor, chip = nil)
+      out = cells.each_with_index.map do |c, i|
+        s = c.to_s
+        s = chip.call(s) if chip && c.is_a?(Chip)
+        (i == offset) ? cursor.call(s) : s
+      end
+      out << cursor.call(" ") if offset && offset >= cells.size
+      out.join
+    end
+
+    # One entry per display row: [cells, offset of its first cell]. A
+    # cursor at the end of a row that is already full has no cell of its
+    # own, so it gets a row of its own — what a terminal does when text
+    # reaches the right margin.
+    def wrapped(width)
+      rows = logical_lines.flat_map do |line, start|
+        at = start
+        (line.empty? ? [[]] : segments(line, width)).map do |seg|
+          row = [seg, at]
+          at += seg.size
+          row
+        end
+      end
+      rows << [[], @g.size] if @cursor == @g.size && width_of(rows.last.first) >= width
+      rows
+    end
+
+    # Text.segments on cells: a chip is one cell however wide its label, so
+    # the wrap has to measure cells rather than a joined string.
+    def segments(cells, width)
+      return [cells] if width_of(cells) <= width
+      words = cells.slice_when { |c, _| c == " " }.to_a
+      lines = []
+      line = []
+      words.each do |word|
+        if !line.empty? && width_of(line) + width_of(word.reverse.drop_while { |c| c == " " }) > width
+          lines << line
+          line = []
+        end
+        while width_of(word) > width
+          cut = word.size - 1
+          cut -= 1 while cut > 0 && width_of(word[0...cut]) > width
+          lines << word[0...cut]
+          word = word[cut..]
+        end
+        line += word
+      end
+      lines << line unless line.empty?
+      lines
+    end
+
+    # The newline itself belongs to the line it ends, so a cursor sitting on
+    # it lands past the end of that line rather than at the start of the next.
+    def logical_lines
+      out = []
+      start = 0
+      line = []
+      @g.each_with_index do |g, i|
+        next line << g unless g == "\n"
+        out << [line, start]
+        line = []
+        start = i + 1
+      end
+      out << [line, start]
+    end
+
+    def cursor_row(rows) = rows.rindex { |_, start| start <= @cursor } || 0
+
+    def delete(at, length)
+      return if at < 0 || length <= 0
+      @g.slice!(at, length)
+      @cursor = at
+    end
+
+    # Back over any spaces, then over the word itself.
+    def delete_word
+      at = @cursor
+      at -= 1 while at > 0 && @g[at - 1] == " "
+      at -= 1 while at > 0 && @g[at - 1] != " "
+      delete(at, @cursor - at)
+    end
+  end
+end

data/lib/claude_inbox/theme.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module ClaudeInbox
+  # Chrome hues tuned to Atom One Dark rather than the terminal profile's
+  # own ANSI reds and greens. 256-color indices, since those render the
+  # same everywhere a terminal claims 256-color support.
+  class Theme
+    HUES = {red: 203, green: 108, yellow: 179, blue: 75, purple: 176, cyan: 73}.freeze
+    BG = 236
+
+    def initialize(enabled: true)
+      @enabled = enabled
+      HUES.each_key do |hue|
+        define_singleton_method(hue) { |text| color(text, hue) }
+        define_singleton_method(:"#{hue}_bold") { |text| color(text, hue, bold: true) }
+      end
+    end
+
+    # A filled pill: editor-background text on the hue, for a selected row
+    # or choice — the inverse of `color`, which puts the hue on the text.
+    def pill(text, hue)
+      return text unless @enabled
+      "\e[38;5;#{BG};48;5;#{HUES.fetch(hue)}m#{text}\e[0m"
+    end
+
+    private
+
+    def color(text, hue, bold: false)
+      return text unless @enabled
+      codes = ["38;5;#{HUES.fetch(hue)}"]
+      codes << "1" if bold
+      "\e[#{codes.join(";")}m#{text}\e[0m"
+    end
+  end
+end

data/lib/claude_inbox/vt_screen.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require "strscan"
+require "unicode/display_width"
+
+module ClaudeInbox
+  # A deliberately small cursor-addressed screen model. `claude logs` emits a
+  # replay of the session's terminal output — cursor moves, erase-line, SGR —
+  # not plain text, and words are often separated by cursor motion instead of
+  # spaces. Stripping escapes therefore yields garbage; feeding them through a
+  # grid does not. This is not a VT emulator: it handles the handful of
+  # sequences the replay actually uses and ignores the rest.
+  class VtScreen
+    CSI = /\e\[([0-9;?]*)([A-Za-z@`])/
+    OSC = /\e\][^\a\e]*(?:\a|\e\\)?/
+    ESC_OTHER = /\e[()#][A-Za-z0-9]|\e[A-Za-z0-9=>78]/
+
+    attr_reader :rows, :cols
+
+    def initialize(rows: 300, cols: 300)
+      @rows = rows
+      @cols = cols
+      @grid = Array.new(rows) { Array.new(cols) { " " } }
+      @row = 0
+      @col = 0
+    end
+
+    def feed(str)
+      ss = StringScanner.new(str.dup.force_encoding("UTF-8").scrub)
+      until ss.eos?
+        if ss.scan(CSI)
+          csi(ss[1], ss[2])
+        elsif ss.scan(OSC) || ss.scan(ESC_OTHER)
+          next
+        else
+          ch = ss.getch
+          control(ch) || put(ch)
+        end
+      end
+      self
+    end
+
+    # Text rows with trailing whitespace removed; leading/trailing blank rows
+    # dropped and runs of blank rows collapsed to one.
+    def lines
+      out = @grid.map { |r| r.join.rstrip }
+      out.shift while out.first&.empty?
+      out.pop while out.last&.empty?
+      out.chunk_while { |a, b| a.empty? && b.empty? }.map(&:first)
+    end
+
+    private
+
+    def control(ch)
+      case ch
+      when "\r" then @col = 0
+      when "\n" then newline
+      when "\b" then @col = [@col - 1, 0].max
+      when "\t" then @col = [((@col / 8) + 1) * 8, @cols - 1].min
+      when "\a", "\0", "\e" then nil
+      else return false
+      end
+      true
+    end
+
+    def newline
+      if @row >= @rows - 1
+        @grid.shift
+        @grid << Array.new(@cols) { " " }
+      else
+        @row += 1
+      end
+    end
+
+    def put(ch)
+      o = ch.ord
+      return if o < 32
+      w = (o < 127) ? 1 : Unicode::DisplayWidth.of(ch)
+      return if w <= 0
+      if @col + w > @cols
+        @col = 0
+        newline
+      end
+      @grid[@row][@col] = ch
+      @grid[@row][@col + 1] = "" if w == 2 && @col + 1 < @cols
+      @col += w
+    end
+
+    def csi(params, final)
+      return if params.start_with?("?")
+      nums = params.split(";").map { |x| x.empty? ? nil : x.to_i }
+      n = nums[0] || 1
+      case final
+      when "H", "f"
+        @row = ((nums[0] || 1) - 1).clamp(0, @rows - 1)
+        @col = ((nums[1] || 1) - 1).clamp(0, @cols - 1)
+      when "A" then @row = [@row - n, 0].max
+      when "B" then @row = [@row + n, @rows - 1].min
+      when "C" then @col = [@col + n, @cols - 1].min
+      when "D" then @col = [@col - n, 0].max
+      when "G", "`" then @col = (n - 1).clamp(0, @cols - 1)
+      when "d" then @row = (n - 1).clamp(0, @rows - 1)
+      when "E"
+        @row = [@row + n, @rows - 1].min
+        @col = 0
+      when "F"
+        @row = [@row - n, 0].max
+        @col = 0
+      when "J" then erase_display(nums[0] || 0)
+      when "K" then erase_line(nums[0] || 0)
+      when "@" then n.times { @grid[@row].insert(@col, " ") && @grid[@row].pop }
+      when "P" then n.times { @grid[@row].delete_at(@col) && @grid[@row].push(" ") }
+      when "X" then n.times { |k| @grid[@row][@col + k] = " " if @col + k < @cols }
+      end
+    end
+
+    def erase_display(mode)
+      case mode
+      when 0
+        erase_line(0)
+        ((@row + 1)...@rows).each { |r| @grid[r].fill(" ") }
+      when 1
+        erase_line(1)
+        (0...@row).each { |r| @grid[r].fill(" ") }
+      else
+        @grid.each { |r| r.fill(" ") }
+      end
+    end
+
+    def erase_line(mode)
+      case mode
+      when 0 then @grid[@row].fill(" ", @col)
+      when 1 then @grid[@row].fill(" ", 0, @col + 1)
+      else @grid[@row].fill(" ")
+      end
+    end
+  end
+end

data/lib/claude_inbox.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module ClaudeInbox
+  VERSION = "0.1.0"
+end
+
+require_relative "claude_inbox/palette"
+require_relative "claude_inbox/session"
+require_relative "claude_inbox/job_state"
+require_relative "claude_inbox/pull_requests"
+require_relative "claude_inbox/agents_client"
+require_relative "claude_inbox/sessions"
+require_relative "claude_inbox/store"
+require_relative "claude_inbox/reaper"