claude-inbox 0.1.0

data/lib/claude_inbox/job_state.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "json"
+
+module ClaudeInbox
+  # What the daemon writes about a background session in
+  # ~/.claude/jobs/<id>/state.json. The only reader of that file.
+  #
+  # `claude agents --json` reports one word, `state`, and "working" covers two
+  # different situations: the agent is thinking, or the agent is idle and
+  # something it started earlier — a watch shell, a sub-agent — is still open.
+  # The file tells them apart: `tempo` is the agent's own pulse, `fan` names
+  # each outstanding piece of work, and `detail` is the session's own status
+  # line, with `needs` naming what it is waiting on while blocked and
+  # `output.result` what it produced once done. It also carries the PR links the daemon scanned out of the
+  # transcript, which PullRequests reads through here, and the color `/color`
+  # set on the session, which `claude agents --json` drops.
+  #
+  # Never cached. A color changes the moment you type `/color`, so every poll
+  # asks the file again.
+  #
+  # The file says what a session is *doing*, never whether it is *alive*: the
+  # session's own process writes it, so one that dies hard leaves it frozen
+  # mid-turn, claiming "working" for ever. Liveness stays with the daemon.
+  class JobState
+    DEFAULT_DIR = File.join(Dir.home, ".claude", "jobs")
+
+    # The daemon's names for the things a session waits on, in ours.
+    KIND_WORDS = {
+      "shell" => "shell",
+      "local_bash" => "shell",
+      "teammate" => "agent",
+      "in_process_teammate" => "agent",
+      "monitor" => "monitor"
+    }.freeze
+
+    # Each background session with its job file read onto `job_state`, or nil
+    # when there is none: interactive sessions have no job file, and neither
+    # does one the daemon has already forgotten. Sessions.load calls this.
+    def self.enrich(sessions, jobs_dir: DEFAULT_DIR)
+      sessions.map { |s| s.background? ? s.with(job_state: read(s.id, jobs_dir: jobs_dir)) : s }
+    end
+
+    # => JobState, or nil when there is no readable file for this id.
+    def self.read(id, jobs_dir: DEFAULT_DIR)
+      return nil unless id
+      new(JSON.parse(File.read(File.join(jobs_dir, id, "state.json"))))
+    rescue JSON::ParserError, SystemCallError
+      nil
+    end
+
+    attr_reader :detail, :needs, :result, :tempo, :kinds, :tasks, :pr_urls, :color
+
+    def initialize(hash)
+      @detail = hash["detail"]
+      @needs = hash["needs"]
+      @result = (hash["output"] || {})["result"]
+      @tempo = hash["tempo"]
+      @kinds = (hash["fan"] || []).filter_map { |f| f["kind"] }
+      @tasks = (hash["inFlight"] || {})["tasks"].to_i
+      @pr_urls = (hash["children"] || []).select { |c| c["kind"] == "pr" && c["href"] }.map { |c| c["href"] }
+      @color = hash["color"]
+    end
+
+    # The agent itself is not thinking. On its own this means little — a
+    # session whose process died leaves the same reading behind — so it only
+    # says something paired with work still in flight.
+    def agent_idle? = tempo == "idle"
+
+    def in_flight? = tasks.positive?
+
+    # True when the agent has stopped and is only waiting on what it started.
+    def waiting_on_work? = agent_idle? && in_flight?
+
+    # "1 shell", "2 agents · 1 shell". Falls back to a bare count for a state
+    # file that counts the open tasks without naming them.
+    def in_flight_label
+      return nil unless in_flight?
+      return count_label if kinds.empty?
+      kinds.tally.map { |kind, n| "#{n} #{plural(KIND_WORDS.fetch(kind, kind), n)}" }.join(" · ")
+    end
+
+    private
+
+    def count_label = "#{tasks} #{plural("task", tasks)}"
+
+    def plural(word, n) = (n == 1) ? word : "#{word}s"
+  end
+end

