rubino-agent 0.3.0

data/lib/rubino/commands/handlers/help.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module Rubino
+  module Commands
+    module Handlers
+      # The `/help` and `/commands` listings (and the unknown-command
+      # "Available:" roster), extracted from Commands::Executor (batch B). A plain
+      # collaborator given the command `loader` and the `ui` — it owns the
+      # built-in/keys/input reference text and the custom-command discovery copy.
+      class Help
+        def initialize(ui:, loader:)
+          @ui = ui
+          @loader = loader
+        end
+
+        # All known slash commands (built-ins + discovered custom), used for the
+        # "Available:" hint on an unknown command (L6 — previously listed only
+        # custom commands, which is usually empty).
+        def available_commands
+          custom = begin
+            @loader.names
+          rescue StandardError
+            []
+          end
+          (BuiltIns::NAMES + custom).uniq
+        end
+
+        def show_help
+          @ui.info("Slash commands run actions or reusable prompts. Type /<name>; /help is this list.")
+          @ui.blank_line
+          @ui.info("Built-in:")
+          rows  = help_builtin_rows
+          width = rows.map { |name, _| name.length }.max
+          rows.each do |name, desc|
+            @ui.info("  #{name.ljust(width)}  - #{desc}")
+          end
+          @ui.blank_line
+
+          # The `@` file-picker is a discoverable composer feature (type `@` to
+          # autocomplete a workspace file) but was undocumented in /help (F14).
+          # /paste and /clear-images already appear once under "Built-in" above,
+          # so they're NOT repeated here — this section is image/file INPUT only,
+          # no command rows (#87 de-dup).
+          @ui.info("Input:")
+          @ui.info("  ! <command>   - run a shell command yourself, no approval; output joins the context")
+          @ui.info("  @<path>       - autocomplete a workspace file into the prompt")
+          @ui.info("  @<image>      - attach an image (png/jpg/jpeg/gif/webp/bmp) to the turn")
+          @ui.info("  <image path>  - drop or paste an image file path to attach it")
+          @ui.blank_line
+
+          # The keystroke vocabulary was invisible in /help (#87): a newcomer
+          # couldn't learn how to cancel a turn, drive the approval menu, or that
+          # Tab completes. One compact reference line covers it.
+          @ui.info("Keys:")
+          @ui.info("  ↑/↓ + Enter   - choose in the approval menu")
+          @ui.info("  Enter         - send; during a turn, interrupt it and run this next")
+          @ui.info("  Alt-Enter     - queue this to run after the current turn (or /queued <msg>)")
+          @ui.info("  Shift-Tab     - cycle mode (default → plan → yolo)")
+          @ui.info("  Ctrl-O        - reveal the last reasoning (collapsed or hidden)")
+          @ui.info("  Ctrl-C        - cancel the turn (twice to exit)")
+          @ui.info("  Esc Esc       - rewind to an earlier message (fork + edit & resend)")
+          @ui.info("  Tab           - complete the highlighted /command or @file")
+          @ui.info("  /             - start a command;  @  attach a file/image")
+          @ui.blank_line
+
+          custom = @loader.all
+          if custom.any?
+            @ui.info("Custom commands  (run with /<name>; add --preview to see the prompt first):")
+            custom.each do |cmd|
+              @ui.info("  /#{cmd.name}#{custom_desc(cmd)}")
+            end
+          else
+            @ui.info("Custom commands  (none yet — run /commands to learn how to add one)")
+          end
+        end
+
+        def show_commands
+          commands = @loader.all
+          return explain_empty_commands if commands.empty?
+
+          @ui.info("Custom commands  (run with /<name>; add --preview to see the prompt first):")
+          commands.each do |cmd|
+            @ui.info("  /#{cmd.name}#{custom_desc(cmd)}")
+          end
+        end
+
+        private
+
+        # The Built-in rows for /help, with synonyms collapsed so /help never
+        # shows two rows that say the same thing (#87): /exit and /quit share one
+        # "End session" row as "/exit, /quit". Everything else passes through in
+        # the BuiltIns order.
+        def help_builtin_rows
+          rows = []
+          seen = {}
+          BuiltIns::DESCRIPTIONS.each do |name, desc|
+            if (canonical = seen[desc])
+              rows[canonical[:index]][0] = "#{canonical[:name]}, #{name}"
+            else
+              seen[desc] = { index: rows.length, name: name }
+              rows << [name, desc]
+            end
+          end
+          rows
+        end
+
+        # The cryptic old empty-state ("Add .md files to .rubino/commands/")
+        # named a dir without ever explaining what a command IS. Now we explain
+        # the concept, name the REAL configured paths, and show a concrete example.
+        def explain_empty_commands
+          @ui.info("Custom commands are reusable prompts you trigger with a slash. Each is a")
+          @ui.info("Markdown file in a commands directory; the file body becomes the prompt")
+          @ui.info("($ARGUMENTS / $1..$9 expand to what you type after the command).")
+          @ui.blank_line
+          @ui.info("No custom commands found yet.")
+          @ui.blank_line
+          @ui.info("Searched: #{command_dirs.join(", ")}")
+          @ui.info("Create one, e.g. .rubino/commands/review.md:")
+          @ui.blank_line
+          @ui.info("    ---")
+          @ui.info("    description: Review the current diff for bugs")
+          @ui.info("    ---")
+          @ui.info("    Review the staged diff. Flag correctness bugs only. $ARGUMENTS")
+          @ui.blank_line
+          @ui.info("Then run:  /review focus on the auth change")
+        end
+
+        # The directories the loader actually searches, for the empty-state copy.
+        # Resolves through Loader.resolve_path so the "Searched:" line reports the
+        # real paths (RUBINO_HOME-aware), not a literal ~/.rubino never searched.
+        def command_dirs
+          paths = Rubino.configuration.dig("commands", "paths")
+          paths = Rubino::Config::Defaults.to_hash.dig("commands", "paths") if paths.nil?
+          Array(paths).map { |dir| Loader.resolve_path(dir) }
+        rescue StandardError
+          Loader.default_command_paths
+        end
+
+        # "  - <description>" suffix for a custom-command listing, omitted when the
+        # command carries no description so the line stays clean.
+        def custom_desc(cmd)
+          desc = cmd.description.to_s.strip
+          desc.empty? ? "" : "  - #{desc}"
+        end
+      end
+    end
+  end
+end

