rubino-agent 0.3.0

data/lib/rubino/ui/null.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+module Rubino
+  module UI
+    # Null UI adapter that discards all output.
+    # Used in testing and background job execution
+    # where no terminal output is needed.
+    class Null < Base
+      attr_reader :messages
+
+      def initialize
+        @messages = []
+      end
+
+      def info(message)
+        @messages << { level: :info, message: message }
+      end
+
+      def success(message)
+        @messages << { level: :success, message: message }
+      end
+
+      def warning(message)
+        @messages << { level: :warning, message: message }
+      end
+
+      def error(message)
+        @messages << { level: :error, message: message }
+      end
+
+      def status(message)
+        @messages << { level: :status, message: message }
+      end
+
+      def box_open(*pieces, at: nil, color: nil)
+        @messages << { level: :box_open, pieces: pieces, at: at, color: color }
+      end
+
+      def box_close(*pieces, color: nil)
+        @messages << { level: :box_close, pieces: pieces, color: color }
+      end
+
+      def body(text)
+        @messages << { level: :body, message: text }
+      end
+
+      def assistant_text(text)
+        @messages << { level: :assistant_text, message: text }
+      end
+
+      def note(text)
+        @messages << { level: :note, message: text }
+      end
+
+      def probe_aside(answer)
+        @messages << { level: :probe_aside, message: answer.to_s }
+      end
+
+      def branch_confirmation(new_id:, parent_id:, title:, included_probe:)
+        @messages << {
+          level: :branch_confirmation,
+          message: { new_id: new_id, parent_id: parent_id, title: title,
+                     included_probe: included_probe }
+        }
+      end
+
+      def stream(chunk)
+        # Every adapter yields the common chunk contract:
+        #   { type: :content | :thinking, text: String, message_id: Integer }
+        text = chunk[:text].to_s
+        type = chunk[:type] || :content
+        @messages << { level: :stream, message: text, stream_type: type }
+      end
+
+      def stream_end
+        @messages << { level: :stream_end, message: "" }
+      end
+
+      def replay_user_input(text, at: nil)
+        @messages << { level: :replay_user_input, message: text, at: at }
+      end
+
+      def thinking_started
+        @messages << { level: :thinking_started, message: "" }
+      end
+
+      def thinking_finished
+        @messages << { level: :thinking_finished, message: "" }
+      end
+
+      def table(headers:, rows:)
+        @messages << { level: :table, message: { headers: headers, rows: rows } }
+      end
+
+      def ask(_prompt)
+        nil
+      end
+
+      # No interactive selection off a real terminal; callers fall back to a
+      # non-interactive path (e.g. the static /sessions table + shortcut).
+      def select(_prompt, _choices)
+        nil
+      end
+
+      # `scope:` is part of the shared UI contract (ToolExecutor always
+      # passes it); the Null adapter auto-approves and ignores it.
+      def confirm(_question, scope: nil, **_context)
+        true
+      end
+
+      # Destructive confirm (#218): no human to ask, so fail closed (decline)
+      # — never destroy on the non-interactive Null adapter.
+      def confirm_destructive(_question)
+        false
+      end
+
+      def tool_started(name, arguments: nil, at: nil)
+        @messages << { level: :tool_started, message: name, arguments: arguments, at: at }
+      end
+
+      def tool_finished(name, result: nil)
+        @messages << { level: :tool_finished, message: name }
+      end
+
+      def tool_body(text, kind: :plain)
+        @messages << { level: :tool_body, message: text, kind: kind }
+      end
+
+      def tool_chunk(name, chunk)
+        @messages << { level: :tool_chunk, name: name, chunk: chunk }
+      end
+
+      def compression_started(at: nil)
+        @messages << { level: :compression_started, message: "", at: at }
+      end
+
+      def compression_finished(metadata, at: nil)
+        @messages << { level: :compression_finished, message: metadata, at: at }
+      end
+
+      def job_enqueued(type)
+        @messages << { level: :job_enqueued, message: type }
+      end
+
+      def job_started(type)
+        @messages << { level: :job_started, message: type }
+      end
+
+      def job_finished(type)
+        @messages << { level: :job_finished, message: type }
+      end
+
+      def separator
+        @messages << { level: :separator, message: "" }
+      end
+
+      def blank_line
+        @messages << { level: :blank_line, message: "" }
+      end
+
+      def mode_changed(name, previous: nil)
+        @messages << { level: :mode_changed, message: name, previous: previous }
+      end
+
+      def reasoning_status(mode)
+        @messages << { level: :reasoning_status, message: mode }
+      end
+
+      def reasoning_changed(mode, previous: nil)
+        @messages << { level: :reasoning_changed, message: mode, previous: previous }
+      end
+
+      def think_status(effort)
+        @messages << { level: :think_status, message: effort }
+      end
+
+      def think_changed(effort, previous: nil)
+        @messages << { level: :think_changed, message: effort, previous: previous }
+      end
+
+      def queued(text)
+        @messages << { level: :queued, message: text }
+      end
+
+      def input_injected(text)
+        @messages << { level: :input_injected, message: text }
+      end
+
+      # Resets captured messages (useful between test cases)
+      def reset!
+        @messages = []
+      end
+    end
+  end
+end

