swarm_cli 2.0.0.pre.1 → 2.0.0

data/lib/swarm_cli/migrator.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module SwarmCLI
+  # Migrator converts Claude Swarm v1 YAML configurations to SwarmSDK v2 format.
+  #
+  # Key transformations:
+  # - version: 1 → 2
+  # - swarm.main → swarm.lead
+  # - swarm.instances → swarm.agents
+  # - For each agent:
+  #   - prompt → system_prompt
+  #   - connections → delegates_to
+  #   - mcps → mcp_servers
+  #   - allowed_tools → tools
+  #   - vibe → bypass_permissions
+  #   - reasoning_effort → parameters.reasoning
+  #
+  class Migrator
+    attr_reader :input_path
+
+    def initialize(input_path)
+      @input_path = input_path
+    end
+
+    def migrate
+      # Read and parse v1 YAML
+      v1_config = YAML.load_file(input_path)
+
+      # Validate it's a v1 config
+      unless v1_config["version"] == 1
+        raise SwarmCLI::ExecutionError, "Input file is not a v1 configuration (version: #{v1_config["version"]})"
+      end
+
+      # Build v2 config
+      v2_config = {
+        "version" => 2,
+        "swarm" => migrate_swarm(v1_config["swarm"]),
+      }
+
+      # Convert to YAML string
+      YAML.dump(v2_config)
+    end
+
+    private
+
+    def migrate_swarm(swarm)
+      v2_swarm = {
+        "name" => swarm["name"],
+        "lead" => swarm["main"], # main → lead
+      }
+
+      # Migrate instances → agents
+      if swarm["instances"]
+        v2_swarm["agents"] = migrate_agents(swarm["instances"])
+      end
+
+      v2_swarm
+    end
+
+    def migrate_agents(instances)
+      agents = {}
+
+      instances.each do |name, config|
+        agents[name] = migrate_agent(config)
+      end
+
+      agents
+    end
+
+    def migrate_agent(config)
+      agent = {}
+
+      # Copy fields that stay the same
+      agent["description"] = config["description"] if config["description"]
+      agent["directory"] = config["directory"] if config["directory"]
+      agent["model"] = config["model"] if config["model"]
+
+      # Migrate connections → delegates_to
+      agent["delegates_to"] = if config["connections"]
+        config["connections"]
+      elsif config.key?("connections") && config["connections"].nil?
+        # Explicit nil becomes empty array
+        []
+      else
+        # No connections field - add empty array for clarity
+        []
+      end
+
+      # Migrate prompt → system_prompt
+      agent["system_prompt"] = config["prompt"] if config["prompt"]
+
+      # Migrate mcps → mcp_servers
+      if config["mcps"]
+        agent["mcp_servers"] = config["mcps"]
+      end
+
+      # Migrate allowed_tools → tools
+      if config["allowed_tools"]
+        agent["tools"] = config["allowed_tools"]
+      end
+
+      # Migrate vibe → bypass_permissions
+      if config["vibe"]
+        agent["bypass_permissions"] = config["vibe"]
+      end
+
+      # Migrate reasoning_effort → parameters.reasoning
+      if config["reasoning_effort"]
+        agent["parameters"] ||= {}
+        agent["parameters"]["reasoning"] = config["reasoning_effort"]
+      end
+
+      # Copy any other fields (like provider, base_url, etc. if they exist)
+      # These are rare in v1 but handle them gracefully
+      ["provider", "base_url", "api_version"].each do |field|
+        agent[field] = config[field] if config[field]
+      end
+
+      # Handle parameters field - merge if it exists
+      if config["parameters"]
+        agent["parameters"] ||= {}
+        agent["parameters"].merge!(config["parameters"])
+      end
+
+      # Copy tools and permissions if they exist (rare in v1)
+      agent["tools"] = config["tools"] if config["tools"] && !config["allowed_tools"]
+      agent["permissions"] = config["permissions"] if config["permissions"]
+
+      agent
+    end
+  end
+end

data/lib/swarm_cli/options.rb

@@ -8,9 +8,11 @@ module SwarmCLI
       program "swarm"
       command "run"
       desc "Execute a swarm with AI agents"