data/lib/rubino/commands/handlers/jobs.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Rubino
+  module Commands
+    module Handlers
+      # The `/jobs` in-chat window into the PERSISTENT jobs queue (#187),
+      # extracted from Commands::Executor (batch B) — the queue the agent itself
+      # feeds mid-session (DistillSkillJob after tool-heavy turns, memory
+      # extraction), distinct from the in-process /agents subagents. Read-mostly:
+      # `process`/`worker` stay CLI-only (they are daemons, not session actions).
+      #
+      #   /jobs        → status counts + the recent-jobs table (the SAME
+      #                  rendering as `rubino jobs list` — JobsCommand.render_list)
+      #   /jobs <id>   → one job in full (attempts, payload, last error);
+      #                  short-id prefixes resolve, like /memory show
+      class Jobs
+        # Render order for the /jobs counts header (#187) — lifecycle order, not
+        # the arbitrary GROUP BY order (any unknown status is appended).
+        STATUS_ORDER = %w[queued running completed failed dead].freeze
+
+        def initialize(ui:)
+          @ui = ui
+        end
+
+        def handle_jobs(arguments)
+          id = arguments.to_s.strip.split(/\s+/).first
+          id.nil? ? show_jobs_list : show_job_detail(id)
+        end
+
+        private
+
+        def show_jobs_list
+          queue  = Rubino::Jobs::Queue.new
+          counts = queue.counts
+          if counts.empty?
+            @ui.info("No jobs yet — the agent enqueues background work " \
+                     "(skill distillation, memory extraction) as you chat.")
+            return
+          end
+
+          ordered = (STATUS_ORDER & counts.keys) + (counts.keys - STATUS_ORDER)
+          @ui.info(ordered.map { |status| "#{counts[status]} #{status}" }.join("  ·  "))
+          CLI::JobsCommand.render_list(queue.list, ui: @ui)
+          @ui.info("/jobs <id> for detail   ·   `rubino jobs process` runs pending ones now")
+        end
+
+        def show_job_detail(id)
+          job = Rubino::Jobs::Queue.new.find(id)
+          if job.nil?
+            @ui.error("no job with id #{id}.")
+            @ui.info("List them with /jobs")
+            return
+          end
+
+          @ui.info("#{job[:id][0..7]}  #{job[:type]}  ·  #{job[:status]}")
+          @ui.info("  attempts  #{job[:attempts]}/#{job[:max_attempts]}")
+          @ui.info("  run_at    #{job[:run_at]}")
+          @ui.info("  created   #{job[:created_at]}")
+          @ui.info("  payload   #{truncate(job[:payload_json], 200)}")
+          error = job[:last_error].to_s
+          @ui.error(error) unless error.empty?
+        end
+
+        def truncate(text, max)
+          s = text.to_s.gsub(/\s+/, " ").strip
+          s.length > max ? "#{s[0, max - 1]}…" : s
+        end
+      end
+    end
+  end
+end