data/lib/claude_inbox/keymap.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module ClaudeInbox
+  # Pure key -> action resolver with vim-style chords. The App feeds it one
+  # keypress at a time (the tty-reader key name plus the raw string) and gets
+  # back an action symbol, or nil while a chord is pending.
+  #
+  #   km = Keymap.new
+  #   km.press(:down, "j")   # => :down
+  #   km.press("g", "g")     # => nil   (pending)
+  #   km.press("g", "g")     # => :top
+  class Keymap
+    CHORD_TIMEOUT = 1.0
+
+    BINDINGS = {
+      # motion
+      "j" => :down, :down => :down,
+      "k" => :up, :up => :up,
+      "G" => :bottom,
+      :ctrl_d => :half_page_down, :ctrl_u => :half_page_up,
+      :ctrl_f => :page_down, :ctrl_b => :page_up,
+      :ctrl_e => :peek_down, :ctrl_y => :peek_up,
+      "J" => :peek_down, "K" => :peek_up,
+      # actions
+      :return => :activate, :enter => :activate, "l" => :activate,
+      "h" => :collapse,
+      "s" => :snooze, "u" => :wake, "a" => :alias, "x" => :settle, "X" => :stop,
+      :ctrl_x => :delete,
+      "o" => :open_pr, "P" => :link_pr, "t" => :toggle_pin,
+      "R" => :refresh, "p" => :toggle_peek, "n" => :new_session,
+      :tab => :next_section, :back_tab => :prev_section,
+      "/" => :filter, :escape => :escape,
+      "q" => :quit, :ctrl_c => :quit
+    }.freeze
+
+    CHORDS = {
+      "g" => {"g" => :top},
+      "z" => {"o" => :fold_open, "c" => :fold_close, "a" => :fold_toggle}
+    }.freeze
+
+    attr_reader :pending
+
+    def initialize(clock: -> { Time.now })
+      @clock = clock
+      @pending = nil
+      @pending_at = nil
+    end
+
+    def press(name, raw)
+      expire_pending
+      if @pending
+        table = CHORDS[@pending]
+        @pending = nil
+        return table[raw] # nil on an unknown second key, chord dropped
+      end
+      if CHORDS.key?(raw)
+        @pending = raw
+        @pending_at = @clock.call
+        return nil
+      end
+      BINDINGS[name] || BINDINGS[raw]
+    end
+
+    private
+
+    def expire_pending
+      return unless @pending && @clock.call - @pending_at > CHORD_TIMEOUT
+      @pending = nil
+    end
+  end
+end

data/lib/claude_inbox/logs.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative "vt_screen"
+
+module ClaudeInbox
+  # The `claude logs <id>` replay of each session as readable lines, fetched
+  # off the main thread, debounced and cached.
+  class Logs
+    DEBOUNCE = 0.25
+    TTL = 10
+    MAX_LINES = 400
+
+    def initialize(client, clock: -> { Time.now })
+      @client = client
+      @clock = clock
+      @cache = {}
+      @mutex = Mutex.new
+      @pending = nil
+      @pending_at = nil
+      @requests = Queue.new
+      @thread = Thread.new { worker }
+      @thread.abort_on_exception = false
+    end
+
+    def cached(id)
+      @mutex.synchronize { @cache[id]&.first }
+    end
+
+    def want(id)
+      return if id.nil?
+      @pending = id
+      @pending_at = @clock.call
+    end
+
+    # Promotes a request that has sat still for DEBOUNCE to the worker,
+    # unless the cache already has a fresh answer.
+    def tick
+      return unless @pending && @clock.call - @pending_at >= DEBOUNCE
+      id = @pending
+      @pending = nil
+      fresh = @mutex.synchronize { (e = @cache[id]) && @clock.call - e[1] < TTL }
+      @requests << id unless fresh
+    end
+
+    def stop = @thread.kill
+
+    private
+
+    def worker
+      loop do
+        id = @requests.pop
+        id = @requests.pop until @requests.empty? # only the latest matters
+        lines = fetch(id)
+        @mutex.synchronize { @cache[id] = [lines, @clock.call] }
+      end
+    end
+
+    def fetch(id)
+      raw = @client.logs(id)
+      return ["(no output available — the session's process is not running)"] if raw.nil?
+      VtScreen.new.feed(raw).lines.last(MAX_LINES)
+    rescue => e
+      ["(logs failed: #{e.message})"]
+    end
+  end
+end

