claude_swarm 1.0.1 → 1.0.2

data/lib/swarm_cli/ui/components/panel.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module SwarmCLI
+  module UI
+    module Components
+      # Renders highlighted panels for warnings, info, errors
+      # Uses top/bottom borders only (no sides per design constraint)
+      class Panel
+        TYPE_CONFIGS = {
+          warning: { color: :yellow, icon: UI::Icons::WARNING },
+          error: { color: :red, icon: UI::Icons::ERROR },
+          info: { color: :cyan, icon: UI::Icons::INFO },
+          success: { color: :green, icon: UI::Icons::SUCCESS },
+        }.freeze
+
+        def initialize(pastel:, terminal_width: 80)
+          @pastel = pastel
+          @terminal_width = terminal_width
+        end
+
+        # Render panel with top/bottom borders
+        #
+        # ⚠️  CONTEXT WARNING
+        #   Context usage: 81.4% (threshold: 80%)
+        #   Tokens remaining: 74,523
+        #
+        def render(type:, title:, lines:, indent: 0)
+          config = TYPE_CONFIGS[type] || TYPE_CONFIGS[:info]
+          prefix = "  " * indent
+
+          output = []
+
+          # Title line with icon
+          icon = config[:icon]
+          colored_title = @pastel.public_send(config[:color], "#{icon} #{title}")
+          output << "#{prefix}#{colored_title}"
+
+          # Content lines
+          lines.each do |line|
+            output << "#{prefix}  #{line}"
+          end
+
+          output << "" # Blank line after panel
+
+          output.join("\n")
+        end
+
+        # Render compact panel (single line)
+        # ⚠️  Context approaching limit (81.4%)
+        def render_compact(type:, message:, indent: 0)
+          config = TYPE_CONFIGS[type] || TYPE_CONFIGS[:info]
+          prefix = "  " * indent
+
+          icon = config[:icon]
+          colored_msg = @pastel.public_send(config[:color], "#{icon} #{message}")
+
+          "#{prefix}#{colored_msg}"
+        end
+      end
+    end
+  end
+end

data/lib/swarm_cli/ui/components/usage_stats.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module SwarmCLI
+  module UI
+    module Components
+      # Renders usage statistics (tokens, cost, context percentage)
+      class UsageStats
+        def initialize(pastel:)
+          @pastel = pastel
+        end
+
+        # Render usage line with all available metrics
+        # 5,922 tokens │ $0.0016 │ 1.5% used, 394,078 remaining
+        def render(tokens:, cost:, context_pct: nil, remaining: nil, cumulative: nil)
+          parts = []
+
+          # Token count (always shown)
+          parts << "#{Formatters::Number.format(tokens)} tokens"
+
+          # Cost (always shown if > 0)
+          parts << Formatters::Cost.format(cost, pastel: @pastel) if cost > 0
+
+          # Context tracking (if available)
+          if context_pct
+            colored_pct = color_context_percentage(context_pct)
+
+            parts << if remaining
+              "#{colored_pct} used, #{Formatters::Number.compact(remaining)} remaining"
+            else
+              "#{colored_pct} used"
+            end
+          elsif cumulative
+            # Model doesn't have context limit, show cumulative
+            parts << "#{Formatters::Number.compact(cumulative)} cumulative"
+          end
+
+          @pastel.dim(parts.join(" #{@pastel.dim("│")} "))
+        end
+
+        # Render compact stats for prompt display
+        # 15.2K tokens • $0.045 • 3.8% context
+        def render_compact(tokens:, cost:, context_pct: nil)
+          parts = []
+
+          parts << "#{Formatters::Number.compact(tokens)} tokens" if tokens > 0
+          parts << Formatters::Cost.format_plain(cost) if cost > 0
+          parts << "#{context_pct} context" if context_pct
+
+          parts.join(" • ")
+        end
+
+        private
+
+        def color_context_percentage(percentage_string)
+          percentage = percentage_string.to_s.gsub("%", "").to_f
+
+          color = if percentage < 50
+            :green
+          elsif percentage < 80
+            :yellow
+          else
+            :red
+          end
+
+          @pastel.public_send(color, percentage_string)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module SwarmCLI
+  module UI
+    module Formatters
+      # Cost formatting with color coding
+      class Cost
+        class << self
+          # Format cost with appropriate precision and color
+          # Small costs: green, $0.001234
+          # Medium costs: yellow, $0.1234
+          # Large costs: red, $12.34
+          def format(cost, pastel:)
+            return pastel.dim("$0.0000") if cost.nil? || cost.zero?
+
+            formatted = if cost < 0.01
+              Kernel.format("%.6f", cost)
+            elsif cost < 1.0
+              Kernel.format("%.4f", cost)
+            else
+              Kernel.format("%.2f", cost)
+            end
+
+            if cost < 0.01
+              pastel.green("$#{formatted}")
+            elsif cost < 1.0
+              pastel.yellow("$#{formatted}")
+            else
+              pastel.red("$#{formatted}")
+            end
+          end
+
+          # Format cost without color (for plain text)
+          def format_plain(cost)
+            return "$0.0000" if cost.nil? || cost.zero?
+
+            if cost < 0.01
+              Kernel.format("$%.6f", cost)
+            elsif cost < 1.0
+              Kernel.format("$%.4f", cost)
+            else
+              Kernel.format("$%.2f", cost)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module SwarmCLI
+  module UI
+    module Formatters
+      # Number formatting utilities for terminal display
+      class Number
+        class << self
+          # Format number with thousand separators
+          # 5922 → "5,922"
+          # 1500000 → "1,500,000"
+          def format(num)
+            return "0" if num.nil? || num.zero?
+
+            num.to_s.reverse.gsub(/(\d{3})(?=\d)/, '\\1,').reverse
+          end
+
+          # Format number with compact units (K, M, B)
+          # 5922 → "5.9K"
+          # 1500000 → "1.5M"
+          # 1500000000 → "1.5B"
+          def compact(num)
+            return "0" if num.nil? || num.zero?
+
+            case num
+            when 0...1_000
+              num.to_s
+            when 1_000...1_000_000
+              "#{(num / 1_000.0).round(1)}K"
+            when 1_000_000...1_000_000_000
+              "#{(num / 1_000_000.0).round(1)}M"
+            else
+              "#{(num / 1_000_000_000.0).round(1)}B"
+            end
+          end
+
+          # Format bytes with units (KB, MB, GB)
+          # 1024 → "1.0 KB"
+          # 1500000 → "1.4 MB"
+          def bytes(num)
+            return "0 B" if num.nil? || num.zero?
+
+            case num
+            when 0...1024
+              "#{num} B"
+            when 1024...1024**2
+              "#{(num / 1024.0).round(1)} KB"
+            when 1024**2...1024**3
+              "#{(num / 1024.0**2).round(1)} MB"
+            else
+              "#{(num / 1024.0**3).round(1)} GB"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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