swarm_cli 2.0.0.pre.1

data/lib/swarm_cli/formatters/human_formatter.rb

@@ -0,0 +1,912 @@
+# frozen_string_literal: true
+
+module SwarmCLI
+  module Formatters
+    # HumanFormatter creates beautiful, detailed real-time output using TTY toolkit.
+    # Shows everything: agent thinking, tool calls with arguments, results, responses.
+    # Uses simple dividers for clean, readable output without box alignment issues.
+    class HumanFormatter
+      ICONS = {
+        success: "✓",
+        error: "✗",
+        info: "ℹ",
+        agent: "🤖",
+        tool: "🔧",
+        llm: "🧠",
+        thinking: "💭",
+        response: "💬",
+        cost: "💰",
+        time: "⏱",
+        tokens: "📊",
+        arrow_right: "→",
+        delegate: "📨",
+        result: "📥",
+        bullet: "•",
+        sparkles: "✨",
+        hook: "🪝",
+      }.freeze
+
+      def initialize(output: $stdout, quiet: false, truncate: false, verbose: false)
+        @output = output
+        @quiet = quiet
+        @truncate = truncate
+        @verbose = verbose
+        # Enable colors when output is a TTY (terminal), disable for non-TTY (pipes, files)
+        # This ensures colors work in terminals but don't pollute piped/redirected output
+        @pastel = Pastel.new(enabled: output.tty?)
+        @llm_request_count = 0
+        @tool_call_count = 0
+        @total_cost = 0.0
+        @total_tokens = 0
+        @agents_seen = Set.new
+        @agent_depth = {}
+        @agent_colors = {}
+        @color_palette = [:cyan, :magenta, :yellow, :blue, :green, :bright_cyan, :bright_magenta]
+        @next_color_index = 0
+        @start_time = nil
+        @terminal_width = TTY::Screen.width
+        @active_spinner = nil
+        @recent_tool_calls = {} # tool_call_id => tool_name
+      end
+
+      # Called when swarm execution starts
+      def on_start(config_path:, swarm_name:, lead_agent:, prompt:)
+        @start_time = Time.now
+        print_header(swarm_name, lead_agent)
+        print_prompt(prompt)
+        print_divider
+        @output.puts @pastel.bold("#{ICONS[:info]} Execution Log:")
+        @output.puts
+
+        # Start spinner while waiting for first event
+        lead_color = get_agent_color(lead_agent.to_sym)
+        start_spinner("  ", "#{@pastel.public_send(lead_color, lead_agent)} is processing the request...")
+      end
+
+      # Called for each log entry from SwarmSDK
+      def on_log(entry)
+        return if @quiet
+
+        # Clear any active spinner before processing new event
+        clear_spinner
+
+        case entry[:type]
+        when "swarm_start"
+          handle_swarm_start(entry)
+        when "swarm_stop"
+          handle_swarm_stop(entry)
+        when "user_prompt"
+          handle_user_request(entry)
+        when "agent_step"
+          handle_agent_step(entry)
+        when "agent_stop"
+          handle_agent_stop(entry)
+        when "tool_call"
+          handle_tool_call(entry)
+        when "tool_result"
+          handle_tool_result(entry)
+        when "agent_delegation"
+          handle_agent_delegation(entry)
+        when "delegation_result"
+          handle_delegation_result(entry)
+        when "context_limit_warning"
+          handle_context_warning(entry)
+        when "model_lookup_warning"
+          handle_model_lookup_warning(entry)
+        when "compression_started"
+          handle_compression_started(entry)
+        when "compression_completed"
+          handle_compression_completed(entry)
+        when "hook_executed"
+          handle_hook_executed(entry)
+        end
+      end
+
+      # Called when swarm execution completes successfully
+      def on_success(result:)
+        clear_spinner
+        @output.puts
+        print_divider
+        print_result(result)
+        print_summary(result)
+      end
+
+      # Called when swarm execution fails
+      def on_error(error:, duration: nil)
+        clear_spinner
+        @output.puts
+        print_divider
+        print_error(error)
+        print_divider
+      end
+
+      private
+
+      def handle_swarm_start(entry)
+        # SwarmSDK now emits this automatically
+        # The CLI's on_start method already displayed the header, so we skip it here
+        # to avoid duplicate output
+      end
+
+      def handle_swarm_stop(entry)
+        # SwarmSDK now emits this automatically
+        # The CLI's on_success/on_error methods will display the summary,
+        # so we just silently track it here
+      end
+
+      def handle_compression_started(entry)
+        agent = entry[:agent]
+        indent = "  " * (@agent_depth[agent] || 0)
+        agent_color = get_agent_color(agent)
+        timestamp = format_timestamp(entry[:timestamp])
+
+        message_count = entry[:message_count]
+        estimated_tokens = entry[:estimated_tokens]
+
+        @output.puts
+        @output.puts "#{indent}#{@pastel.dim(timestamp)} #{@pastel.yellow("🗜️  CONTEXT COMPRESSION")} #{@pastel.public_send(agent_color, agent)}"
+        @output.puts "#{indent}  #{@pastel.dim("Compressing #{message_count} messages (~#{format_number(estimated_tokens)} tokens)...")}"
+        @output.puts
+
+        # Show spinner while compressing
+        start_spinner("#{indent}  ", "Compacting context...")
+      end
+
+      def handle_compression_completed(entry)
+        agent = entry[:agent]
+        indent = "  " * (@agent_depth[agent] || 0)
+        agent_color = get_agent_color(agent)
+        timestamp = format_timestamp(entry[:timestamp])
+
+        original_messages = entry[:original_message_count]
+        compressed_messages = entry[:compressed_message_count]
+        messages_removed = entry[:messages_removed]
+
+        original_tokens = entry[:original_tokens]
+        compressed_tokens = entry[:compressed_tokens]
+        compression_ratio = entry[:compression_ratio]
+
+        time_taken = entry[:time_taken]
+
+        @output.puts "#{indent}#{@pastel.dim(timestamp)} #{@pastel.green("✓ COMPRESSION COMPLETE")} #{@pastel.public_send(agent_color, agent)}"
+        @output.puts "#{indent}  #{@pastel.dim("Messages:")} #{original_messages} → #{compressed_messages} #{@pastel.green("(-#{messages_removed})")}"
+        @output.puts "#{indent}  #{@pastel.dim("Tokens:")} #{format_number(original_tokens)} → #{format_number(compressed_tokens)} #{@pastel.green("(#{(compression_ratio * 100).round(1)}%)")}"
+        @output.puts "#{indent}  #{@pastel.dim("Time taken:")} #{format_duration(time_taken)}"
+        @output.puts
+      end
+
+      def handle_user_request(entry)
+        agent = entry[:agent]
+        @agents_seen.add(agent)
+        @llm_request_count += 1
+
+        @agent_depth[agent] ||= calculate_depth(agent)
+        indent = "  " * @agent_depth[agent]
+        agent_color = get_agent_color(agent)
+
+        timestamp = format_timestamp(entry[:timestamp])
+        @output.puts "#{indent}#{@pastel.dim(timestamp)} #{@pastel.public_send(agent_color, "#{ICONS[:thinking]} #{agent}")} #{@pastel.dim("(#{entry[:model]})")}"
+
+        # Show actual tools (non-delegation)
+        if entry[:tools]&.any?
+          tools_list = entry[:tools].join(", ")
+          @output.puts "#{indent}  #{@pastel.dim("Tools available: #{tools_list}")}"
+        end
+
+        # Show agents this agent can delegate to
+        if entry[:delegates_to]&.any?
+          delegates_list = entry[:delegates_to].map do |delegate_name|
+            delegate_color = get_agent_color(delegate_name.to_sym)
+            @pastel.public_send(delegate_color, delegate_name)
+          end.join(", ")
+          @output.puts "#{indent}  #{@pastel.dim("Can delegate to:")} #{delegates_list}"
+        end
+
+        # Show spinner while waiting for response
+        start_spinner("#{indent}  ", "#{@pastel.public_send(agent_color, agent)} is thinking...")
+      end
+
+      def handle_agent_step(entry)
+        # Agent made an intermediate response with tool calls
+        agent = entry[:agent]
+        indent = "  " * (@agent_depth[agent] || 0)
+        get_agent_color(agent)
+
+        # Track usage for this LLM API call
+        if entry[:usage]
+          cost = entry[:usage][:total_cost] || 0.0
+          tokens = entry[:usage][:total_tokens] || 0
+          @total_cost += cost
+          @total_tokens += tokens
+
+          # Build usage text with per-turn tokens and cost
+          usage_parts = ["#{format_number(tokens)} tokens", format_cost(cost)]
+
+          # Add context usage if available (cumulative tracking)
+          if entry[:usage][:tokens_used_percentage]
+            usage_percentage = entry[:usage][:tokens_used_percentage]
+            tokens_remaining = entry[:usage][:tokens_remaining]
+
+            # Color code the percentage based on usage
+            percentage_display = format_context_percentage(usage_percentage)
+
+            if tokens_remaining
+              remaining_display = format_number(tokens_remaining)
+              usage_parts << "#{percentage_display} used, #{remaining_display} remaining"
+            else
+              # Context limit not available for this model
+              cumulative = entry[:usage][:cumulative_total_tokens]
+              usage_parts << "#{format_number(cumulative)} cumulative" if cumulative
+            end
+          end
+
+          usage_text = usage_parts.join(" #{@pastel.dim("│")} ")
+          @output.puts "#{indent}  #{@pastel.dim(usage_text)}"
+        end
+
+        # Display the agent's thinking/explanation text if present
+        if entry[:content] && !entry[:content].empty?
+          # Filter out system reminders for cleaner display
+          thinking_text = strip_system_reminders(entry[:content])
+
+          unless thinking_text.empty?
+            @output.puts
+            # Display thinking text in italic for visual distinction
+            thinking_text.split("\n").each do |line|
+              @output.puts "#{indent}  #{@pastel.italic(line)}"
+            end
+          end
+        end
+
+        # Show what the agent is doing (requesting tools)
+        tool_count = entry[:tool_calls]&.size || 0
+        if tool_count > 0
+          @output.puts "#{indent}  #{@pastel.dim("→ Requesting #{tool_count} tool#{"s" if tool_count > 1}...")}"
+        end
+
+        @output.puts
+        print_event_divider
+      end
+
+      def handle_agent_stop(entry)
+        # Agent completed with final response (no more tool calls)
+        agent = entry[:agent]
+        indent = "  " * (@agent_depth[agent] || 0)
+        agent_color = get_agent_color(agent)
+        depth = @agent_depth[agent] || 0
+
+        # Track usage for this final LLM API call
+        if entry[:usage]
+          cost = entry[:usage][:total_cost] || 0.0
+          tokens = entry[:usage][:total_tokens] || 0
+          @total_cost += cost
+          @total_tokens += tokens
+
+          # Build usage text with per-turn tokens and cost
+          usage_parts = ["#{format_number(tokens)} tokens", format_cost(cost)]
+
+          # Add context usage if available (cumulative tracking)
+          if entry[:usage][:tokens_used_percentage]
+            usage_percentage = entry[:usage][:tokens_used_percentage]
+            tokens_remaining = entry[:usage][:tokens_remaining]
+
+            # Color code the percentage based on usage
+            percentage_display = format_context_percentage(usage_percentage)
+
+            if tokens_remaining
+              remaining_display = format_number(tokens_remaining)
+              usage_parts << "#{percentage_display} used, #{remaining_display} remaining"
+            else
+              # Context limit not available for this model
+              cumulative = entry[:usage][:cumulative_total_tokens]
+              usage_parts << "#{format_number(cumulative)} cumulative" if cumulative
+            end
+          end
+
+          usage_text = usage_parts.join(" #{@pastel.dim("│")} ")
+          @output.puts "#{indent}  #{@pastel.dim(usage_text)}"
+        end
+
+        # Display final response
+        # Skip displaying content if this is a delegated agent (depth > 0)
+        # The content will be shown as a delegation_result to avoid duplication
+        if entry[:content] && !entry[:content].empty? && depth == 0
+          timestamp = format_timestamp(entry[:timestamp])
+          @output.puts "#{indent}#{@pastel.dim(timestamp)} #{@pastel.public_send(agent_color, "#{ICONS[:response]} #{agent}")} responded:"
+          display_response(entry[:content], indent)
+        end
+
+        @output.puts
+        @output.puts "#{indent}#{@pastel.green("#{ICONS[:success]} #{agent} completed")}"
+
+        @output.puts
+        print_event_divider
+      end
+
+      def handle_tool_call(entry)
+        @tool_call_count += 1
+        # Display tool call (non-delegation)
+        agent = entry[:agent]
+        indent = "  " * (@agent_depth[agent] || 0)
+        agent_color = get_agent_color(agent)
+
+        timestamp = format_timestamp(entry[:timestamp])
+        tool_name = entry[:tool]
+        tool_call_id = entry[:tool_call_id]
+        args = entry[:arguments]
+
+        # Track this tool call for later matching with results
+        @recent_tool_calls[tool_call_id] = tool_name if tool_call_id
+
+        @output.puts "#{indent}#{@pastel.dim(timestamp)} #{@pastel.public_send(agent_color, agent)} #{@pastel.blue("#{ICONS[:tool]} uses tool")} #{@pastel.bold.blue(tool_name)}"
+
+        # Show arguments (skip for TodoWrite unless verbose mode)
+        show_args = args && !args.empty?
+        show_args &&= tool_name != "TodoWrite" || @verbose
+
+        if show_args
+          @output.puts "#{indent}  #{@pastel.dim("Arguments:")}"
+          args.each do |key, value|
+            formatted_value = format_argument_value(value)
+            @output.puts "#{indent}    #{@pastel.cyan("#{key}:")} #{formatted_value}"
+          end
+        end
+
+        @output.puts
+
+        # Show spinner while waiting for tool to execute
+        start_spinner("#{indent}  ", "Executing #{@pastel.bold.blue(tool_name)}...")
+      end
+
+      def handle_agent_delegation(entry)
+        @tool_call_count += 1
+        # Display delegation to another agent
+        agent = entry[:agent]
+        delegate_to = entry[:delegate_to]
+        indent = "  " * (@agent_depth[agent] || 0)
+        agent_color = get_agent_color(agent)
+        delegate_color = get_agent_color(delegate_to.to_sym)
+
+        timestamp = format_timestamp(entry[:timestamp])
+        args = entry[:arguments]
+
+        @output.puts "#{indent}#{@pastel.dim(timestamp)} #{@pastel.public_send(agent_color, agent)} #{@pastel.yellow("#{ICONS[:delegate]} delegates to")} #{@pastel.public_send(delegate_color, delegate_to)}"
+        @output.puts
+
+        if args && !args.empty?
+          @output.puts "#{indent}  #{@pastel.dim("Arguments:")}"
+          args.each do |key, value|
+            formatted_value = format_argument_value(value)
+            @output.puts "#{indent}    #{@pastel.cyan("#{key}:")} #{formatted_value}"
+          end
+        end
+
+        @output.puts
+
+        # Show spinner while waiting for delegated agent to respond
+        start_spinner("  #{indent}  ", "Waiting for #{@pastel.public_send(delegate_color, delegate_to)}...")
+      end
+
+      def handle_tool_result(entry)
+        agent = entry[:agent]
+        indent = "  " * (@agent_depth[agent] || 0)
+        agent_color = get_agent_color(agent)
+        tool_name = entry[:tool] || extract_tool_from_entry(entry)
+
+        timestamp = format_timestamp(entry[:timestamp])
+
+        # Check if this is a TodoWrite tool result - if so, show formatted todo list
+        if tool_name == "TodoWrite"
+          display_todo_list(agent, indent, timestamp)
+        else
+          @output.puts "#{indent}#{@pastel.dim(timestamp)} #{@pastel.green("#{ICONS[:result]} Tool result")} received by #{agent}"
+
+          result_text = entry[:result]
+          if result_text.is_a?(String) && !result_text.empty?
+            display_result(result_text, indent)
+          end
+        end
+
+        @output.puts
+        print_event_divider
+
+        # Show spinner while agent processes the result
+        start_spinner("#{indent}  ", "#{@pastel.public_send(agent_color, agent)} processing tool result...")
+      end
+
+      def handle_delegation_result(entry)
+        agent = entry[:agent]
+        delegate_from = entry[:delegate_from]
+        indent = "  " * (@agent_depth[agent] || 0)
+        agent_color = get_agent_color(agent)
+
+        timestamp = format_timestamp(entry[:timestamp])
+
+        # Show who sent the result to whom
+        if delegate_from
+          delegate_color = get_agent_color(delegate_from.to_sym)
+          @output.puts "#{indent}#{@pastel.dim(timestamp)} #{@pastel.green("#{ICONS[:result]} Delegation result")} from #{@pastel.public_send(delegate_color, delegate_from)} #{@pastel.dim("→")} #{@pastel.public_send(agent_color, agent)}"
+        else
+          @output.puts "#{indent}#{@pastel.dim(timestamp)} #{@pastel.green("#{ICONS[:result]} Delegation result")} received by #{@pastel.public_send(agent_color, agent)}"
+        end
+
+        result_text = entry[:result]
+        if result_text.is_a?(String) && !result_text.empty?
+          display_result(result_text, indent)
+        end
+
+        @output.puts
+        print_event_divider
+
+        # Show spinner while agent processes the delegation result
+        start_spinner("#{indent}  ", "#{@pastel.public_send(agent_color, agent)} processing result from #{@pastel.public_send(delegate_color, delegate_from)}...")
+      end
+
+      def handle_context_warning(entry)
+        agent = entry[:agent]
+        indent = "  " * (@agent_depth[agent] || 0)
+        agent_color = get_agent_color(agent)
+        timestamp = format_timestamp(entry[:timestamp])
+
+        threshold = entry[:threshold]
+        current_usage = entry[:current_usage]
+        tokens_remaining = entry[:tokens_remaining]
+
+        # Color code based on threshold
+        warning_color = threshold == "90%" ? :red : :yellow
+        icon = threshold == "90%" ? "⚠️" : "⚡"
+
+        @output.puts
+        @output.puts "#{indent}#{@pastel.dim(timestamp)} #{@pastel.public_send(warning_color, "#{icon} CONTEXT WARNING")} #{@pastel.public_send(agent_color, agent)}"
+        @output.puts "#{indent}  #{@pastel.public_send(warning_color, "Context usage: #{current_usage} (threshold: #{threshold})")}"
+        @output.puts "#{indent}  #{@pastel.dim("Tokens remaining: #{format_number(tokens_remaining)}")}"
+        @output.puts
+      end
+
+      def handle_model_lookup_warning(entry)
+        agent = entry[:agent]
+        indent = "  " * (@agent_depth[agent] || 0)
+        agent_color = get_agent_color(agent)
+        timestamp = format_timestamp(entry[:timestamp])
+
+        model = entry[:model]
+        error_message = entry[:error_message]
+        suggestions = entry[:suggestions] || []
+
+        @output.puts
+        @output.puts "#{indent}#{@pastel.dim(timestamp)} #{@pastel.yellow("⚠️  MODEL WARNING")} #{@pastel.public_send(agent_color, agent)}"
+        @output.puts "#{indent}  #{@pastel.yellow("Model '#{model}' not found in registry")}"
+
+        if suggestions.any?
+          @output.puts "#{indent}  #{@pastel.dim("Did you mean one of these?")}"
+          suggestions.each do |suggestion|
+            model_id = suggestion[:id] || suggestion["id"]
+            context = suggestion[:context_window] || suggestion["context_window"]
+            context_display = context ? " (#{format_number(context)} tokens)" : ""
+            @output.puts "#{indent}    #{@pastel.cyan("•")} #{@pastel.white(model_id)}#{@pastel.dim(context_display)}"
+          end
+        else
+          @output.puts "#{indent}  #{@pastel.dim("Error: #{error_message}")}"
+        end
+
+        @output.puts "#{indent}  #{@pastel.dim("Context tracking unavailable for this model.")}"
+        @output.puts
+      end
+
+      def handle_hook_executed(entry)
+        hook_event = entry[:hook_event]
+        agent = entry[:agent]
+        command = entry[:command]
+        exit_code = entry[:exit_code]
+        success = entry[:success]
+        stderr = entry[:stderr]
+        blocked = entry[:blocked]
+
+        indent = "  " * (@agent_depth[agent] || 0)
+        agent_color = agent ? get_agent_color(agent.to_sym) : :white
+        timestamp = format_timestamp(entry[:timestamp])
+
+        # Determine hook display color and status
+        if blocked
+          # Exit code 2 - blocked execution
+          status_color = :red
+          ICONS[:error]
+          status_text = "BLOCKED"
+        elsif success
+          # Exit code 0 - success
+          status_color = :green
+          ICONS[:success]
+          status_text = "executed"
+        else
+          # Other exit codes - non-blocking error
+          status_color = :yellow
+          status_text = "warning"
+        end
+
+        # Format hook event name
+        hook_display = @pastel.cyan(hook_event || "unknown")
+
+        # Show hook execution
+        agent_display = agent ? @pastel.public_send(agent_color, agent) : ""
+        @output.puts "#{indent}#{@pastel.dim(timestamp)} #{@pastel.public_send(status_color, "#{ICONS[:hook]} Hook #{status_text}")} #{hook_display} #{agent_display}"
+
+        # Show command if verbose mode
+        if @verbose
+          @output.puts "#{indent}  #{@pastel.dim("Command:")} #{@pastel.dim(command)}"
+        end
+
+        # Show stderr if present (errors or messages)
+        # For user_prompt blocks, show prominently since prompt was erased
+        if stderr && !stderr.empty?
+          if blocked && hook_event == "user_prompt"
+            # User prompt was blocked - show prominently to user
+            @output.puts
+            @output.puts "#{indent}  #{@pastel.bold.red("⛔ Prompt Blocked by Hook:")}"
+            stderr.lines.each do |line|
+              @output.puts "#{indent}  #{@pastel.red(line.chomp)}"
+            end
+            @output.puts "#{indent}  #{@pastel.dim("(Prompt was not sent to the agent)")}"
+          elsif blocked
+            @output.puts "#{indent}  #{@pastel.red("Blocked:")} #{@pastel.red(stderr)}"
+          else
+            @output.puts "#{indent}  #{@pastel.yellow("Message:")} #{@pastel.dim(stderr)}"
+          end
+        end
+
+        # Show exit code in verbose mode
+        if @verbose && exit_code
+          code_color = if exit_code == 0
+            :green
+          else
+            (exit_code == 2 ? :red : :yellow)
+          end
+          @output.puts "#{indent}  #{@pastel.dim("Exit code:")} #{@pastel.public_send(code_color, exit_code)}"
+        end
+
+        @output.puts
+
+        # Show spinner after hook execution so user knows agent is processing
+        # Skip spinner for user_prompt blocks (prompt was erased, execution stops)
+        if agent && !(blocked && hook_event == "user_prompt")
+          agent_display = @pastel.public_send(agent_color, agent)
+          if blocked
+            start_spinner("#{indent}  ", "#{agent_display} adapting to blocked operation...")
+          else
+            start_spinner("#{indent}  ", "#{agent_display} processing hook result...")
+          end
+        end
+      end
+
+      def display_result(content, indent)
+        # Filter out system reminders unless verbose mode is enabled
+        filtered_content = @verbose ? content : strip_system_reminders(content)
+
+        lines = filtered_content.split("\n")
+
+        # Truncate based on verbose flag
+        display_lines = if @verbose
+          # Verbose mode: show everything
+          lines
+        else
+          # Non-verbose mode: truncate to first 2 lines and 300 chars
+          truncate_tool_result(lines, filtered_content)
+        end
+
+        display_lines.each do |line|
+          @output.puts "#{indent}  #{@pastel.bright_green(line)}"
+        end
+      end
+
+      def display_todo_list(agent, indent, timestamp)
+        # Get the current todos from TodoManager
+        todos = SwarmSDK::Tools::Stores::TodoManager.get_todos(agent.to_sym)
+
+        if todos.empty?
+          @output.puts "#{indent}#{@pastel.dim(timestamp)} #{@pastel.cyan("#{ICONS[:bullet]} Todo list")} updated (empty)"
+          return
+        end
+
+        @output.puts "#{indent}#{@pastel.dim(timestamp)} #{@pastel.cyan("#{ICONS[:bullet]} Todo list")} updated:"
+        @output.puts
+
+        todos.each_with_index do |todo, index|
+          status = todo[:status] || todo["status"]
+          content = todo[:content] || todo["content"]
+          num = index + 1
+
+          # Format based on status
+          case status
+          when "completed"
+            # Strikethrough for completed - use dim and strikethrough
+            @output.puts "#{indent}  #{@pastel.dim("#{num}.")} #{@pastel.dim.strikethrough(content)}"
+          when "in_progress"
+            # Bold for in progress items
+            @output.puts "#{indent}  #{@pastel.bold.yellow("#{num}.")} #{@pastel.bold(content)}"
+          when "pending"
+            # Regular for pending
+            @output.puts "#{indent}  #{@pastel.white("#{num}.")} #{content}"
+          else
+            # Fallback
+            @output.puts "#{indent}  #{num}. #{content}"
+          end
+        end
+      end
+
+      def extract_tool_from_entry(entry)
+        # Try to extract tool name from the entry
+        # First check if it has :tool directly
+        return entry[:tool] if entry[:tool]
+
+        # Otherwise look up from tool_call_id
+        tool_call_id = entry[:tool_call_id]
+        return unless tool_call_id
+
+        @recent_tool_calls[tool_call_id]
+      end
+
+      def display_response(content, indent)
+        lines = content.split("\n")
+
+        # Only truncate if flag is enabled
+        display_lines = if @truncate
+          if lines.length > 12
+            lines.first(12) + ["", @pastel.dim("... (#{lines.length - 12} more lines)")]
+          elsif content.length > 500
+            [content[0..500], "", @pastel.dim("... (#{content.length} total chars)")]
+          else
+            lines
+          end
+        else
+          lines
+        end
+
+        display_lines.each do |line|
+          @output.puts "#{indent}  #{line}"
+        end
+      end
+
+      def format_argument_value(value)
+        case value
+        when String
+          if @truncate && value.length > 300
+            lines = value.split("\n")
+            if lines.length > 3
+              preview = lines.first(3).join("\n")
+              "#{@pastel.white(preview)}\n#{@pastel.dim("        ... (#{lines.length} lines, #{value.length} chars)")}"
+            else
+              preview = value[0..300]
+              "#{@pastel.white(preview)}\n#{@pastel.dim("        ... (#{value.length} chars)")}"
+            end
+          else
+            @pastel.white(value)
+          end
+        when Array
+          @pastel.dim("[#{value.join(", ")}]")
+        when Hash
+          formatted = value.map { |k, v| "#{k}: #{v}" }.join(", ")
+          @pastel.dim("{#{formatted}}")
+        when Numeric
+          @pastel.white(value.to_s)
+        when TrueClass, FalseClass
+          @pastel.white(value.to_s)
+        when NilClass
+          @pastel.dim("nil")
+        else
+          @pastel.white(value.to_s)
+        end
+      end
+
+      def calculate_depth(agent)
+        @agents_seen.size == 1 ? 0 : 1
+      end
+
+      def get_agent_color(agent)
+        @agent_colors[agent] ||= begin
+          color = @color_palette[@next_color_index % @color_palette.length]
+          @next_color_index += 1
+          color
+        end
+      end
+
+      def print_header(swarm_name, lead_agent)
+        @output.puts
+        @output.puts @pastel.bold.bright_cyan("#{ICONS[:sparkles]} SwarmSDK - AI Agent Orchestration #{ICONS[:sparkles]}")
+        print_divider
+        @output.puts "#{@pastel.bold("Swarm:")} #{@pastel.cyan(swarm_name)}"
+        @output.puts "#{@pastel.bold("Lead Agent:")} #{@pastel.cyan(lead_agent)}"
+        @output.puts
+      end
+
+      def print_prompt(prompt)
+        @output.puts @pastel.bold("#{ICONS[:thinking]} Task Prompt:")
+        @output.puts @pastel.bright_white(prompt)
+        @output.puts
+      end
+
+      def print_divider
+        @output.puts @pastel.dim("─" * @terminal_width)
+      end
+
+      def print_result(result)
+        @output.puts
+        @output.puts @pastel.bold.green("#{ICONS[:success]} Execution Complete")
+        @output.puts
+
+        if result.content && !result.content.empty?
+          @output.puts @pastel.bold("#{ICONS[:response]} Final Response from #{@pastel.public_send(get_agent_color(result.agent.to_sym), result.agent)}:")
+          @output.puts
+          print_divider
+
+          # Render markdown if content looks like markdown
+          content_to_display = if looks_like_markdown?(result.content)
+            begin
+              TTY::Markdown.parse(result.content)
+            rescue StandardError
+              result.content
+            end
+          else
+            result.content
+          end
+
+          @output.puts content_to_display
+          print_divider
+          @output.puts
+        end
+      end
+
+      def print_summary(result)
+        @output.puts @pastel.bold("#{ICONS[:info]} Execution Summary:")
+        @output.puts
+
+        # Agent involvement with colors
+        agents_display = @agents_seen.map do |agent|
+          color = get_agent_color(agent)
+          @pastel.public_send(color, agent)
+        end.join(", ")
+
+        @output.puts "  #{ICONS[:agent]} #{@pastel.bold("Agents used:")} #{agents_display}"
+        @output.puts "  #{ICONS[:llm]} #{@pastel.bold("LLM Requests:")} #{result.llm_requests}"
+        @output.puts "  #{ICONS[:tool]} #{@pastel.bold("Tool Calls:")} #{result.tool_calls_count}"
+        @output.puts "  #{ICONS[:tokens]} #{@pastel.bold("Total Tokens:")} #{format_number(result.total_tokens)}"
+        @output.puts "  #{ICONS[:cost]} #{@pastel.bold("Total Cost:")} #{format_cost(result.total_cost)}"
+        @output.puts "  #{ICONS[:time]} #{@pastel.bold("Duration:")} #{format_duration(result.duration)}"
+
+        @output.puts
+      end
+
+      def print_error(error)
+        @output.puts
+        @output.puts @pastel.bold.red("#{ICONS[:error]} Execution Failed")
+        @output.puts
+        @output.puts @pastel.red("Error: #{error.class.name}")
+        @output.puts @pastel.red(error.message)
+        @output.puts
+
+        if error.backtrace
+          @output.puts @pastel.dim("Backtrace:")
+          error.backtrace.first(5).each do |line|
+            @output.puts @pastel.dim("  #{line}")
+          end
+          @output.puts
+        end
+      end
+
+      def looks_like_markdown?(text)
+        text.match?(/^#+\s|^\*\s|^-\s|^\d+\.\s|```|\[.+\]\(.+\)/)
+      end
+
+      def format_cost(cost)
+        if cost < 0.01
+          @pastel.green("$#{format("%.6f", cost)}")
+        elsif cost < 1.0
+          @pastel.yellow("$#{format("%.4f", cost)}")
+        else
+          @pastel.red("$#{format("%.2f", cost)}")
+        end
+      end
+
+      def format_context_percentage(percentage_string)
+        # Extract numeric value from percentage string (e.g., "12.5%" -> 12.5)
+        percentage = percentage_string.to_s.gsub("%", "").to_f
+
+        if percentage < 50
+          @pastel.green(percentage_string)
+        elsif percentage < 80
+          @pastel.yellow(percentage_string)
+        else
+          @pastel.red(percentage_string)
+        end
+      end
+
+      def format_duration(seconds)
+        if seconds < 1
+          "#{(seconds * 1000).round}ms"
+        elsif seconds < 60
+          "#{seconds.round(2)}s"
+        else
+          minutes = (seconds / 60).floor
+          secs = (seconds % 60).round
+          "#{minutes}m #{secs}s"
+        end
+      end
+
+      def format_number(num)
+        num.to_s.reverse.gsub(/(\d{3})(?=\d)/, '\\1,').reverse
+      end
+
+      def format_timestamp(timestamp)
+        return "" unless timestamp
+
+        time = Time.parse(timestamp)
+        time.strftime("[%H:%M:%S]")
+      rescue StandardError
+        ""
+      end
+
+      def print_event_divider
+        @output.puts @pastel.dim("  " + "·" * 60)
+      end
+
+      def start_spinner(indent, message)
+        return if @quiet
+
+        @active_spinner = TTY::Spinner.new("#{indent}:spinner #{message}", format: :dots, output: @output)
+        @active_spinner.auto_spin
+      end
+
+      def clear_spinner
+        return unless @active_spinner
+
+        @active_spinner.stop
+        @active_spinner = nil
+      end
+
+      def strip_system_reminders(content)
+        # Remove <system-reminder>...</system-reminder> blocks
+        content.gsub(%r{<system-reminder>.*?</system-reminder>}m, "").strip
+      end
+
+      def truncate_tool_result(lines, full_content)
+        # Truncate to first 2 lines and 300 characters
+        total_lines = lines.length
+        total_chars = full_content.length
+
+        # Take first 2 lines
+        preview_lines = lines.first(2)
+        preview_text = preview_lines.join("\n")
+
+        # Track what we're actually showing
+        shown_lines = preview_lines.length
+        shown_chars = preview_text.length
+
+        # If preview already exceeds 300 chars, truncate it
+        if preview_text.length > 300
+          preview_text = preview_text[0..299]
+          # Convert back to array with single truncated element
+          preview_lines = [preview_text]
+          shown_lines = 1 # We only show partial content now
+          shown_chars = 300
+        end
+
+        # Calculate what's hidden
+        if total_lines <= 2 && total_chars <= 300
+          # Nothing hidden, show as-is
+          preview_lines
+        else
+          # Build truncation message
+          hidden_parts = []
+
+          hidden_lines = total_lines - shown_lines
+          hidden_chars = total_chars - shown_chars
+
+          hidden_parts << "#{hidden_lines} more lines" if hidden_lines > 0
+          hidden_parts << "#{hidden_chars} more characters" if hidden_chars > 0
+
+          truncation_msg = @pastel.dim("... (#{hidden_parts.join(", ")})")
+
+          preview_lines + ["", truncation_msg]
+        end
+      end
+    end
+  end
+end