swarm_memory 2.1.4 → 2.1.6

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

@@ -1,62 +0,0 @@
-# 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

@@ -1,70 +0,0 @@
-# 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

@@ -1,49 +0,0 @@
-# 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

@@ -1,58 +0,0 @@
-# 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

@@ -1,77 +0,0 @@
-# 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

@@ -1,73 +0,0 @@
-# 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

@@ -1,36 +0,0 @@
-# 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 = "🗜️"
-    end
-  end
-end

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

@@ -1,188 +0,0 @@
-# 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

@@ -1,45 +0,0 @@
-# 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

@@ -1,40 +0,0 @@
-# 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