swarm_cli 2.0.0.pre.1 → 2.0.0

data/lib/swarm_cli/ui/formatters/text.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module SwarmCLI
+  module UI
+    module Formatters
+      # Text manipulation utilities for clean display
+      class Text
+        class << self
+          # Strip <system-reminder> tags from content
+          def strip_system_reminders(text)
+            return "" if text.nil?
+
+            text.gsub(%r{<system-reminder>.*?</system-reminder>}m, "").strip
+          end
+
+          # Truncate text to specified character/line limits
+          # Returns [display_text, truncation_message]
+          def truncate(text, chars: nil, lines: nil)
+            return [text, nil] if text.nil? || text.empty?
+
+            text_lines = text.split("\n")
+            truncated = false
+            truncation_parts = []
+
+            # Apply line limit
+            if lines && text_lines.length > lines
+              text_lines = text_lines.first(lines)
+              hidden_lines = text.split("\n").length - lines
+              truncation_parts << "#{hidden_lines} more lines"
+              truncated = true
+            end
+
+            result_text = text_lines.join("\n")
+
+            # Apply character limit
+            if chars && result_text.length > chars
+              result_text = result_text[0...chars]
+              hidden_chars = text.length - chars
+              truncation_parts << "#{hidden_chars} more chars"
+              truncated = true
+            end
+
+            truncation_msg = truncated ? "... (#{truncation_parts.join(", ")})" : nil
+
+            [result_text, truncation_msg]
+          end
+
+          # Wrap text to specified width
+          def wrap(text, width:)
+            return "" if text.nil? || text.empty?
+
+            text.split("\n").flat_map do |line|
+              wrap_line(line, width)
+            end.join("\n")
+          end
+
+          # Indent all lines in text
+          def indent(text, level: 0, char: "  ")
+            return "" if text.nil? || text.empty?
+
+            prefix = char * level
+            text.split("\n").map { |line| "#{prefix}#{line}" }.join("\n")
+          end
+
+          private
+
+          # Word wrap a single line
+          def wrap_line(line, width)
+            return [line] if line.length <= width
+
+            line.scan(/.{1,#{width}}(?:\s+|$)/).map(&:strip)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/swarm_cli/ui/formatters/time.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module SwarmCLI
+  module UI
+    module Formatters
+      # Time and duration formatting utilities
+      class Time
+        class << self
+          # Format timestamp as [HH:MM:SS]
+          # Time.now → "[12:34:56]"
+          def timestamp(time)
+            return "" if time.nil?
+
+            case time
+            when ::Time
+              time.strftime("[%H:%M:%S]")
+            when String
+              parsed = ::Time.parse(time)
+              parsed.strftime("[%H:%M:%S]")
+            else
+              ""
+            end
+          rescue StandardError
+            ""
+          end
+
+          # Format duration in human-readable form
+          # 0.5 → "500ms"
+          # 2.3 → "2.3s"
+          # 65 → "1m 5s"
+          # 3665 → "1h 1m 5s"
+          def duration(seconds)
+            return "0ms" if seconds.nil? || seconds.zero?
+
+            if seconds < 1
+              "#{(seconds * 1000).round}ms"
+            elsif seconds < 60
+              "#{seconds.round(2)}s"
+            elsif seconds < 3600
+              minutes = (seconds / 60).floor
+              secs = (seconds % 60).round
+              "#{minutes}m #{secs}s"
+            else
+              hours = (seconds / 3600).floor
+              minutes = ((seconds % 3600) / 60).floor
+              secs = (seconds % 60).round
+              "#{hours}h #{minutes}m #{secs}s"
+            end
+          end
+
+          # Format relative time (future enhancement)
+          # Time.now - 120 → "2 minutes ago"
+          def relative(time)
+            return "" if time.nil?
+
+            seconds_ago = ::Time.now - time
+
+            case seconds_ago
+            when 0...60
+              "#{seconds_ago.round}s ago"
+            when 60...3600
+              "#{(seconds_ago / 60).round}m ago"
+            when 3600...86400
+              "#{(seconds_ago / 3600).round}h ago"
+            else
+              "#{(seconds_ago / 86400).round}d ago"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/swarm_cli/ui/icons.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module SwarmCLI
+  module UI
+    # Icon definitions for terminal UI
+    # Centralized so all components use the same icons
+    module Icons
+      # Event type icons
+      THINKING = "💭"
+      RESPONSE = "💬"
+      SUCCESS = "✓"
+      ERROR = "✗"
+      INFO = "ℹ"
+      WARNING = "⚠️"
+
+      # Entity icons
+      AGENT = "🤖"
+      TOOL = "🔧"
+      DELEGATE = "📨"
+      RESULT = "📥"
+      HOOK = "🪝"
+
+      # Metric icons
+      LLM = "🧠"
+      TOKENS = "📊"
+      COST = "💰"
+      TIME = "⏱"
+
+      # Visual elements
+      SPARKLES = "✨"
+      ARROW_RIGHT = "→"
+      BULLET = "•"
+      COMPRESS = "🗜️"
+
+      # All icons as hash for backward compatibility
+      ALL = {
+        thinking: THINKING,
+        response: RESPONSE,
+        success: SUCCESS,
+        error: ERROR,
+        info: INFO,
+        warning: WARNING,
+        agent: AGENT,
+        tool: TOOL,
+        delegate: DELEGATE,
+        result: RESULT,
+        hook: HOOK,
+        llm: LLM,
+        tokens: TOKENS,
+        cost: COST,
+        time: TIME,
+        sparkles: SPARKLES,
+        arrow_right: ARROW_RIGHT,
+        bullet: BULLET,
+        compress: COMPRESS,
+      }.freeze
+    end
+  end
+end

data/lib/swarm_cli/ui/renderers/event_renderer.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+module SwarmCLI
+  module UI
+    module Renderers
+      # High-level event rendering by composing lower-level components
+      # Returns formatted strings for each event type
+      class EventRenderer
+        def initialize(pastel:, agent_badge:, depth_tracker:)
+          @pastel = pastel
+          @agent_badge = agent_badge
+          @depth_tracker = depth_tracker
+          @usage_stats = Components::UsageStats.new(pastel: pastel)
+          @content_block = Components::ContentBlock.new(pastel: pastel)
+          @panel = Components::Panel.new(pastel: pastel)
+        end
+
+        # Render agent thinking event
+        # [12:34:56] 💭 architect (gpt-5-mini)
+        def agent_thinking(agent:, model:, timestamp:)
+          indent = @depth_tracker.indent(agent)
+          time = Formatters::Time.timestamp(timestamp)
+          agent_name = @agent_badge.render(agent, icon: UI::Icons::THINKING)
+          model_info = @pastel.dim("(#{model})")
+
+          "#{indent}#{@pastel.dim(time)} #{agent_name} #{model_info}"
+        end
+
+        # Render agent response event
+        # [12:34:56] 💬 architect responded:
+        def agent_response(agent:, timestamp:)
+          indent = @depth_tracker.indent(agent)
+          time = Formatters::Time.timestamp(timestamp)
+          agent_name = @agent_badge.render(agent, icon: UI::Icons::RESPONSE)
+
+          "#{indent}#{@pastel.dim(time)} #{agent_name} responded:"
+        end
+
+        # Render agent completion
+        # ✓ architect completed
+        def agent_completed(agent:)
+          indent = @depth_tracker.indent(agent)
+          agent_name = @agent_badge.render(agent)
+
+          "#{indent}#{@pastel.green("#{UI::Icons::SUCCESS} #{agent_name} completed")}"
+        end
+
+        # Render tool call event
+        # [12:34:56] architect 🔧 uses tool Read
+        def tool_call(agent:, tool:, timestamp:)
+          indent = @depth_tracker.indent(agent)
+          time = Formatters::Time.timestamp(timestamp)
+          agent_name = @agent_badge.render(agent)
+          tool_name = @pastel.bold.blue(tool)
+
+          "#{indent}#{@pastel.dim(time)} #{agent_name} #{@pastel.blue("#{UI::Icons::TOOL} uses tool")} #{tool_name}"
+        end
+
+        # Render tool result received
+        # [12:34:56] 📥 Tool result received by architect
+        def tool_result(agent:, timestamp:, tool: nil)
+          indent = @depth_tracker.indent(agent)
+          time = Formatters::Time.timestamp(timestamp)
+
+          "#{indent}#{@pastel.dim(time)} #{@pastel.green("#{UI::Icons::RESULT} Tool result")} received by #{agent}"
+        end
+
+        # Render delegation event
+        # [12:34:56] architect 📨 delegates to worker
+        def delegation(from:, to:, timestamp:)
+          indent = @depth_tracker.indent(from)
+          time = Formatters::Time.timestamp(timestamp)
+          from_name = @agent_badge.render(from)
+          to_name = @agent_badge.render(to)
+
+          "#{indent}#{@pastel.dim(time)} #{from_name} #{@pastel.yellow("#{UI::Icons::DELEGATE} delegates to")} #{to_name}"
+        end
+
+        # Render delegation result
+        # [12:34:56] 📥 Delegation result from worker → architect
+        def delegation_result(from:, to:, timestamp:)
+          indent = @depth_tracker.indent(to)
+          time = Formatters::Time.timestamp(timestamp)
+          from_name = @agent_badge.render(from)
+          to_name = @agent_badge.render(to)
+
+          "#{indent}#{@pastel.dim(time)} #{@pastel.green("#{UI::Icons::RESULT} Delegation result")} from #{from_name} #{@pastel.dim("→")} #{to_name}"
+        end
+
+        # Render hook execution
+        # [12:34:56] 🪝 Hook executed PreToolUse architect
+        def hook_executed(hook_event:, agent:, timestamp:, success:, blocked:)
+          indent = @depth_tracker.indent(agent)
+          time = Formatters::Time.timestamp(timestamp)
+          hook_display = @pastel.cyan(hook_event)
+          agent_name = @agent_badge.render(agent)
+
+          status = if blocked
+            @pastel.red("BLOCKED")
+          elsif success
+            @pastel.green("executed")
+          else
+            @pastel.yellow("warning")
+          end
+
+          color = if blocked
+            :red
+          else
+            (success ? :green : :yellow)
+          end
+          icon_colored = @pastel.public_send(color, UI::Icons::HOOK)
+
+          "#{indent}#{@pastel.dim(time)} #{icon_colored} Hook #{status} #{hook_display} #{agent_name}"
+        end
+
+        # Render usage stats line
+        #   5,922 tokens │ $0.0016 │ 1.5% used, 394,078 remaining
+        def usage_stats(tokens:, cost:, context_pct: nil, remaining: nil, cumulative: nil, indent: 0)
+          prefix = "  " * indent
+          stats = @usage_stats.render(
+            tokens: tokens,
+            cost: cost,
+            context_pct: context_pct,
+            remaining: remaining,
+            cumulative: cumulative,
+          )
+
+          "#{prefix}  #{stats}"
+        end
+
+        # Render tool list
+        #   Tools available: Read, Write, Bash
+        def tools_available(tools, indent: 0)
+          return "" if tools.nil? || tools.empty?
+
+          prefix = "  " * indent
+          tools_list = tools.join(", ")
+
+          "#{prefix}  #{@pastel.dim("Tools available: #{tools_list}")}"
+        end
+
+        # Render delegation list
+        #   Can delegate to: frontend_dev, backend_dev
+        def delegates_to(agents, indent: 0, color_cache:)
+          return "" if agents.nil? || agents.empty?
+
+          prefix = "  " * indent
+          agent_badge = Components::AgentBadge.new(pastel: @pastel, color_cache: color_cache)
+          delegates_list = agent_badge.render_list(agents)
+
+          "#{prefix}  #{@pastel.dim("Can delegate to:")} #{delegates_list}"
+        end
+
+        # Render thinking text (italic, indented)
+        def thinking_text(content, indent: 0)
+          return "" if content.nil? || content.empty?
+
+          # Strip system reminders
+          text = Formatters::Text.strip_system_reminders(content)
+          return "" if text.empty?
+
+          prefix = "  " * indent
+
+          text.split("\n").map do |line|
+            "#{prefix}  #{@pastel.italic(line)}"
+          end.join("\n")
+        end
+
+        # Render tool arguments
+        def tool_arguments(args, indent: 0, truncate: false)
+          @content_block.render_hash(args, indent: indent, label: "Arguments", truncate: truncate)
+        end
+
+        # Render tool result content
+        def tool_result_content(content, indent: 0, truncate: false)
+          @content_block.render_text(
+            content,
+            indent: indent,
+            color: :bright_green,
+            truncate: truncate,
+            max_lines: 2,
+            max_chars: 300,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/swarm_cli/ui/state/agent_color_cache.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module SwarmCLI
+  module UI
+    module State
+      # Caches agent name → color assignments for consistent coloring
+      class AgentColorCache
+        # Professional color palette inspired by modern CLIs
+        PALETTE = [
+          :cyan,
+          :magenta,
+          :yellow,
+          :blue,
+          :green,
+          :bright_cyan,
+          :bright_magenta,
+        ].freeze
+
+        def initialize
+          @cache = {}
+          @next_index = 0
+        end
+
+        # Get color for agent (cached)
+        def get(agent_name)
+          @cache[agent_name] ||= assign_next_color
+        end
+
+        # Reset cache (for testing)
+        def reset
+          @cache.clear
+          @next_index = 0
+        end
+
+        private
+
+        def assign_next_color
+          color = PALETTE[@next_index % PALETTE.size]
+          @next_index += 1
+          color
+        end
+      end
+    end
+  end
+end

data/lib/swarm_cli/ui/state/depth_tracker.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module SwarmCLI
+  module UI
+    module State
+      # Tracks agent depth for hierarchical indentation display
+      class DepthTracker
+        def initialize
+          @depths = {}
+          @seen_agents = []
+        end
+
+        # Get indentation depth for agent
+        def get(agent_name)
+          @depths[agent_name] ||= calculate_depth(agent_name)
+        end
+
+        # Get indent string for agent
+        def indent(agent_name, char: "  ")
+          char * get(agent_name)
+        end
+
+        # Reset tracker (for testing)
+        def reset
+          @depths.clear
+          @seen_agents.clear
+        end
+
+        private
+
+        def calculate_depth(agent_name)
+          @seen_agents << agent_name unless @seen_agents.include?(agent_name)
+
+          # First agent is depth 0, all others are depth 1
+          @seen_agents.size == 1 ? 0 : 1
+        end
+      end
+    end
+  end
+end

data/lib/swarm_cli/ui/state/spinner_manager.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+module SwarmCLI
+  module UI
+    module State
+      # Manages active spinners with elapsed time display
+      class SpinnerManager
+        def initialize
+          @active_spinners = {}
+          @time_updaters = {}
+        end
+
+        # Start a spinner with elapsed time tracking
+        #
+        # @param key [Symbol, String] Unique key for this spinner
+        # @param message [String] Spinner message
+        # @param format [Symbol] Spinner format (:dots, :pulse, etc.)
+        # @return [TTY::Spinner] The spinner instance
+        def start(key, message, format: :dots)
+          # Stop any existing spinner with this key
+          stop(key) if @active_spinners[key]
+
+          # Create spinner with elapsed time token
+          spinner = TTY::Spinner.new(
+            "[:spinner] #{message} (:elapsed)",
+            format: format,
+            hide_cursor: true,
+          )
+
+          spinner.auto_spin
+
+          # Spawn thread to update elapsed time every 1 second
+          # This is 10x slower than spinner animation (100ms), preventing flicker
+          @time_updaters[key] = Thread.new do
+            loop do
+              elapsed = spinner.duration
+              break unless elapsed
+
+              formatted_time = format_duration(elapsed)
+              spinner.update(elapsed: formatted_time)
+              sleep(1.0) # 1s refresh rate - smooth without flicker
+            rescue StandardError
+              break
+            end
+          end
+
+          @active_spinners[key] = spinner
+          spinner
+        end
+
+        # Stop spinner with success
+        #
+        # @param key [Symbol, String] Spinner key
+        # @param message [String] Success message
+        def success(key, message = "completed")
+          spinner = @active_spinners[key]
+          return unless spinner
+
+          # Kill time updater
+          kill_updater(key)
+
+          # Show final time
+          final_time = format_duration(spinner.duration || 0)
+          spinner.success("#{message} (#{final_time})")
+
+          cleanup(key)
+        end
+
+        # Stop spinner with error
+        #
+        # @param key [Symbol, String] Spinner key
+        # @param message [String] Error message
+        def error(key, message = "failed")
+          spinner = @active_spinners[key]
+          return unless spinner
+
+          # Kill time updater
+          kill_updater(key)
+
+          # Show final time
+          final_time = format_duration(spinner.duration || 0)
+          spinner.error("#{message} (#{final_time})")
+
+          cleanup(key)
+        end
+
+        # Stop spinner without success/error (just stop)
+        #
+        # @param key [Symbol, String] Spinner key
+        def stop(key)
+          spinner = @active_spinners[key]
+          return unless spinner
+
+          kill_updater(key)
+          spinner.stop
+          cleanup(key)
+        end
+
+        # Stop all active spinners
+        def stop_all
+          @active_spinners.keys.each { |key| stop(key) }
+        end
+
+        # Check if a spinner is active
+        #
+        # @param key [Symbol, String] Spinner key
+        # @return [Boolean]
+        def active?(key)
+          @active_spinners.key?(key)
+        end
+
+        # Pause all active spinners (for interactive debugging)
+        #
+        # This temporarily stops spinner animation while preserving state,
+        # allowing interactive sessions like binding.irb to run cleanly.
+        #
+        # @return [void]
+        def pause_all
+          @active_spinners.each_value do |spinner|
+            spinner.stop if spinner.spinning?
+          end
+
+          # Keep time updaters running (they'll safely handle stopped spinners)
+        end
+
+        # Resume all paused spinners
+        #
+        # Restarts spinner animation for all spinners that were paused.
+        #
+        # @return [void]
+        def resume_all
+          @active_spinners.each_value do |spinner|
+            spinner.auto_spin unless spinner.spinning?
+          end
+        end
+
+        private
+
+        def kill_updater(key)
+          updater = @time_updaters[key]
+          return unless updater
+
+          updater.kill if updater.alive?
+          @time_updaters.delete(key)
+        end
+
+        def cleanup(key)
+          @active_spinners.delete(key)
+          @time_updaters.delete(key)
+        end
+
+        def format_duration(seconds)
+          if seconds < 1
+            "#{(seconds * 1000).round}ms"
+          elsif seconds < 60
+            "#{seconds.round}s"
+          elsif seconds < 3600
+            minutes = (seconds / 60).floor
+            secs = (seconds % 60).round
+            "#{minutes}m #{secs}s"
+          else
+            hours = (seconds / 3600).floor
+            minutes = ((seconds % 3600) / 60).floor
+            "#{hours}h #{minutes}m"
+          end
+        end
+      end
+    end
+  end
+end