-      example "swarm run team.yml -p 'Build a REST API'"
-      example "echo 'Build a REST API' | swarm run team.yml"
-      example "swarm run team.yml -p 'Refactor code' --output-format json"
+      example "swarm run team.yml                              # Interactive REPL"
+      example "swarm run team.yml 'Build a REST API'          # REPL with initial message"
+      example "echo 'Build API' | swarm run team.yml          # REPL with piped message"
+      example "swarm run team.yml -p 'Build a REST API'       # Non-interactive mode"
+      example "echo 'Build API' | swarm run team.yml -p       # Non-interactive from stdin"
     end
 
     argument :config_file do
@@ -18,10 +20,15 @@ module SwarmCLI
       required
     end
 
-    option :prompt do
+    argument :prompt_text do
+      desc "Initial message for REPL or prompt for execution (optional)"
+      optional
+    end
+
+    flag :prompt do
       short "-p"
-      long "--prompt PROMPT"
-      desc "Task prompt for the swarm (if not provided, reads from stdin)"
+      long "--prompt"
+      desc "Run in non-interactive mode (reads from argument or stdin)"
     end
 
     option :output_format do
@@ -62,24 +69,53 @@ module SwarmCLI
     def validate!
       errors = []
 
-      # At least one of prompt or stdin must be provided
-      if !prompt && $stdin.tty?
-        errors << "Prompt is required. Use -p or provide input via stdin."
-      end
-
       # Config file must exist
       if config_file && !File.exist?(config_file)
         errors << "Configuration file not found: #{config_file}"
       end
 
+      # Interactive mode cannot be used with JSON output
+      if interactive_mode? && output_format == "json"
+        errors << "Interactive mode is not compatible with --output-format json"
+      end
+
+      # Non-interactive mode requires a prompt
+      if non_interactive_mode? && !has_prompt_source?
+        errors << "Non-interactive mode (-p) requires a prompt (provide as argument or via stdin)"
+      end
+
       unless errors.empty?
         raise SwarmCLI::ExecutionError, errors.join("\n")
       end
     end
 
+    def interactive_mode?
+      # Interactive (REPL) mode when -p flag is NOT present
+      !params[:prompt]
+    end
+
+    def non_interactive_mode?
+      # Non-interactive mode when -p flag IS present
+      params[:prompt] == true
+    end
+
+    def initial_message
+      # For REPL mode - get initial message from argument or stdin (if piped)
+      return unless interactive_mode?
+
+      if params[:prompt_text] && !params[:prompt_text].empty?
+        params[:prompt_text]
+      elsif !$stdin.tty?
+        $stdin.read.strip
+      end
+    end
+
     def prompt_text
-      @prompt_text ||= if prompt
-        prompt
+      # For non-interactive mode - get prompt from argument or stdin
+      raise SwarmCLI::ExecutionError, "Cannot get prompt_text in interactive mode" if interactive_mode?
+
+      @prompt_text ||= if params[:prompt_text] && !params[:prompt_text].empty?
+        params[:prompt_text]
       elsif !$stdin.tty?
         $stdin.read.strip
       else
@@ -87,15 +123,15 @@ module SwarmCLI
       end
     end
 
+    def has_prompt_source?
+      (params[:prompt_text] && !params[:prompt_text].empty?) || !$stdin.tty?
+    end
+
     # Convenience accessors that delegate to params
     def config_file
       params[:config_file]
     end
 
-    def prompt
-      params[:prompt]
-    end
-
     def output_format
       params[:output_format]
     end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module SwarmCLI