data/lib/rubino/commands/handlers/mcp.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+require "pastel"
+
+module Rubino
+  module Commands
+    module Handlers
+      # The `/mcp` in-chat management of MCP servers (#182), extracted from
+      # Commands::Executor (batch B). Shaped like /skills:
+      #
+      #   /mcp                 → server list: status, transport, tool count
+      #   /mcp <server>        → drill-in: transport/target, health, its tools
+      #   /mcp <server> off    → stop the client + deregister its tools (session)
+      #   /mcp <server> on     → (re)start the client + register its tools
+      #   /mcp reload          → re-read config.yml and reconnect every server
+      #
+      # List/drill-in read the LIVE booted manager (Rubino::MCP.manager) and
+      # never re-spawn stdio servers — doctor's start/stop dance is wrong inside
+      # a session that already holds clients. `off` is session-scoped, like
+      # /skills activation; persistent disable stays a config edit (mcp.enabled
+      # or removing the server).
+      class MCP
+        def initialize(ui:)
+          @ui = ui
+        end
+
+        def handle_mcp(arguments)
+          server, action = arguments.to_s.strip.split(/\s+/)
+          # reload must work BEFORE the enabled? gate: its whole point is picking
+          # up a config edit (e.g. a first server added mid-session).
+          return reload_mcp if server == "reload"
+
+          unless Rubino::MCP.enabled?
+            show_mcp_empty_state
+            return
+          end
+
+          server.nil? ? show_mcp_list : handle_mcp_server(server, action)
+        end
+
+        private
+
+        # The two empty states the issue calls out: no servers at all vs the
+        # mcp.enabled kill switch.
+        # Empty states are quiet facts, not successes/calls-to-celebrate:
+        # dim, never colored (P8).
+        def show_mcp_empty_state
+          if mcp_servers_config.any?
+            @ui.status("MCP is disabled (mcp.enabled: false in config.yml) — " \
+                       "#{mcp_servers_config.size} server(s) defined but not started.")
+          else
+            @ui.status("No MCP servers configured.")
+            @ui.status("Add an mcp.servers block to config.yml (see docs/mcp.md), then /mcp reload.")
+          end
+        end
+
+        def show_mcp_list
+          mcp_servers_config.each do |name, server_config|
+            tools = mcp_tools_for(name).size
+            @ui.panel_line(name, "(#{server_config["transport"] || "stdio"})  " \
+                                 "#{mcp_status_icon(name)}  ·  #{tools} tool#{"s" if tools != 1}")
+          end
+          @ui.status("/mcp <server> for its tools   ·   /mcp <server> on|off   ·   /mcp reload")
+        end
+
+        def handle_mcp_server(name, action)
+          unless mcp_servers_config.key?(name)
+            @ui.error("unknown MCP server: #{name}")
+            @ui.info("Configured: #{mcp_servers_config.keys.join(", ")}")
+            return
+          end
+
+          case action
+          when nil   then show_mcp_server(name)
+          when "off" then mcp_server_off(name)
+          when "on"  then mcp_server_on(name)
+          else
+            @ui.error("unknown /mcp action: #{action}")
+            @ui.info("Usage: /mcp #{name} [on|off]")
+          end
+        end
+
+        def show_mcp_server(name)
+          server_config = mcp_servers_config[name]
+          transport     = server_config["transport"] || "stdio"
+          target        = if transport == "stdio"
+                            [server_config["command"], *Array(server_config["args"])].join(" ")
+                          else
+                            server_config["url"].to_s
+                          end
+
+          @ui.info("#{name}  #{mcp_status_icon(name)}")
+          @ui.panel_line("transport", "#{transport}  ·  #{target}")
+          last_error = Rubino::MCP.manager&.last_errors&.dig(name)
+          @ui.panel_line("last error", last_error) if last_error
+          show_mcp_server_tools(name)
+        end
+
+        # The server's registered tools (prefixed names + descriptions), wrapped
+        # like the /skills list so long descriptions never hard-break mid-word.
+        def show_mcp_server_tools(name)
+          tools = mcp_tools_for(name)
+          if tools.empty?
+            @ui.info("  tools      (none registered — /mcp #{name} on to start it)")
+            return
+          end
+
+          @ui.info("  tools      #{tools.size}:")
+          tools.each do |tool|
+            wrap_skill_line("    #{tool.name} - ", tool.description.to_s).each { |line| @ui.info(line) }
+          end
+        end
+
+        # Session-scoped disable: stop the client AND drop its wrappers from the
+        # registry (Manager#stop_server deregisters — #182), so the model stops
+        # seeing tools whose client is gone.
+        def mcp_server_off(name)
+          manager = Rubino::MCP.manager
+          if manager.nil? || !manager.clients.key?(name)
+            @ui.info("MCP server #{name} is not running.")
+            return
+          end
+
+          removed = mcp_tools_for(name).size
+          manager.stop_server(name)
+          @ui.success("MCP server #{name} stopped — #{removed} tool#{"s" if removed != 1} removed " \
+                      "for this session (/mcp #{name} on to restart; config untouched).")
+        end
+
+        # (Re)start one server and register its tools. With no booted manager yet
+        # (MCP never enabled at boot, or boot failed), boot! brings the whole
+        # subsystem up — which starts this server too.
+        def mcp_server_on(name)
+          manager = Rubino::MCP.manager || Rubino::MCP.boot!
+          unless manager
+            @ui.error("could not boot MCP — check mcp.servers in config.yml, or /mcp reload")
+            return
+          end
+
+          manager.stop_server(name) if manager.clients.key?(name)
+          # start_server already warned with the failure detail; just point at it.
+          return @ui.error("could not start MCP server #{name} (see warning above)") unless
+            manager.start_server(name, mcp_servers_config[name])
+
+          manager.register_server_tools(name)
+          count = mcp_tools_for(name).size
+          @ui.success("MCP server #{name} started — #{count} tool#{"s" if count != 1} registered.")
+        end
+
+        def reload_mcp
+          manager = Rubino::MCP.reload!
+          if manager.nil?
+            show_mcp_empty_state
+            return
+          end
+
+          @ui.success("MCP reloaded.")
+          show_mcp_list
+        end
+
+        # `<glyph> <word>` for a server's state (colored like agent_status_icon):
+        # green ● reachable, red ✗ down, yellow ◌ not started (no live client).
+        def mcp_status_icon(name)
+          entry = mcp_health.find { |h| h[:name] == name }
+          glyph, word, color =
+            if entry.nil? then ["◌", "not started", :yellow]
+            elsif entry[:alive] then ["●", "reachable", :green]
+            else ["✗", "down", :red]
+            end
+          "#{pastel.public_send(color, glyph)} #{word}"
+        end
+
+        # The configured mcp.servers block (name => config), {} when absent.
+        def mcp_servers_config
+          Rubino.configuration.dig("mcp", "servers") || {}
+        end
+
+        # Live reachability from the booted manager; [] when MCP never booted.
+        # Manager#health_check already rescues per client, so a wedged transport
+        # reports alive: false instead of raising.
+        def mcp_health
+          Rubino::MCP.manager&.health_check || []
+        end
+
+        # The registry wrappers a server contributed (prefixed tools).
+        def mcp_tools_for(server_name)
+          Tools::Registry.all.select do |tool|
+            tool.is_a?(Rubino::MCP::MCPToolWrapper) && tool.server_name == server_name
+          end
+        end
+
+        # Wraps "<head><description>" to the terminal width, breaking only on
+        # whitespace, with continuation lines indented to the description column.
+        def wrap_skill_line(head, description)
+          width = terminal_width
+          indent = " " * head.length
+          avail  = [width - head.length, 20].max
+
+          lines = []
+          current = +""
+          description.split(/\s+/).each do |word|
+            candidate = current.empty? ? word : "#{current} #{word}"
+            if candidate.length > avail && !current.empty?
+              lines << current
+              current = word.dup
+            else
+              current = candidate
+            end
+          end
+          lines << current unless current.empty?
+          lines = [""] if lines.empty?
+
+          lines.each_with_index.map { |line, i| (i.zero? ? head : indent) + line }
+        end
+
+        def pastel
+          @pastel ||= Pastel.new
+        end
+
+        def terminal_width
+          cols = IO.console&.winsize&.last
+          cols&.positive? ? cols : 80
+        rescue StandardError
+          80
+        end
+      end
+    end
+  end
+end

