claude_swarm 1.0.1 → 1.0.2

data/lib/swarm_cli/mcp_serve_options.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module SwarmCLI
+  # Options for the `swarm mcp serve` command
+  class McpServeOptions
+    include TTY::Option
+
+    usage do
+      program "swarm"
+      commands "mcp", "serve"
+      desc "Start an MCP server exposing swarm lead agent as a tool"
+      example "swarm mcp serve team.yml"
+    end
+
+    argument :config_file do
+      desc "Path to swarm configuration file (YAML)"
+      required
+    end
+
+    option :help do
+      short "-h"
+      long "--help"
+      desc "Print usage"
+    end
+
+    def validate!
+      errors = []
+
+      # Config file must exist
+      if config_file && !File.exist?(config_file)
+        errors << "Configuration file not found: #{config_file}"
+      end
+
+      unless errors.empty?
+        raise SwarmCLI::ExecutionError, errors.join("\n")
+      end
+    end
+
+    # Convenience accessor
+    def config_file
+      params[:config_file]
+    end
+  end
+end

data/lib/swarm_cli/mcp_tools_options.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module SwarmCLI
+  # Options for the `swarm mcp tools` command
+  class McpToolsOptions
+    include TTY::Option
+
+    usage do
+      program "swarm"
+      commands "mcp", "tools"
+      desc "Start an MCP server exposing SwarmSDK tools"
+      example "swarm mcp tools"
+      example "swarm mcp tools Read Write Bash"
+      example "swarm mcp tools ScratchpadWrite,ScratchpadRead"
+    end
+
+    argument :tool_names do
+      desc "Optional tool names to expose (defaults to all non-special tools)"
+      optional
+      arity :any
+    end
+
+    option :help do
+      short "-h"
+      long "--help"
+      desc "Print usage"
+    end
+
+    def validate!
+      errors = []
+
+      # Validate tool names if provided
+      if tool_names&.any?
+        invalid_tools = SwarmSDK::Tools::Registry.validate(tool_names)
+        if invalid_tools.any?
+          available = SwarmSDK::Tools::Registry.available_names.join(", ")
+          errors << "Invalid tool names: #{invalid_tools.join(", ")}. Available: #{available}"
+        end
+      end
+
+      unless errors.empty?
+        raise SwarmCLI::ExecutionError, errors.join("\n")
+      end
+    end
+
+    # Convenience accessor
+    def tool_names
+      names = params[:tool_names]
+      return [] if names.nil? || names.empty?
+
+      # TTY::Option might return a string or array
+      names_array = names.is_a?(Array) ? names : [names]
+
+      # Support comma-separated tool names in addition to space-separated
+      # e.g., both "swarm mcp tools Read Write" and "swarm mcp tools Read,Write" work
+      names_array.flat_map { |name| name.to_s.split(",") }.map(&:strip).reject(&:empty?)
+    end
+  end
+end

data/lib/swarm_cli/migrate_options.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module SwarmCLI
+  class MigrateOptions
+    include TTY::Option
+
+    usage do
+      program "swarm"
+      command "migrate"
+      desc "Migrate a Claude Swarm v1 configuration to SwarmSDK v2 format"
+      example "swarm migrate old-config.yml"
+      example "swarm migrate old-config.yml --output new-config.yml"
+    end
+
+    argument :input_file do
+      desc "Path to Claude Swarm v1 configuration file (YAML)"
+      required
+    end
+
+    option :output do
+      short "-o"
+      long "--output FILE"
+      desc "Output file path (if not specified, prints to stdout)"
+    end
+
+    option :help do
+      short "-h"
+      long "--help"
+      desc "Print usage"
+    end
+
+    def validate!
+      errors = []
+
+      # Input file must exist
+      if input_file && !File.exist?(input_file)
+        errors << "Input file not found: #{input_file}"
+      end
+
+      unless errors.empty?
+        raise SwarmCLI::ExecutionError, errors.join("\n")
+      end
+    end
+
+    # Convenience accessors that delegate to params
+    def input_file
+      params[:input_file]
+    end
+
+    def output
+      params[:output]
+    end
+  end
+end

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

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module SwarmCLI
+  class Options
+    include TTY::Option
+
+    usage do
+      program "swarm"
+      command "run"
+      desc "Execute a swarm with AI agents"
+      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
+      desc "Path to swarm configuration file (YAML)"
+      required
+    end
+
+    argument :prompt_text do
+      desc "Initial message for REPL or prompt for execution (optional)"
+      optional
+    end
+
+    flag :prompt do
+      short "-p"
+      long "--prompt"
+      desc "Run in non-interactive mode (reads from argument or stdin)"
+    end
+
+    option :output_format do
+      long "--output-format FORMAT"
+      desc "Output format: 'human' (default) or 'json'"
+      default "human"
+      permit ["human", "json"]
+    end
+
+    option :help do
+      short "-h"
+      long "--help"
+      desc "Print usage"
+    end
+
+    option :version do
+      short "-v"
+      long "--version"
+      desc "Print version"
+    end
+
+    flag :quiet do
+      short "-q"
+      long "--quiet"
+      desc "Suppress progress output (human format only)"
+    end
+
+    flag :truncate do
+      long "--truncate"
+      desc "Truncate long outputs for concise view"
+    end
+
+    flag :verbose do
+      long "--verbose"
+      desc "Show system reminders and additional debug information"
+    end
+
+    def validate!
+      errors = []
+
+      # 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
+      # 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
+        raise SwarmCLI::ExecutionError, "No prompt provided"
+      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 output_format
+      params[:output_format]
+    end
+
+    def quiet?
+      params[:quiet]
+    end
+
+    def truncate?
+      params[:truncate]
+    end
+
+    def verbose?
+      params[:verbose]
+    end
+  end
+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