+  module UI
+    module Components
+      # Renders agent names with consistent colors using cache
+      class AgentBadge
+        def initialize(pastel:, color_cache:)
+          @pastel = pastel
+          @color_cache = color_cache
+        end
+
+        # Render agent name with cached color
+        # architect → "architect" (in cyan)
+        def render(agent_name, icon: nil, bold: false)
+          color = @color_cache.get(agent_name)
+          text = icon ? "#{icon} #{agent_name}" : agent_name.to_s
+
+          styled = @pastel.public_send(color, text)
+          styled = @pastel.bold(styled) if bold
+
+          styled
+        end
+
+        # Render agent list (comma-separated, each colored)
+        # [architect, worker] → "architect, worker" (each colored differently)
+        def render_list(agent_names, separator: ", ")
+          agent_names.map { |name| render(name) }.join(separator)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module SwarmCLI
+  module UI
+    module Components
+      # Renders multi-line content blocks with indentation
+      class ContentBlock
+        def initialize(pastel:)
+          @pastel = pastel
+        end
+
+        # Render key-value pairs as indented block
+        #   Arguments:
+        #     file_path: "config.yml"
+        #     mode: "read"
+        def render_hash(data, indent: 0, label: nil, truncate: false, max_value_length: 300)
+          return "" if data.nil? || data.empty?
+
+          lines = []
+          prefix = "  " * indent
+
+          # Optional label
+          lines << "#{prefix}#{@pastel.dim("#{label}:")}" if label
+
+          # Render each key-value pair
+          data.each do |key, value|
+            formatted_value = format_value(value, truncate: truncate, max_length: max_value_length)
+            lines << "#{prefix}  #{@pastel.cyan("#{key}:")} #{formatted_value}"
+          end
+
+          lines.join("\n")
+        end
+
+        # Render multi-line text with indentation
+        def render_text(text, indent: 0, color: :white, truncate: false, max_lines: nil, max_chars: nil)
+          return "" if text.nil? || text.empty?
+
+          prefix = "  " * indent
+          content = text
+
+          # Strip system reminders
+          content = Formatters::Text.strip_system_reminders(content)
+          return "" if content.empty?
+
+          # Apply truncation if requested
+          if truncate
+            content, truncation_msg = Formatters::Text.truncate(
+              content,
+              lines: max_lines,
+              chars: max_chars,
+            )
+          end
+
+          # Render lines
+          lines = content.split("\n").map do |line|
+            "#{prefix}  #{@pastel.public_send(color, line)}"
+          end
+
+          # Add truncation message if present
+          lines << "#{prefix}  #{@pastel.dim(truncation_msg)}" if truncation_msg
+
+          lines.join("\n")
+        end
+
+        # Render list items
+        #   • Item 1
+        #   • Item 2
+        def render_list(items, indent: 0, bullet: UI::Icons::BULLET, color: :white)
+          return "" if items.nil? || items.empty?
+
+          prefix = "  " * indent
+
+          items.map do |item|
+            "#{prefix}  #{@pastel.public_send(color, "#{bullet} #{item}")}"
+          end.join("\n")
+        end
+
+        private
+
+        def format_value(value, truncate:, max_length:)
+          case value
+          when String
+            format_string_value(value, truncate: truncate, max_length: max_length)
+          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 format_string_value(value, truncate:, max_length:)
+          return @pastel.white(value) unless truncate
+          return @pastel.white(value) if value.length <= max_length
+
+          lines = value.split("\n")
+
+          if lines.length > 3
+            # Multi-line content - show first 3 lines
+            preview = lines.first(3).join("\n")
+            line_info = "(#{lines.length} lines, #{value.length} chars)"
+            "#{@pastel.white(preview)}\n        #{@pastel.dim("... #{line_info}")}"
+          else
+            # Single/few lines - character truncation
+            preview = value[0...max_length]
+            "#{@pastel.white(preview)}\n        #{@pastel.dim("... (#{value.length} chars)")}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module SwarmCLI
+  module UI
+    module Components
+      # Divider rendering for visual separation
+      # Only horizontal lines - no side borders per design constraint
+      class Divider
+        def initialize(pastel:, terminal_width: 80)
+          @pastel = pastel
+          @terminal_width = terminal_width
+        end
+
+        # Full-width divider line
+        # ────────────────────────────────────────────────────────────
+        def full(char: "─", color: :dim)
+          @pastel.public_send(color, char * @terminal_width)
+        end
+
+        # Event separator (dotted, indented)
+        #   ····························································
+        def event(indent: 0, char: "·")
+          prefix = "  " * indent
+          line = char * 60
+          "#{prefix}#{@pastel.dim(line)}"
+        end
+
+        # Section divider with centered label
+        # ───────── Section Name ─────────
+        def section(label, char: "─", color: :dim)
+          label_width = label.length + 2 # Add spaces around label
+          total_line_width = @terminal_width
+          side_width = (total_line_width - label_width) / 2
+
+          left = char * side_width
+          right = char * (total_line_width - label_width - side_width)
+
+          @pastel.public_send(color, "#{left} #{label} #{right}")
+        end
+
+        # Top border only (no sides)
+        # ────────────────────────────────────────────────────────────
+        # Content here
+        def top(char: "─", color: :dim)
+          @pastel.public_send(color, char * @terminal_width)
+        end
+
+        # Bottom border only (no sides)
+        # Content here
+        # ────────────────────────────────────────────────────────────
+        def bottom(char: "─", color: :dim)
+          @pastel.public_send(color, char * @terminal_width)
+        end
+      end
+    end
+  end
+end

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