data/lib/rubino/commands/handlers/memory.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+module Rubino
+  module Commands
+    module Handlers
+      # The `/memory` in-chat read/manage view over the *active* memory backend,
+      # extracted from Commands::Executor (batch B) — the same store the agent
+      # loop, the `rubino memory` CLI (#94) and the HTTP `/v1/memory` ops resolve
+      # via `Memory::Backends.build`. The agent's MemoryTool does autonomous
+      # writes; this is the human's window into it.
+      #
+      #   /memory                  → backend + count + recent facts
+      #   /memory --all            → recent facts INCLUDING retired, marked (#184)
+      #   /memory <query>          → substring search over content
+      #   /memory search <query>   → same search, explicit subcommand
+      #   /memory show <id>        → one fact in full, with the temporal chain (#184)
+      #   /memory forget <id>      → delete a fact
+      #   /memory backend          → active + available backends (#184)
+      class Memory
+        def initialize(ui:)
+          @ui = ui
+        end
+
+        def handle_memory(arguments)
+          args = arguments.to_s.strip
+
+          if args.empty?
+            show_memory_summary
+          elsif args == "--all"
+            show_memory_summary(include_retired: true)
+          elsif args.match?(/\Ashow\b/)
+            id = args[/\Ashow\s+(\S+)\z/, 1]
+            id ? show_memory(id) : @ui.info("Usage: /memory show <id>")
+          elsif args.match?(/\Abackend\b/)
+            show_memory_backend(args[/\Abackend\s+(\S+)\z/, 1])
+          elsif args.match?(/\Aforget\b/)
+            id = args[/\Aforget\s+(\S+)\z/, 1]
+            id ? forget_memory(id) : @ui.info("Usage: /memory forget <id>")
+          elsif args.match?(/\Asearch\b/)
+            # `search` is a subcommand token, not a query term (#59): bare
+            # `/memory search` falls back to the summary instead of searching
+            # for the literal word "search".
+            query = args[/\Asearch\s+(.+)\z/, 1]
+            query ? search_memory(query) : show_memory_summary
+          else
+            search_memory(args)
+          end
+        end
+
+        private
+
+        # `/memory show <id>` (#184): a REAL id lookup (the store resolves the
+        # short-id prefix), not a substring search over content — an id used to
+        # match nothing. Rendering (incl. the temporal chain: Retired /
+        # Superseded by) is shared with the `rubino memory show` CLI verb.
+        def show_memory(id)
+          memory = memory_backend.find(id)
+          if memory.nil?
+            @ui.error("no fact with id #{id}.")
+            return
+          end
+
+          CLI::MemoryCommand.render(memory, ui: @ui)
+        end
+
+        # `/memory backend [name]` (#184): shows the active + available
+        # backends in-chat. SWITCHING stays CLI-only on purpose: every consumer
+        # (the lifecycle's retriever/flusher, the memory tool, this executor)
+        # memoizes its built backend, so an in-process flip would leave the live
+        # loop writing to the OLD store while /memory reads the new one — a
+        # half-applied switch. The CLI verb writes config and a restart applies
+        # it everywhere at once.
+        def show_memory_backend(name)
+          CLI::MemoryCommand.render_active_backend(ui: @ui)
+          return unless name
+
+          @ui.info("Switching is CLI-only: run `rubino memory backend #{name}` " \
+                   "(a restart applies it to the whole agent).")
+        end
+
+        def show_memory_summary(include_retired: false)
+          store    = memory_backend
+          backend  = Rubino.configuration.dig("memory", "backend") || Rubino::Memory::Backends::DEFAULT_NAME
+          @ui.info("backend  #{backend}   ·   #{store.count} facts")
+
+          memories = store.list(limit: 10, include_retired: include_retired)
+          if memories.empty?
+            @ui.info("No facts stored yet — the agent records them as it learns about you.")
+            return
+          end
+
+          render_memory_table(memories)
+          @ui.info("/memory <query>   ·   /memory show <id>   ·   /memory forget <id>")
+        end
+
+        def search_memory(query)
+          needle  = query.downcase
+          matches = memory_backend.list(limit: 200)
+                                  .select { |m| m[:content].to_s.downcase.include?(needle) }
+          if matches.empty?
+            @ui.info("No facts matching #{query.inspect}.")
+            return
+          end
+
+          shown = matches.first(20)
+          @ui.info(%(#{shown.length} match#{"es" if shown.length != 1} for #{query.inspect}))
+          # A targeted search must SHOW the matched fact in full — the list-view's
+          # narrow truncation hides exactly the part the user searched for (#85).
+          # Print each match's full content, wrapping to the terminal width.
+          shown.each { |m| render_memory_match(m) }
+          @ui.info("/memory forget <id> to delete one")
+        end
+
+        # One searched fact, content shown end-to-end (wrapped, never truncated).
+        def render_memory_match(memory)
+          head    = "#{memory[:id].to_s[0..7]}  #{memory[:kind]}  "
+          content = memory[:content].to_s.gsub(/\s+/, " ").strip
+          wrap_skill_line(head, content).each { |line| @ui.info(line) }
+        end
+
+        def forget_memory(id)
+          store  = memory_backend
+          memory = store.find(id)
+          if memory.nil?
+            @ui.error("no fact with id #{id}.")
+            return
+          end
+
+          # Destructive, irreversible delete — confirm first, default No (#218).
+          # A piped/Esc/EOF decline must NOT forget the fact.
+          confirmed = @ui.confirm_destructive(
+            %(Forget fact #{memory[:id][0..7]} "#{truncate(memory[:content], 60)}"? This cannot be undone.)
+          )
+          unless confirmed
+            @ui.info("Aborted.")
+            return
+          end
+
+          store.delete(memory[:id])
+          @ui.success(%(Forgot #{memory[:id][0..7]} "#{truncate(memory[:content], 60)}"))
+        end
+
+        # Resolve the *configured* memory backend (default: sqlite tiny-Zep), the
+        # same store the agent loop, the `rubino memory` CLI and the HTTP
+        # `/v1/memory` ops use. The old `Memory::Store.new` was hardwired to the
+        # legacy `:memories` table and ignored `memory.backend`, so in-chat
+        # `/memory` never saw the facts the agent actually persists (#106).
+        def memory_backend
+          @memory_backend ||= Rubino::Memory::Backends.build
+        end
+
+        # The retired tombstone marker is shared with `rubino memory list --all`
+        # (CLI::MemoryCommand.retired_marker) so both surfaces speak one dialect.
+        def render_memory_table(memories)
+          rows = memories.map do |m|
+            [m[:id].to_s[0..7], m[:kind].to_s,
+             "#{truncate(m[:content], 60)}#{CLI::MemoryCommand.retired_marker(m)}"]
+          end
+          @ui.table(headers: %w[ID Kind Content], rows: rows)
+        end
+
+        # Wraps "<head><description>" to the terminal width, breaking only on
+        # whitespace, with continuation lines indented to the description column.
+        def wrap_skill_line(head, description)
+          width = terminal_width
+          indent = " " * head.length
+          avail  = [width - head.length, 20].max
+
+          lines = []
+          current = +""
+          description.split(/\s+/).each do |word|
+            candidate = current.empty? ? word : "#{current} #{word}"
+            if candidate.length > avail && !current.empty?
+              lines << current
+              current = word.dup
+            else
+              current = candidate
+            end
+          end
+          lines << current unless current.empty?
+          lines = [""] if lines.empty?
+
+          lines.each_with_index.map { |line, i| (i.zero? ? head : indent) + line }
+        end
+
+        def truncate(text, max)
+          s = text.to_s.gsub(/\s+/, " ").strip
+          s.length > max ? "#{s[0, max - 1]}…" : s
+        end
+
+        def terminal_width
+          cols = IO.console&.winsize&.last
+          cols&.positive? ? cols : 80
+        rescue StandardError
+          80
+        end
+      end
+    end
+  end
+end