anima-core 1.0.2 → 1.1.1

data/lib/tui/app.rb

@@ -4,6 +4,7 @@ require "time"
 require_relative "cable_client"
 require_relative "input_buffer"
 require_relative "message_store"
+require_relative "performance_logger"
 require_relative "screens/chat"
 
 module TUI
@@ -12,6 +13,7 @@ module TUI
 
     COMMAND_KEYS = {
       "a" => :anthropic_token,
+      "h" => :toggle_hud,
       "n" => :new_session,
       "s" => :session_picker,
       "v" => :view_mode,
@@ -21,7 +23,8 @@ module TUI
     MENU_LABELS = (COMMAND_KEYS.map { |key, action| "[#{key}] #{action.to_s.tr("_", " ").capitalize}" } +
       ["[\u2191] Scroll chat", "[\u2193] Return to input"]).freeze
 
-    SIDEBAR_WIDTH = 28
+    # HUD occupies 1/3 of screen width, clamped to a usable minimum.
+    HUD_MIN_WIDTH = 24
 
     # Picker entry prefix width: "[N]" (3) + marker (1) + space (1) = 5
     PICKER_PREFIX_WIDTH = 5
@@ -77,14 +80,20 @@ module TUI
 
     attr_reader :current_screen, :command_mode, :session_picker_active,
       :view_mode_picker_active
+    # @return [Boolean] true when the HUD info panel is visible
+    attr_reader :hud_visible
     # @return [Boolean] true when the token setup popup overlay is visible
     attr_reader :token_setup_active
     # @return [Boolean] true when graceful shutdown has been requested via signal
     attr_reader :shutdown_requested
+    # @return [TUI::PerformanceLogger] frame timing logger (no-op when debug is off)
+    attr_reader :perf_logger
 
     # @param cable_client [TUI::CableClient] WebSocket client connected to the brain
-    def initialize(cable_client:)
+    # @param debug [Boolean] enable performance logging to log/tui_performance.log
+    def initialize(cable_client:, debug: false)
       @cable_client = cable_client
+      @perf_logger = PerformanceLogger.new(enabled: debug)
       @current_screen = :chat
       @command_mode = false
       @session_picker_active = false
@@ -92,17 +101,19 @@ module TUI
       @session_picker_page = 0
       @session_picker_mode = :root
       @session_picker_parent_id = nil
+      @hud_visible = true
       @view_mode_picker_active = false
       @view_mode_picker_index = 0
       @token_setup_active = false
       @token_input_buffer = InputBuffer.new
       @token_setup_error = nil
+      @token_setup_warning = nil
       @token_setup_status = :idle
       @shutdown_requested = false
       @previous_signal_handlers = {}
       @watchdog_thread = nil
       @screens = {
-        chat: Screens::Chat.new(cable_client: cable_client)
+        chat: Screens::Chat.new(cable_client: cable_client, perf_logger: @perf_logger)
       }
     end
 
@@ -130,20 +141,31 @@ module TUI
     private
 
     def render(frame, tui)
-      content_area, sidebar = tui.split(
-        frame.area,
-        direction: :horizontal,
-        constraints: [
-          tui.constraint_fill(1),
-          tui.constraint_length(SIDEBAR_WIDTH)
-        ]
-      )
+      @perf_logger.start_frame
+
+      @screens[:chat].hud_hint = !@hud_visible
+
+      if @hud_visible
+        hud_width = [frame.area.width / 3, HUD_MIN_WIDTH].max
+        content_area, sidebar = tui.split(
+          frame.area,
+          direction: :horizontal,
+          constraints: [
+            tui.constraint_fill(1),
+            tui.constraint_length(hud_width)
+          ]
+        )
 
-      @screens[@current_screen].render(frame, content_area, tui)
-      render_sidebar(frame, sidebar, tui)
+        @perf_logger.measure(:chat_render) { @screens[@current_screen].render(frame, content_area, tui) }
+        @perf_logger.measure(:sidebar) { render_sidebar(frame, sidebar, tui) }
+      else
+        @perf_logger.measure(:chat_render) { @screens[@current_screen].render(frame, frame.area, tui) }
+      end
 
       check_token_setup_signals
       render_token_setup_popup(frame, frame.area, tui) if @token_setup_active
+
+      @perf_logger.end_frame
     end
 
     def render_sidebar(frame, area, tui)
@@ -171,10 +193,73 @@ module TUI
       frame.render_widget(menu, area)
     end
 
+    # HUD status icons for goal progress and sub-agent activity.
+    GOAL_ICON_ACTIVE = "\u25CF"       # ●
+    GOAL_ICON_IN_PROGRESS = "\u25D0"  # ◐
+    GOAL_ICON_COMPLETED = "\u2713"    # ✓
+    CHILD_ICON_RUNNING = "\u25CF"     # ●
+    CHILD_ICON_IDLE = "\u25CC"        # ◌
+
     def render_info(frame, area, tui)
       session = @screens[:chat].session_info
-      view_mode = @screens[:chat].view_mode
 
+      # Split into main content area and bottom status bar
+      main_area, status_area = tui.split(
+        area,
+        direction: :vertical,
+        constraints: [
+          tui.constraint_fill(1),
+          tui.constraint_length(3)
+        ]
+      )
+
+      render_hud_content(frame, main_area, tui, session)
+      render_hud_status_bar(frame, status_area, tui)
+    end
+
+    # Renders the main HUD content: session name, goals, skills,
+    # workflow, and sub-agents.
+    def render_hud_content(frame, area, tui, session)
+      session_label = session[:name] || "##{session[:id]}"
+
+      lines = [
+        tui.line(spans: [
+          tui.span(content: "\u{1F4CB} ", style: tui.style(fg: "dark_gray")),
+          tui.span(content: session_label, style: tui.style(fg: "cyan", modifiers: [:bold]))
+        ]),
+        hud_goals_section(tui, session),
+        hud_skills_line(tui, session),
+        hud_workflow_line(tui, session),
+        hud_children_section(tui, session),
+        interaction_state_line(tui)
+      ].flatten.compact
+
+      content = tui.paragraph(
+        text: lines,
+        wrap: true,
+        block: tui.block(
+          borders: [:left, :top, :right],
+          border_type: :rounded,
+          border_style: {fg: "white"}
+        )
+      )
+      frame.render_widget(content, area)
+    end
+
+    # Renders the bottom status bar: connection state and model name.
+    def render_hud_status_bar(frame, area, tui)
+      cable_status = @cable_client.status
+      style = STATUS_STYLES.fetch(cable_status, STATUS_STYLES[:disconnected])
+
+      status_label = if cable_status == :reconnecting
+        attempt = @cable_client.reconnect_attempt
+        max = CableClient::MAX_RECONNECT_ATTEMPTS
+        "#{style[:label]} (#{attempt}/#{max})"
+      else
+        style[:label]
+      end
+
+      view_mode = @screens[:chat].view_mode
       mode_label = view_mode.capitalize
       mode_color = case view_mode
       when "verbose" then "yellow"
@@ -182,110 +267,133 @@ module TUI
       else "cyan"
       end
 
-      session_label = session[:name] || "##{session[:id]}"
-
-      lines = [
-        tui.line(spans: [
-          tui.span(content: "Anima v#{Anima::VERSION}", style: tui.style(fg: "white"))
-        ]),
-        tui.line(spans: [tui.span(content: "")]),
-        if session[:name]
-          tui.line(spans: [
-            tui.span(content: session_label, style: tui.style(fg: "cyan", modifiers: [:bold]))
-          ])
-        else
+      bar = tui.paragraph(
+        text: [
           tui.line(spans: [
-            tui.span(content: "Session ", style: tui.style(fg: "dark_gray")),
-            tui.span(content: session_label, style: tui.style(fg: "cyan", modifiers: [:bold]))
+            tui.span(content: status_label, style: tui.style(fg: style[:color], modifiers: [:bold])),
+            tui.span(content: " \u2502 ", style: tui.style(fg: "dark_gray")),
+            tui.span(content: mode_label, style: tui.style(fg: mode_color, modifiers: [:bold]))
           ])
-        end,
-        tui.line(spans: [
-          tui.span(content: "Messages ", style: tui.style(fg: "dark_gray")),
-          tui.span(content: session[:message_count].to_s, style: tui.style(fg: "cyan"))
-        ]),
-        active_skills_line(tui, session),
-        active_workflow_line(tui, session),
-        goals_line(tui, session),
-        tui.line(spans: [tui.span(content: "")]),
-        tui.line(spans: [
-          tui.span(content: "Mode ", style: tui.style(fg: "dark_gray")),
-          tui.span(content: mode_label, style: tui.style(fg: mode_color, modifiers: [:bold]))
-        ]),
-        interaction_state_line(tui),
-        tui.line(spans: [tui.span(content: "")]),
-        connection_status_line(tui),
-        tui.line(spans: [tui.span(content: "")]),
-        tui.line(spans: [
-          tui.span(content: "Ctrl+a", style: tui.style(fg: "cyan", modifiers: [:bold])),
-          tui.span(content: " command mode", style: tui.style(fg: "dark_gray"))
-        ])
-      ].compact
-
-      info = tui.paragraph(
-        text: lines,
+        ],
         block: tui.block(
-          title: "Info",
-          borders: [:all],
+          borders: [:left, :bottom, :right],
           border_type: :rounded,
           border_style: {fg: "white"}
         )
       )
-      frame.render_widget(info, area)
+      frame.render_widget(bar, area)
+    end
+
+    # Builds goal lines with status icons and descriptions.
+    # Root goals show as individual lines. A root goal with some completed
+    # sub-goals shows the ◐ (in-progress) icon.
+    #
+    # @return [Array<RatatuiRuby::Widgets::Line>, nil]
+    def hud_goals_section(tui, session)
+      goal_list = session[:goals]
+      return if goal_list.nil? || goal_list.empty?
+
+      lines = [
+        tui.line(spans: [tui.span(content: "")]),
+        tui.line(spans: [
+          tui.span(content: "\u{1F3AF} Goals", style: tui.style(fg: "dark_gray"))
+        ])
+      ]
+
+      goal_list.each do |goal|
+        icon, color = goal_icon_and_color(goal)
+        lines << tui.line(spans: [
+          tui.span(content: "  #{icon} ", style: tui.style(fg: color)),
+          tui.span(content: goal["description"].to_s, style: tui.style(fg: "white"))
+        ])
+      end
+
+      lines
     end
 
-    # Builds the active skills line for the info panel.
-    # Returns nil when no skills are active so the line is hidden entirely.
-    # @param tui [RatatuiRuby] TUI rendering context
-    # @param session [Hash] session info hash containing :active_skills array
-    # @return [RatatuiRuby::Widgets::Line, nil] styled skills line, or nil when empty
-    def active_skills_line(tui, session)
+    # Returns the status icon and color for a goal.
+    # Active goals with some completed sub-goals show as in-progress (◐).
+    #
+    # @param goal [Hash] goal data with "status" and optional "sub_goals" keys
+    # @return [Array(String, String)] icon and color pair
+    def goal_icon_and_color(goal)
+      if goal["status"] == "completed"
+        [GOAL_ICON_COMPLETED, "green"]
+      elsif goal["sub_goals"]&.any? { |sg| sg["status"] == "completed" }
+        [GOAL_ICON_IN_PROGRESS, "yellow"]
+      else
+        [GOAL_ICON_ACTIVE, "cyan"]
+      end
+    end
+
+    # Builds the skills line with brain emoji.
+    # @return [Array<RatatuiRuby::Widgets::Line>, nil]
+    def hud_skills_line(tui, session)
       skills = session[:active_skills]
       return if skills.nil? || skills.empty?
 
-      label = skills.join(", ")
-      tui.line(spans: [
-        tui.span(content: "\u{1F4DA} ", style: tui.style(fg: "dark_gray")),
-        tui.span(content: label, style: tui.style(fg: "yellow"))
-      ])
+      [
+        tui.line(spans: [tui.span(content: "")]),
+        tui.line(spans: [
+          tui.span(content: "\u{1F9E0} ", style: tui.style(fg: "dark_gray")),
+          tui.span(content: skills.join(", "), style: tui.style(fg: "yellow"))
+        ])
+      ]
     end
 
-    # Builds the active workflow line for the info panel.
-    # Returns nil when no workflow is active so the line is hidden entirely.
-    # @param tui [RatatuiRuby] TUI rendering context
-    # @param session [Hash] session info hash containing :active_workflow string
-    # @return [RatatuiRuby::Widgets::Line, nil] styled workflow line, or nil when empty
-    def active_workflow_line(tui, session)
+    # Builds the workflow line with scroll emoji.
+    # @return [Array<RatatuiRuby::Widgets::Line>, nil]
+    def hud_workflow_line(tui, session)
       workflow = session[:active_workflow]
       return if workflow.nil? || workflow.empty?
 
-      tui.line(spans: [
-        tui.span(content: "\u{1F504} ", style: tui.style(fg: "dark_gray")),
-        tui.span(content: workflow, style: tui.style(fg: "magenta"))
-      ])
+      [
+        tui.line(spans: [tui.span(content: "")]),
+        tui.line(spans: [
+          tui.span(content: "\u{1F4DC} ", style: tui.style(fg: "dark_gray")),
+          tui.span(content: workflow, style: tui.style(fg: "magenta"))
+        ])
+      ]
     end
 
-    # Builds the active goals line for the info panel.
-    # Returns nil when no goals exist so the line is hidden entirely.
-    # Shows root goal count with active/completed breakdown.
-    # @param tui [RatatuiRuby] TUI rendering context
-    # @param session [Hash] session info hash containing :goals array
-    # @return [RatatuiRuby::Widgets::Line, nil] styled goals line, or nil when empty
-    def goals_line(tui, session)
-      goal_list = session[:goals]
-      return if goal_list.nil? || goal_list.empty?
+    # Builds the sub-agents section with activity indicators.
+    # @return [Array<RatatuiRuby::Widgets::Line>, nil]
+    def hud_children_section(tui, session)
+      children = session[:children]
+      return if children.nil? || children.empty?
 
-      active = goal_list.count { |g| g["status"] == "active" }
-      completed = goal_list.count { |g| g["status"] == "completed" }
-      label = "#{active} active"
-      label += ", #{completed} done" if completed > 0
-      tui.line(spans: [
-        tui.span(content: "\u{1F3AF} ", style: tui.style(fg: "dark_gray")),
-        tui.span(content: label, style: tui.style(fg: "green"))
-      ])
+      lines = [
+        tui.line(spans: [tui.span(content: "")]),
+        tui.line(spans: [
+          tui.span(content: "\u{1F465} Sub-agents", style: tui.style(fg: "dark_gray"))
+        ])
+      ]
+
+      children.each do |child|
+        icon, color = child_icon_and_color(child)
+        name = child["name"] || "sub-agent"
+        lines << tui.line(spans: [
+          tui.span(content: "  #{icon} ", style: tui.style(fg: color)),
+          tui.span(content: "@#{name}", style: tui.style(fg: "white"))
+        ])
+      end
+
+      lines
+    end
+
+    # Returns the activity icon and color for a child session.
+    #
+    # @param child [Hash] child session data with "processing" key
+    # @return [Array(String, String)] icon and color pair
+    def child_icon_and_color(child)
+      if child["processing"]
+        [CHILD_ICON_RUNNING, "yellow"]
+      else
+        [CHILD_ICON_IDLE, "green"]
+      end
     end
 
-    # Builds the interaction state line for the info panel.
-    # Shows "Scrolling" when chat pane is focused, or "Thinking..." during LLM processing.
+    # Shows "Scrolling" when chat pane is focused, "Thinking..." during LLM processing.
     def interaction_state_line(tui)
       if @screens[:chat].chat_focused
         tui.line(spans: [
@@ -295,33 +403,9 @@ module TUI
         tui.line(spans: [
           tui.span(content: "Thinking...", style: tui.style(fg: "magenta", modifiers: [:bold]))
         ])
-      else
-        tui.line(spans: [tui.span(content: "")])
       end
     end
 
-    # Builds the connection status line for the info panel.
-    # Shows a single emoji for the normal (subscribed) state; adds descriptive
-    # text only when something requires attention.
-    # @param tui [RatatuiRuby] TUI rendering context
-    # @return [RatatuiRuby::Widgets::Line] styled status line with emoji indicator
-    def connection_status_line(tui)
-      cable_status = @cable_client.status
-      style = STATUS_STYLES.fetch(cable_status, STATUS_STYLES[:disconnected])
-
-      label = if cable_status == :reconnecting
-        attempt = @cable_client.reconnect_attempt
-        max = CableClient::MAX_RECONNECT_ATTEMPTS
-        "#{style[:label]} (#{attempt}/#{max})"
-      else
-        style[:label]
-      end
-
-      tui.line(spans: [
-        tui.span(content: label, style: tui.style(fg: style[:color], modifiers: [:bold]))
-      ])
-    end
-
     def chat_loading?
       @screens[:chat].loading?
     end
@@ -365,6 +449,9 @@ module TUI
       when :anthropic_token
         activate_token_setup
         nil
+      when :toggle_hud
+        @hud_visible = !@hud_visible
+        nil
       when :new_session
         @screens[:chat].new_session
         @current_screen = :chat
@@ -891,13 +978,14 @@ module TUI
     # -- Token setup popup -----------------------------------------------
 
     # Opens the token setup popup and resets all input state.
-    # Can be triggered manually via Ctrl+a > a or automatically when the
+    # Can be triggered manually via C-a → a or automatically when the
     # brain broadcasts authentication_required.
     # @return [void]
     def activate_token_setup
       @token_setup_active = true
       @token_input_buffer.clear
       @token_setup_error = nil
+      @token_setup_warning = nil
       @token_setup_status = :idle
     end
 
@@ -907,6 +995,7 @@ module TUI
       @token_setup_active = false
       @token_input_buffer.clear
       @token_setup_error = nil
+      @token_setup_warning = nil
       @token_setup_status = :idle
     end
 
@@ -933,9 +1022,11 @@ module TUI
       if result[:success]
         @token_setup_status = :success
         @token_setup_error = nil
+        @token_setup_warning = result[:warning]
       else
         @token_setup_status = :error
         @token_setup_error = result[:message]
+        @token_setup_warning = nil
       end
     end
 
@@ -1087,9 +1178,15 @@ module TUI
       end
 
       if @token_setup_status == :success
-        lines << tui.line(spans: [
-          tui.span(content: "Token saved and validated!", style: tui.style(fg: "green", modifiers: [:bold]))
-        ])
+        lines << if @token_setup_warning
+          tui.line(spans: [
+            tui.span(content: "Token saved (API unavailable, validation skipped)", style: tui.style(fg: "yellow", modifiers: [:bold]))
+          ])
+        else
+          tui.line(spans: [
+            tui.span(content: "Token saved and validated!", style: tui.style(fg: "green", modifiers: [:bold]))
+          ])
+        end
         lines << tui.line(spans: [tui.span(content: "")])
       end
 
@@ -1110,7 +1207,7 @@ module TUI
     def token_status_display
       case @token_setup_status
       when :success
-        ["Valid", "green"]
+        @token_setup_warning ? ["Saved (unverified)", "yellow"] : ["Valid", "green"]
       when :validating
         ["Validating...", "yellow"]
       when :error

data/lib/tui/decorators/base_decorator.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require_relative "../formatting"
+
+module TUI
+  module Decorators
+    # Client-side decorator layer for per-tool TUI rendering.
+    #
+    # Mirrors the server's Draper architecture but with a different
+    # specialization axis: server decorators are uniform per EVENT TYPE
+    # (tool_call, tool_result, message), while client decorators are
+    # unique per TOOL NAME (bash, read_file, web_get) — determining
+    # how each tool looks on screen.
+    #
+    # The factory dispatches on the +tool+ field in the structured data
+    # hash received from the server. Unknown tools fall back to generic
+    # rendering provided by this base class.
+    #
+    # @example Render a tool call
+    #   decorator = TUI::Decorators::BaseDecorator.for(data)
+    #   lines = decorator.render(tui)
+    class BaseDecorator
+      include Formatting
+
+      ICON = "\u{1F527}"        # wrench
+      CHECKMARK = "\u2713"
+      RETURN_ARROW = "\u21A9"
+      ERROR_ICON = "\u274C"
+
+      attr_reader :data
+
+      def initialize(data)
+        @data = data
+      end
+
+      # Factory returning the per-tool decorator for the given data hash.
+      #
+      # @param data [Hash] structured event data with string keys
+      #   ("role", "tool", "content", etc.)
+      # @return [BaseDecorator] the appropriate per-tool decorator
+      def self.for(data)
+        tool = resolve_tool(data)
+        decorator_for(tool).new(data)
+      end
+
+      # Renders the event, dispatching by role to the appropriate method.
+      #
+      # @param tui [RatatuiRuby] TUI rendering API
+      # @return [Array<RatatuiRuby::Widgets::Line>]
+      def render(tui)
+        case data["role"].to_s
+        when "tool_call" then render_call(tui)
+        when "tool_response" then render_response(tui)
+        when "think" then render_think(tui)
+        end
+      end
+
+      # Generic tool call rendering — icon, tool name, and indented input.
+      # Subclasses override for tool-specific presentation.
+      #
+      # @param tui [RatatuiRuby] TUI rendering API
+      # @return [Array<RatatuiRuby::Widgets::Line>]
+      def render_call(tui)
+        style = tui.style(fg: color)
+        header = build_call_header
+        lines = [tui.line(spans: [tui.span(content: header, style: style)])]
+        data["input"].to_s.split("\n", -1).each do |line|
+          lines << tui.line(spans: [tui.span(content: "  #{line}", style: style)])
+        end
+        lines
+      end
+
+      # Generic tool response rendering — success/failure indicator and content.
+      # Subclasses override for tool-specific presentation.
+      #
+      # @param tui [RatatuiRuby] TUI rendering API
+      # @return [Array<RatatuiRuby::Widgets::Line>]
+      def render_response(tui)
+        indicator = (data["success"] == false) ? ERROR_ICON : CHECKMARK
+        tool_id = data["tool_use_id"]
+        tokens = data["tokens"]
+
+        meta_parts = []
+        meta_parts << "[#{tool_id}]" if tool_id
+        meta_parts << indicator
+        meta_parts << format_token_label(tokens, data["estimated"]) if tokens
+        prefix = "  #{RETURN_ARROW} #{meta_parts.join(" ")} "
+
+        content_lines = data["content"].to_s.split("\n", -1)
+        style = tui.style(fg: response_color)
+        lines = [tui.line(spans: [tui.span(content: "#{prefix}#{content_lines.first}", style: style)])]
+        content_lines.drop(1).each { |line| lines << tui.line(spans: [tui.span(content: "    #{line}", style: style)]) }
+        lines
+      end
+
+      # Think rendering — delegated to ThinkDecorator, but base provides
+      # a fallback that renders as a generic tool call.
+      #
+      # @param tui [RatatuiRuby] TUI rendering API
+      # @return [Array<RatatuiRuby::Widgets::Line>]
+      def render_think(tui)
+        render_call(tui)
+      end
+
+      # Icon for this tool type. Subclasses override with tool-specific icons.
+      # @return [String]
+      def icon
+        ICON
+      end
+
+      # Color for tool call headers. Subclasses override for tool-specific colors.
+      # @return [String]
+      def color
+        "white"
+      end
+
+      # Color for tool response content. Subclasses override for tool-specific colors.
+      # @return [String]
+      def response_color
+        "white"
+      end
+
+      private
+
+      # Builds the header line for a tool call entry.
+      # @return [String]
+      def build_call_header
+        ts = data["timestamp"]
+        tool_id = data["tool_use_id"]
+
+        meta = []
+        meta << "[#{format_ns_timestamp(ts)}]" if ts
+        prefix = meta.empty? ? icon : "#{meta.join(" ")} #{icon}"
+        header = "#{prefix} #{data["tool"]}"
+        header += " [#{tool_id}]" if tool_id
+        header
+      end
+
+      # Resolves the tool name from the data hash.
+      # Think events have role "think" but no "tool" field.
+      def self.resolve_tool(data)
+        role = data["role"].to_s
+        return "think" if role == "think"
+
+        data["tool"].to_s
+      end
+      private_class_method :resolve_tool
+
+      # Maps tool name to its decorator class.
+      # Unknown tools get the base decorator (generic rendering).
+      def self.decorator_for(tool_name)
+        case tool_name
+        when "bash" then BashDecorator
+        when "think" then ThinkDecorator
+        when "read" then ReadDecorator
+        when "edit" then EditDecorator
+        when "write" then WriteDecorator
+        when "web_get" then WebGetDecorator
+        else self
+        end
+      end
+      private_class_method :decorator_for
+    end
+  end
+end

data/lib/tui/decorators/bash_decorator.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module TUI
+  module Decorators
+    # Renders bash tool calls and responses.
+    # Calls show the shell command with a terminal icon.
+    # Responses use green for success, red for failure.
+    class BashDecorator < BaseDecorator
+      ICON = "\u{1F4BB}" # laptop / terminal
+
+      def icon
+        ICON
+      end
+
+      def response_color
+        (data["success"] == false) ? "red" : "green"
+      end
+    end
+  end
+end