data/lib/claude_inbox/mouse.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module ClaudeInbox
+  # Parses SGR mouse reports ("\e[<Cb;Cx;Cy(M|m)", emitted once App turns on
+  # \e[?1000h\e[?1006h) into clicks and wheel ticks. Pure: no terminal, no
+  # IO. Row/col are the terminal's own 1-based coordinates, so callers can
+  # index straight into what they just painted.
+  module Mouse
+    SEQUENCE = /\e\[<(\d+);(\d+);(\d+)([Mm])/
+
+    Event = Struct.new(:kind, :row, :col)
+
+    # A raw keypress can glue several reports together the same way a fast
+    # "esc gg" glues onto one read (see App#split_keys), so this scans
+    # rather than matching once.
+    def self.events(raw)
+      raw.to_s.scan(SEQUENCE).filter_map do |cb, col, row, type|
+        kind = kind_for(cb.to_i, type)
+        Event.new(kind, row.to_i, col.to_i) if kind
+      end
+    end
+
+    # Bit 6 (0x40) marks a wheel tick, direction in bit 0. Otherwise this is
+    # a button press/release: bits 0-1 give the button (0 = left) and bit 5
+    # (0x20) marks a drag, so 0x23 masks both at once. Only a left click,
+    # released of any drag, counts; middle/right buttons and drags are left
+    # for the terminal's own handling.
+    def self.kind_for(cb, type)
+      return (cb.even? ? :scroll_up : :scroll_down) if cb & 0x40 != 0
+      :click if type == "M" && cb & 0x23 == 0
+    end
+    private_class_method :kind_for
+  end
+end

data/lib/claude_inbox/new_session_form.rb

@@ -0,0 +1,363 @@
+# frozen_string_literal: true
+
+require_relative "agents_client"
+require_relative "images"
+require_relative "settings"
+require_relative "slash_commands"
+require_relative "text"
+require_relative "text_buffer"
+require_relative "theme"
+
+module ClaudeInbox
+  # State and key handling for the "new session" modal. Pure: returns what
+  # happened so the App can act on it. Rendering returns plain lines; the
+  # App wraps them in a box.
+  class NewSessionForm
+    # `value` is a TextBuffer on :text and :multiline fields and the picked
+    # string on :choice ones — `kind` says which.
+    Field = Struct.new(:key, :label, :kind, :value, :choices)
+
+    # "default" stays the internal value so spawn_args leaves the flag off;
+    # the screen shows what that resolves to instead.
+    DEFAULT = "default"
+
+    MENU_ROWS = 6
+
+    def initialize(cwd:, pastel:, theme: Theme.new(enabled: pastel.enabled), home: Dir.home, clipboard: Images.method(:from_clipboard))
+      @p = pastel
+      @theme = theme
+      @home = home
+      @clipboard = clipboard
+      @fields = [
+        Field.new(:prompt, "Prompt", :multiline, TextBuffer.new),
+        Field.new(:name, "Name", :text, TextBuffer.new),
+        Field.new(:cwd, "Directory", :text, TextBuffer.new(cwd.to_s)),
+        Field.new(:model, "Model", :choice, DEFAULT, AgentsClient::MODELS),
+        Field.new(:effort, "Effort", :choice, DEFAULT, AgentsClient::EFFORTS),
+        Field.new(:permission_mode, "Permissions", :choice, DEFAULT, AgentsClient::PERMISSION_MODES),
+        Field.new(:worktree, "Worktree", :choice, "no", %w[no yes])
+      ]
+      @focus = 0
+      @error = nil
+      @defaults_for = nil
+      @commands_for = nil
+      @pick = 0
+      @dismissed = nil
+      @confirm_discard = false
+    end
+
+    def focused = @fields[@focus]
+
+    # => :cancel | :start | :start_and_attach | :changed
+    def press(name, raw)
+      return confirm_discard_press(name, raw) if @confirm_discard
+      @error = nil
+      @candidates = nil
+      return :changed if menu && menu_press(name)
+      before = command_query
+      case name
+      when :escape then return escape_pressed
+      when :ctrl_s then return submit(attach: false)
+      when :ctrl_o then return submit(attach: true)
+      when :ctrl_v then paste_clipboard
+      when :tab then complete_dir || move(1)
+      when :down then move(1)
+      when :back_tab, :up then move(-1)
+      when :return, :enter
+        (focused.kind == :multiline) ? focused.value.insert("\n") : move(1)
+      else
+        editable? ? focused.value.press(name, raw) : choose(name, raw)
+      end
+      edited = before && command_query && command_query != before
+      @pick = 0 if edited
+      @dismissed = nil if edited
+      :changed
+    end
+
+    # A bracketed paste. Empty is how a terminal pastes an image: there is
+    # no text to send, so the clipboard is read directly, the way Claude
+    # Code does on Cmd-V. A dropped file arrives as its path, and an image
+    # becomes a chip in the prompt rather than text.
+    def paste(text)
+      @error = nil
+      text = text.gsub(/\r\n?/, "\n")
+      if text.empty?
+        paste_clipboard
+      elsif focused.key == :prompt && (path = Images.dropped(text))
+        focused.value.attach(path)
+      else
+        insert(text)
+      end
+      :changed
+    end
+
+    def command_query
+      return nil unless focused.key == :prompt
+      focused.value.head[/(?:\A|\s)\/(\S*)\z/, 1]
+    end
+
+    def menu
+      q = command_query
+      return nil if q.nil? || @dismissed == q
+      found = SlashCommands.match(commands, q)
+      found.empty? ? nil : found
+    end
+
+    def picked = menu&.fetch(@pick.clamp(0, menu.size - 1))
+
+    def values
+      @fields.to_h { |f| [f.key, f.value.to_s] }.tap do |v|
+        v[:prompt] = @fields[0].value.expand { |chip| AgentsClient.mention(chip.path) }.strip
+        v[:worktree] = v[:worktree] == "yes"
+        v[:name] = nil if v[:name].strip.empty?
+        v[:cwd] = File.expand_path(v[:cwd].strip.empty? ? "." : v[:cwd].strip)
+      end
+    end
+
+    # Settings resolve against the directory the session will run in, so
+    # they follow the Directory field.
+    def defaults
+      cwd = values[:cwd]
+      return @defaults if @defaults_for == cwd
+      @defaults_for = cwd
+      @defaults = Settings.defaults(cwd, home: @home)
+    end
+
+    # Project commands live under the Directory field's path, so they
+    # follow it as the defaults do.
+    def commands
+      cwd = values[:cwd]
+      return @commands if @commands_for == cwd
+      @commands_for = cwd
+      @commands = SlashCommands.list(cwd: cwd, home: @home)
+    end
+
+    # Full-screen body: a tall prompt editor, then one row per setting with
+    # every choice visible. Exactly `height` lines.
+    def screen(width, height)
+      inner_w = width - 4
+      fixed = 3 + 2 + 1 + (@fields.size - 1) + 1
+      menu_rows = menu_lines(inner_w, [height - fixed - 3, MENU_ROWS].min)
+      prompt_h = [height - fixed - menu_rows.size, 3].max
+      out = [""]
+      out << "  " + (@confirm_discard ? @theme.red("Discard this session? (y/n)") : @p.bold("New session"))
+      out << ""
+      out << "  " + field_label(@fields[0]) + @p.dim("  ⏎ newline")
+      out += prompt_box(@fields[0], inner_w, prompt_h)
+      out += menu_rows
+      out << ""
+      @fields[1..].each { |f| out << "  " + field_label(f) + field_value(f, inner_w - 14) }
+      out.first(height) + [""] * [height - out.size, 0].max
+    end
+
+    def footer
+      if @confirm_discard
+        return [["y", "discard"], ["esc", "keep editing"]]
+            .map { |k, d| @theme.cyan_bold(k) + " " + @p.dim(d) }.join("  ")
+      end
+      return @theme.red(@error) if @error
+      return @p.dim("matches: ") + @candidates.join(@p.dim("  ")) if @candidates
+      if menu
+        return [["↑ ↓", "choose"], ["⇥ ⏎", "pick"], ["esc", "close"]]
+            .map { |k, d| @theme.cyan_bold(k) + " " + @p.dim(d) }.join("  ")
+      end
+      keys =
+        case focused.kind
+        when :multiline then [["⏎", "newline"], ["^V", "image"]]
+        when :choice then [["← → h l", "change"], ["⏎", "next"]]
+        else [["⏎", "next"]]
+        end
+      keys += [["^S", "start"], ["^O", "start & open"],
+        ["⇥", (focused.key == :cwd) ? "complete / next" : "next"], ["esc", "cancel"]]
+      keys.map { |k, d| @theme.cyan_bold(k) + " " + @p.dim(d) }.join("  ")
+    end
+
+    private
+
+    # Esc with a prompt typed asks first, so a stray keypress can't lose it.
+    def escape_pressed
+      return :cancel if @fields[0].value.empty?
+      @confirm_discard = true
+      :changed
+    end
+
+    def confirm_discard_press(name, raw)
+      return :cancel if raw == "y"
+      @confirm_discard = false if name == :escape || raw == "n" || raw == "q"
+      :changed
+    end
+
+    def paste_clipboard
+      clip = @clipboard.call
+      if clip.image
+        return @error = "images go in the prompt" unless focused.key == :prompt
+        focused.value.attach(clip.image)
+      elsif clip.text
+        insert(clip.text)
+      else
+        @error = "nothing on the clipboard"
+      end
+    end
+
+    def insert(text)
+      return unless editable?
+      focused.value.insert((focused.kind == :multiline) ? text : text.tr("\n", " "))
+    end
+
+    def menu_press(name)
+      case name
+      when :up, :ctrl_p then @pick = (@pick - 1) % menu.size
+      when :down, :ctrl_n then @pick = (@pick + 1) % menu.size
+      when :tab, :return, :enter then accept(picked)
+      when :escape then @dismissed = command_query
+      else return false
+      end
+      true
+    end
+
+    def accept(cmd)
+      focused.value.replace_before(command_query.grapheme_clusters.size + 1, "#{cmd} ")
+      @pick = 0
+    end
+
+    # Scrolled so the pick never falls off the bottom; the count of what is
+    # cut rides on the last row rather than costing one of its own.
+    def menu_lines(w, h)
+      items = menu
+      return [] if items.nil? || h <= 0
+      pick = @pick.clamp(0, items.size - 1)
+      first = [pick - h + 1, 0].max
+      shown = items[first, h]
+      left = items.size - first - shown.size
+      more = (left > 0) ? "  +#{left} more" : ""
+      name_w = [shown.map { |c| Text.width(c.to_s) }.max, 36].min
+      rows = shown.each_with_index.map do |c, i|
+        on = first + i == pick
+        name = Text.pad(c.to_s, name_w)
+        tag = (i == shown.size - 1) ? more.size : 0
+        desc = Text.truncate(c.description, w - name_w - 8 - tag)
+        "    " + (on ? @theme.pill(" #{name} ", :cyan) : @theme.cyan(" #{name} ")) + " " + (on ? desc : @p.dim(desc))
+      end
+      rows[-1] = Text.pad(rows[-1], w - more.size) + @p.dim(more)
+      rows
+    end
+
+    def field_label(f)
+      on = f.equal?(focused)
+      (on ? @theme.cyan_bold("▶ ") : "  ") + (on ? @p.bold(Text.pad(f.label, 12)) : @p.dim(Text.pad(f.label, 12)))
+    end
+
+    # The cell the cursor sits on, drawn as a block by inverting it: a bar
+    # between cells would shift everything after it a column to the right.
+    def caret = ->(cell) { @p.inverse(cell) }
+
+    def field_value(f, w)
+      on = f.equal?(focused)
+      if f.kind == :text
+        return f.value.row(w, cursor: caret) if on
+        if f.value.empty?
+          @p.dim((f.key == :name) ? "(none — claude picks one)" : "")
+        else
+          f.value.row(w)
+        end
+      else
+        f.choices.map { |c|
+          text = (c == DEFAULT) ? default_text(f) : c
+          if c == f.value then (on ? @theme.pill(" #{text} ", :cyan) : @theme.cyan_bold(" #{text} "))
+          else @p.dim(" #{text} ")
+          end
+        }.join(" ")
+      end
+    end
+
+    def default_text(f)
+      resolved = defaults[f.key]
+      resolved ? "#{resolved} (settings)" : "auto (cli default)"
+    end
+
+    def prompt_box(f, w, h)
+      on = f.equal?(focused)
+      edge = on ? ->(s) { @theme.cyan(s) } : ->(s) { @p.dim(s) }
+      rows, hidden = f.value.view(w - 4, h, cursor: (caret if on), chip: ->(s) { @theme.cyan_bold(s) })
+      rows = [@p.dim("What should this session do?")] if f.value.empty? && !on
+      rows += [""] * (h - rows.size)
+      [top_edge(edge, w, hidden)] +
+        rows.map { |r| "  " + edge.call("│") + " " + Text.pad(r, w - 4) + " " + edge.call("│") } +
+        ["  " + edge.call("└" + "─" * (w - 2) + "┘")]
+    end
+
+    # How much of a long prompt is scrolled out of sight goes in the top
+    # border, where it can't collide with the text or the cursor.
+    def top_edge(edge, w, hidden)
+      label = (hidden > 0) ? @p.dim(" ↑ #{hidden} more ") : ""
+      "  " + edge.call("┌" + "─" * (w - 2 - Text.width(label))) + label + edge.call("┐")
+    end
+
+    # Tab in the Directory field: extend the path as far as the matching
+    # directories agree, listing them while it is still ambiguous. Returns
+    # nil when the path is already a directory or matches nothing, so the
+    # caller can treat Tab as "next field" instead.
+    def complete_dir
+      return nil unless focused.key == :cwd
+      typed = focused.value.to_s
+      base = File.expand_path(typed.empty? ? "." : typed)
+      listing = typed.empty? || typed.end_with?("/")
+      return nil if !listing && File.directory?(base)
+      matches = Dir.glob(listing ? "#{base}/*" : "#{base}*").select { |d| File.directory?(d) }.sort
+      return nil if matches.empty?
+      if matches.size == 1
+        focused.value.replace("#{matches.first}/")
+      else
+        @candidates = matches.map { |d| File.basename(d) }
+        focused.value.replace(common_prefix(matches))
+      end
+      :changed
+    end
+
+    def common_prefix(paths)
+      first, *rest = paths
+      first.each_char.with_index.reduce("") do |acc, (c, i)|
+        (rest.all? { |o| o[i] == c }) ? acc + c : (break acc)
+      end
+    end
+
+    def editable? = %i[text multiline].include?(focused.kind)
+
+    def move(d) = @focus = (@focus + d) % @fields.size
+
+    # Keys a :choice field answers to; an editable field spends these on its
+    # own text instead.
+    def choose(name, raw)
+      case name
+      when :left then cycle(-1)
+      when :right then cycle(1)
+      else
+        case raw
+        when "h" then cycle(-1)
+        when "l", " " then cycle(1)
+        end
+      end
+    end
+
+    def cycle(d)
+      f = focused
+      return unless f.kind == :choice
+      f.value = f.choices[(f.choices.index(f.value) + d) % f.choices.size]
+    end
+
+    def submit(attach:)
+      v = values
+      if v[:prompt].empty?
+        @error = "a prompt is required"
+        @focus = 0
+        return :changed
+      end
+      unless File.directory?(v[:cwd])
+        @error = "no such directory: #{v[:cwd]}"
+        @focus = 2
+        return :changed
+      end
+      attach ? :start_and_attach : :start
+    end
+  end
+end

data/lib/claude_inbox/palette.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module ClaudeInbox
+  # The eight colors `/color` offers, mapped to the terminal the same way
+  # Claude Code's own tmux code maps them when it tints a teammate pane:
+  # six are plain ansi, and orange and pink have no ansi name so they go
+  # through a 256-color index.
+  #
+  # Closing with 39 (default foreground) rather than 0 (reset everything)
+  # matters: the label is often already bold or italic and a full reset
+  # would strip that back off.
+  class Palette
+    ANSI = {
+      "red" => 31, "green" => 32, "yellow" => 33,
+      "blue" => 34, "purple" => 35, "cyan" => 36
+    }.freeze
+
+    INDEXED = {"orange" => 208, "pink" => 205}.freeze
+
+    RESET = "\e[39m"
+
+    def self.known?(name) = ANSI.key?(name) || INDEXED.key?(name)
+
+    def self.sequence(name)
+      return "\e[#{ANSI[name]}m" if ANSI.key?(name)
+      return "\e[38;5;#{INDEXED[name]}m" if INDEXED.key?(name)
+      nil
+    end
+
+    def initialize(enabled: true)
+      @enabled = enabled
+    end
+
+    def paint(text, name)
+      return text unless @enabled
+      seq = self.class.sequence(name)
+      seq ? seq + text + RESET : text
+    end
+  end
+end