data/lib/rubino/ui/paste_store.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Rubino
+  module UI
+    # The per-session PASTE store behind the composer's file-backed paste
+    # pipeline (Hermes-style, two tiers).
+    #
+    # A large bracketed paste does not flood the composer: the body is
+    # registered here and a single compact PLACEHOLDER token —
+    # "[Pasted text #1 +123 lines]" — is inserted into the editable buffer
+    # instead. The token rides the draft like normal text (editable around,
+    # history-recalled, queueable) and is EXPANDED to the full body only at
+    # the message-build seam, where the line leaves the composer for the
+    # agent loop (ChatCommand#run_turn): the model sees everything, while the
+    # transcript echo keeps the placeholder so scrollback stays clean.
+    #
+    # Two tiers, both behind one placeholder shape:
+    #
+    #   * Tier 1 — PLACEHOLDER COLLAPSE: a paste longer than
+    #     `paste.collapse_lines` lines (default 5) is held in memory and the
+    #     token expands to the verbatim body at submit.
+    #   * Tier 2 — FILE OVERFLOW: a paste bigger than
+    #     `paste.file_threshold_tokens` (default 8000, estimated at the same
+    #     chars/4 rule Context::TokenBudget uses) is written to a session-
+    #     scoped file — <RUBINO_HOME>/sessions/<id>/paste_N.txt — and the
+    #     token expands to a one-line pointer telling the model to read the
+    #     file with the read tool. The home sessions dir is where session
+    #     artifacts already live, it never pollutes the workspace tree, and
+    #     the read tool is deliberately un-sandboxed (only WRITES are gated
+    #     by Workspace roots), so the model can read it from any cwd.
+    #
+    # Lifecycle: a tier-1 body is consumed when its token is expanded into an
+    # outgoing message (re-submitting the line from history later leaves the
+    # literal placeholder, matching Hermes); tier-2 files persist for the
+    # session so the model can re-read them in later turns. Pastes at or
+    # under the collapse threshold never reach the store — they inline into
+    # the buffer exactly as before.
+    class PasteStore
+      # The placeholder shape, shared with the CompletionSource highlight and
+      # the composer's whole-token backspace.
+      TOKEN_RE = /\[Pasted text #\d+ \+\d+ lines\]/
+
+      # Built-in fallbacks when config is missing/garbage.
+      DEFAULT_COLLAPSE_LINES   = 5
+      DEFAULT_THRESHOLD_TOKENS = 8000
+
+      # @param config [Config::Configuration, nil] resolved lazily from
+      #   Rubino.configuration when nil, so a long-lived store follows config
+      #   reloads.
+      # @param session_source [#call, String, nil] the session id the tier-2
+      #   files are scoped under. A callable is resolved at WRITE time, so the
+      #   chat loop can hand a closure over its (re-assignable) runner and
+      #   /new //sessions //branch swaps are honored without re-wiring.
+      def initialize(config: nil, session_source: nil)
+        @config         = config
+        @session_source = session_source
+        @entries        = {} # placeholder token => expansion text
+        @counter        = 0
+      end
+
+      # Late wiring for the session scope (see #initialize) — the chat command
+      # builds the store before the runner exists.
+      attr_writer :session_source
+
+      # True when +body+ should collapse to a placeholder instead of inlining:
+      # strictly more lines than paste.collapse_lines.
+      def collapse?(body)
+        body.to_s.lines.length > collapse_lines
+      end
+
+      # Registers a pasted +body+ and returns the placeholder token to insert
+      # into the buffer. Oversized bodies (tier 2) are written to the session
+      # paste file here, at paste time; their token expands to the file
+      # pointer instead of the content.
+      def register(body)
+        body  = body.to_s
+        n     = (@counter += 1)
+        token = "[Pasted text ##{n} +#{body.lines.length} lines]"
+        @entries[token] = oversize?(body) ? overflow_to_file(n, body) : body
+        token
+      end
+
+      # Expands every registered placeholder in +text+ to its stored body
+      # (tier 1) or file pointer (tier 2) — the message-build seam. Consumed
+      # entries are dropped ("cleared on submit"); unknown placeholder-shaped
+      # text is left verbatim, so user-typed literals are never rewritten.
+      def expand(text)
+        return text unless text.is_a?(String) && @entries.keys.any? { |t| text.include?(t) }
+
+        text.gsub(TOKEN_RE) { |token| @entries.delete(token) || token }
+      end
+
+      # The registered [token, body] pairs whose placeholder appears in +text+,
+      # CONSUMING them like #expand does (re-submitting from history later leaves
+      # the literal placeholder). Returned as an array of pairs so the tokens
+      # survive JSON round-trips intact (a token is not a valid symbol key).
+      # Empty array when +text+ carries no live placeholder.
+      def expansions_in(text)
+        return [] unless text.is_a?(String)
+
+        text.scan(TOKEN_RE).uniq.filter_map do |token|
+          body = @entries.delete(token)
+          [token, body] if body
+        end
+      end
+
+      # The [start, length] (codepoint) span of the registered placeholder
+      # covering the char just BEFORE +cursor+ in +buffer+, or nil. The
+      # composer's backspace uses it to delete a placeholder WHOLE — a
+      # half-eaten token would neither read nor expand. Only spans the store
+      # actually registered qualify; lookalike text the user typed is edited
+      # char-by-char as usual.
+      def placeholder_span(buffer, cursor)
+        return nil if @entries.empty? || buffer.nil?
+
+        pos = 0
+        while (m = TOKEN_RE.match(buffer, pos))
+          start  = m.begin(0)
+          length = m[0].length
+          return [start, length] if @entries.key?(m[0]) && cursor > start && cursor <= start + length
+
+          pos = start + length
+        end
+        nil
+      end
+
+      private
+
+      def collapse_lines
+        positive(config&.paste_collapse_lines) || DEFAULT_COLLAPSE_LINES
+      end
+
+      def threshold_tokens
+        positive(config&.paste_file_threshold_tokens) || DEFAULT_THRESHOLD_TOKENS
+      end
+
+      # Tier-2 gate: the same chars/4 estimate compaction runs on
+      # (Context::TokenBudget::CHARS_PER_TOKEN), so "a context share" here and
+      # the status bar / compactor agree on what a token is.
+      def oversize?(body)
+        (body.length / Context::TokenBudget::CHARS_PER_TOKEN) > threshold_tokens
+      end
+
+      # Write the oversized body to <home>/sessions/<id>/paste_N.txt and
+      # return the pointer line its token expands to. Best-effort: if the
+      # write fails for any reason the body is kept in memory (tier-1
+      # behavior) — a paste must never be lost to a disk hiccup.
+      def overflow_to_file(num, body)
+        dir = session_dir
+        FileUtils.mkdir_p(dir)
+        path = File.join(dir, "paste_#{num}.txt")
+        File.write(path, body)
+        "[Pasted text ##{num} saved to #{path} — too large to inline; read it with the read tool]"
+      rescue StandardError
+        body
+      end
+
+      def session_dir
+        id = @session_source.respond_to?(:call) ? @session_source.call : @session_source
+        id = "pastes-#{Process.pid}" if id.nil? || id.to_s.empty?
+        File.join(Rubino.home_path, "sessions", id.to_s)
+      end
+
+      def config
+        @config || Rubino.configuration
+      end
+
+      def positive(value)
+        v = value.to_i
+        v.positive? ? v : nil
+      end
+    end
+  end
+end

data/lib/rubino/ui/printer_base.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "pastel"
+
+module Rubino
+  module UI
+    # Shared printing behaviour for terminal-based UI adapters.
+    #
+    # Subclasses must implement #color_for(role) returning a Pastel method name
+    # (e.g. :cyan, :green) so that message formatting stays here while each
+    # adapter controls its own color scheme.
+    class PrinterBase < Base
+      def initialize
+        @pastel = Pastel.new
+      end
+
+      def info(message)    = puts_colored(color_for(:info), message)
+      def success(message) = puts_colored(color_for(:success), "✓ #{message}")
+      def warning(message) = puts_colored(color_for(:warning), "⚠ #{message}")
+      def error(message)   = puts_colored(color_for(:error),   "✗ #{message}")
+      def status(message)  = puts_colored(color_for(:status),  message)
+
+      def stream(chunk)
+        text = chunk[:text].to_s
+        $stdout.print text
+        $stdout.flush
+      end
+
+      def stream_end
+        $stdout.puts
+      end
+
+      def tool_started(name, arguments: nil, at: nil)
+        puts_colored(color_for(:tool), "  → Running tool: #{name}")
+      end
+
+      def tool_finished(name, result: nil)
+        suffix = result ? " (#{result.truncated_preview})" : ""
+        puts_colored(color_for(:tool), "  ← #{name} done#{suffix}")
+      end
+
+      def compression_started(at: nil)
+        puts_colored(color_for(:muted), "  ⟳ Compacting context...")
+      end
+
+      def compression_finished(metadata, at: nil)
+        saved = metadata[:saved_tokens] || 0
+        puts_colored(color_for(:muted), "  ⟳ Context compacted (saved #{saved} tokens)")
+      end
+
+      def job_enqueued(_type) = nil
+      def job_started(_type)  = nil
+      def job_finished(_type) = nil
+
+      def blank_line = $stdout.puts
+
+      # Default fallback. CLI overrides to render the
+      # `┄ HH:MM · mode → plan ┄` free-line variant.
+      def mode_changed(name, previous: nil)
+        arrow = previous && previous != name ? " #{previous} → #{name}" : " #{name}"
+        puts_colored(color_for(:muted), "  ⟳ mode#{arrow}")
+      end
+
+      private
+
+      # Subclasses override to map a semantic role to a Pastel method symbol.
+      # @param role [Symbol] e.g. :info, :success, :warning, :error, :tool, :muted
+      # @return [Symbol, nil] Pastel method name, or nil to skip coloring
+      def color_for(_role)
+        nil
+      end
+
+      def puts_colored(color, text)
+        line = color ? @pastel.send(color, text) : text
+        $stdout.puts line
+      end
+    end
+  end
+end

data/lib/rubino/ui/probe_wait_indicator.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative "bottom_composer"
+
+module Rubino
+  module UI
+    # The /probe (#58) and /agents probe (#146) wait indicator: reuse the UI's
+    # thinking-row machinery (UI::CLI) while a billed ephemeral peek runs, and
+    # stay silent on Null/API adapters or piped stdout. Mixed into both the
+    # CLI::ChatCommand and Commands::Executor probe paths, which carried a
+    # byte-identical pair of guards.
+    #
+    # The peek is SYNCHRONOUS (seconds of model wait) and runs at the idle REPL
+    # with no live composer, so keystrokes typed during it used to smear onto the
+    # thinking row — there was no `❯` to echo into (#221). To own input the same
+    # way a streaming turn does, the wait now runs under a transient bottom
+    # composer: it draws a real `❯`, its reader thread buffers keystrokes, and
+    # the thinking ticker paints into its transient row via #set_partial (the
+    # #169 seam) instead of colliding with the input. Anything typed is recovered
+    # into the next idle prompt's draft, so input is never lost.
+    module ProbeWaitIndicator
+      def probe_thinking_started(ui)
+        return unless $stdout.tty? && ui.respond_to?(:thinking_started)
+
+        # Own the bottom of the screen for the wait so typed input lands in a
+        # visible `❯` instead of smearing onto the ticker row (#221). Started
+        # BEFORE the ticker so #thinking_started paints into the composer's
+        # transient row. A standalone editor (no completion/history wiring) — it
+        # only needs to echo input and host the ticker. Best-effort: a terminal
+        # that can't host a raw composer (no real device, sized double) just
+        # keeps the old ticker-only wait — never break the probe.
+        @probe_composer = build_probe_composer
+        ui.thinking_started
+      end
+
+      def probe_thinking_finished(ui)
+        ui.thinking_finished if ui.respond_to?(:thinking_finished)
+        composer = @probe_composer
+        @probe_composer = nil
+        return unless composer
+
+        # Hand whatever the user typed during the wait to the next idle prompt as
+        # a draft, so the buffered text reappears in `❯` after the peek (no data
+        # loss). Read the buffer before #stop tears the composer down and
+        # restores cooked mode + a clean line. Best-effort: tearing down a
+        # degraded composer must never break the probe (mirrors the start guard).
+        typed = begin
+          composer.buffer.dup
+        rescue StandardError
+          nil
+        end
+        begin
+          composer.stop
+        rescue StandardError
+          nil
+        end
+        ui.stash_probe_draft(typed) if typed && !typed.empty? && ui.respond_to?(:stash_probe_draft)
+      end
+
+      private
+
+      # Builds and starts the transient probe composer, or nil when the terminal
+      # can't host a raw input reader (no real stdin/stdout device — piped, or a
+      # test double). Best-effort: a failed start degrades to the old ticker-only
+      # wait rather than breaking the probe.
+      def build_probe_composer
+        return nil unless $stdin.respond_to?(:tty?) && $stdin.tty?
+
+        BottomComposer.new(input_queue: [], echo: :prompt).start
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/rubino/ui/queued_indicators.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "pastel"
+
+module Rubino
+  module UI
+    # The {BottomComposer}'s stack of EXPLICITLY-queued messages (Alt+Enter /
+    # "/queued <msg>") awaiting their turn, rendered as live "⏳ queued: <msg>"
+    # rows above the input — never committed to scrollback. Wraps the list the
+    # chat loop SHARES across the per-turn composers, so the indicator survives
+    # a composer teardown and is removed (and the item committed as a normal
+    # message) when the queued item's turn runs. Pure state + row formatting:
+    # the composer owns the render mutex and the redraw around every mutation.
+    class QueuedIndicators
+      # Hard cap on the visible rows so a burst of explicit queues can never
+      # push the prompt off-screen. Beyond the cap, a dim count row stands in
+      # for the overflow.
+      MAX_ROWS = 4
+
+      # @param list [Array<String>] the shared (or private) pending stack.
+      def initialize(list)
+        @list = list
+      end
+
+      def any?
+        @list.any?
+      end
+
+      # Add +msg+ to the pending stack. +front+ jumps the queue (the
+      # interrupt-by-default Enter): its indicator leads the pending rows so
+      # the visible order matches the run order (#129).
+      def push(msg, front: false)
+        front ? @list.unshift(msg) : @list.push(msg)
+      end
+
+      # Remove the FIRST pending indicator matching +msg+ (the chat loop calls
+      # through when the queued item's turn starts). Returns the removed
+      # message, or nil when none matched.
+      def remove(msg)
+        idx = @list.index(msg)
+        return unless idx
+
+        @list.delete_at(idx)
+      end
+
+      # The "⏳ queued: <msg>" indicator rows for the pending stack, in
+      # submission order. House grammar: the ⏳ glyph, dim. Capped to MAX_ROWS
+      # with a dim "┄ +N more queued ┄" overflow row.
+      def rows
+        return [] if @list.empty?
+
+        shown = @list.first(MAX_ROWS)
+        rows = shown.map { |msg| pastel.dim("⏳ queued: #{msg}") }
+        overflow = @list.size - shown.size
+        rows << pastel.dim("┄ +#{overflow} more queued ┄") if overflow.positive?
+        rows
+      end
+
+      private
+
+      def pastel
+        @pastel ||= Pastel.new
+      end
+    end
+  end
+end

data/lib/rubino/ui/status_bar.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require "pastel"
+
+module Rubino
+  module UI
+    # Formats the dim one-line status bar the {BottomComposer} renders BELOW
+    # the pinned input row:
+    #
+    #   default · minimax-m3 · ctx ~8.4k/64k (13%)
+    #
+    # Content: the session MODE leads (the prompt chip moved here in the
+    # Rail-rubino redesign — the prompt is a constant "▍❯ "), then the
+    # optional branch / active-skill tokens, the resolved model id and the
+    # context saturation — the SAME estimate the compaction logic runs on
+    # (Context::TokenBudget: chars/4 over the session messages, window from
+    # `model.context_length` / `context.max_tokens` with the TokenBudget
+    # default). The caller passes the values; this module only formats. ONE
+    # encoding of the saturation (P9): the used/window pair, with the
+    # percentage in parentheses — omitted entirely below 1% so a fresh
+    # session doesn't carry a "(0%)". With no usable window the bar degrades
+    # to `~8.4k tok`.
+    #
+    # Color: everything dim, except the mode token when it carries risk
+    # (plan yellow, yolo red — subtle, no bold) and the percentage when high
+    # — yellow ≥ 70%, red ≥ 90% — matching the existing pastel usage. Each
+    # segment is styled SEPARATELY (never a colored span nested inside one
+    # dim span) so a colored reset can't strip the dim from the rest of the
+    # line. The single leading space tucks the bar one column in, under the
+    # input rail.
+    module StatusBar
+      WARN_PCT = 70
+      CRIT_PCT = 90
+
+      module_function
+
+      # The styled status line. +chips+ carries the leading session-context
+      # tokens — :mode (the mode token shown FIRST; plan/yolo carry their
+      # accent), :branch (the short id after a `/branch` fork) and :skill
+      # (the active skill, rendered "skill <name>") — each omitted when
+      # nil/absent, so callers without that context get the bare
+      # model-and-ctx bar. +tokens+ is the estimated tokens in the
+      # conversation; +window+ the model's context window (nil/0 ⇒ unknown,
+      # percentage omitted). Returns a string ready to draw (leading indent
+      # included) — the composer clamps/omits it per terminal width.
+      def render(model:, tokens:, window: nil, chips: {}, pastel: Pastel.new)
+        segments = chip_segments(chips, pastel)
+        segments << pastel.dim(model.to_s)
+        if window.to_i.positive?
+          pct = (tokens.to_i * 100.0 / window.to_i).round
+          ctx = pastel.dim("ctx ~#{abbreviate(tokens)}/#{abbreviate(window)}")
+          ctx += " #{pastel.dim("(")}#{percent_segment(pct, pastel)}#{pastel.dim(")")}" if pct >= 1
+          segments << ctx
+        else
+          segments << pastel.dim("~#{abbreviate(tokens)} tok")
+        end
+        " #{segments.join(pastel.dim(" · "))}"
+      end
+
+      # The leading session-context segments, in fixed order: mode, branch,
+      # skill (each omitted when absent). The mode token is dim for default
+      # and carries a subtle color accent when the mode carries risk — plan
+      # yellow, yolo red (the same red as the input rail's brand accent).
+      def chip_segments(chips, pastel)
+        segments = []
+        segments << mode_segment(chips[:mode], pastel) if chips[:mode]
+        segments << pastel.dim("branch:#{chips[:branch]}") if chips[:branch]
+        segments << pastel.dim("skill #{chips[:skill]}") if chips[:skill]
+        segments
+      end
+
+      def mode_segment(mode, pastel)
+        case mode.to_s
+        when "plan" then pastel.yellow("plan")
+        when "yolo" then pastel.red("yolo")
+        else pastel.dim(mode.to_s)
+        end
+      end
+
+      # The "<pct>%" segment: dim normally, yellow from WARN_PCT, red from
+      # CRIT_PCT — the at-a-glance compaction warning.
+      def percent_segment(pct, pastel)
+        text = "#{pct}%"
+        return pastel.red(text) if pct >= CRIT_PCT
+        return pastel.yellow(text) if pct >= WARN_PCT
+
+        pastel.dim(text)
+      end
+
+      # Human token count: 842 → "842", 8421 → "8.4k", 128_000 → "128k".
+      def abbreviate(count)
+        n = count.to_i
+        return n.to_s if n < 1000
+
+        k = n / 1000.0
+        k >= 100 ? "#{k.round}k" : format("%.1fk", k).sub(".0k", "k")
+      end
+    end
+  end
+end