swarm_cli 2.1.13 → 3.0.0.alpha2

data/lib/swarm_cli/commands/mcp_serve.rb

@@ -1,130 +0,0 @@
-# frozen_string_literal: true
-
-module SwarmCLI
-  module Commands
-    # McpServe command starts an MCP server that exposes the swarm's lead agent as a tool.
-    #
-    # Usage:
-    #   swarm mcp serve config.yml
-    #
-    # The server uses stdio transport and exposes a "swarm" tool that executes tasks
-    # through the configured lead agent.
-    class McpServe
-      attr_reader :options
-
-      def initialize(options)
-        @options = options
-      end
-
-      def execute
-        # Validate options
-        options.validate!
-
-        # Load swarm configuration to validate it
-        config_path = options.config_file
-        unless File.exist?(config_path)
-          $stderr.puts "Error: Configuration file not found: #{config_path}"
-          exit(1)
-        end
-
-        # Validate the swarm configuration
-        begin
-          SwarmSDK.load_file(config_path)
-        rescue SwarmSDK::ConfigurationError => e
-          $stderr.puts "Error: Invalid swarm configuration: #{e.message}"
-          exit(1)
-        end
-
-        # MCP servers should be quiet - stdout is reserved for MCP protocol
-        # Errors will still be logged to stderr
-
-        # Start the MCP server
-        start_mcp_server(config_path)
-      rescue Interrupt
-        # User cancelled (Ctrl+C) - silent exit
-        exit(130)
-      rescue StandardError => e
-        # Unexpected errors - always log to stderr
-        $stderr.puts "Fatal error: #{e.message}"
-        $stderr.puts e.backtrace.first(5).join("\n") if ENV["DEBUG"]
-        exit(1)
-      end
-
-      private
-
-      def start_mcp_server(config_path)
-        require "fast_mcp"
-
-        # Create the server
-        server = FastMcp::Server.new(
-          name: "swarm-mcp-server",
-          version: SwarmCLI::VERSION,
-        )
-
-        # Register the swarm tool
-        tool_class = create_swarm_tool_class(config_path)
-        server.register_tool(tool_class)
-
-        # Start with stdio transport (default)
-        server.start
-      end
-
-      def create_swarm_tool_class(config_path)
-        # Create a tool class dynamically with the config path bound
-        Class.new(FastMcp::Tool) do
-          # Explicit tool name required for anonymous classes
-          tool_name "task"
-
-          description "Execute tasks through the SwarmSDK lead agent"
-
-          arguments do
-            required(:task).filled(:string).description("The task or prompt to execute")
-            optional(:description).filled(:string).description("Brief description of the task")
-            optional(:thinking_budget).filled(:string, included_in?: ["think", "think hard", "think harder", "ultrathink"]).description("Thinking budget level")
-          end
-
-          # Store config path as class variable
-          @config_path = config_path
-
-          class << self
-            attr_accessor :config_path
-          end
-
-          define_method(:call) do |task:, description: nil, thinking_budget: nil|
-            # Load swarm for each execution (ensures fresh state)
-            swarm = SwarmSDK.load_file(self.class.config_path)
-
-            # Build prompt with thinking budget if provided
-            prompt = task
-            if thinking_budget
-              prompt = "<thinking_budget>#{thinking_budget}</thinking_budget>\n\n#{task}"
-            end
-
-            # Execute the task (description is metadata only, not passed to execute)
-            result = swarm.execute(prompt)
-
-            # Check for errors
-            if result.failure?
-              {
-                success: false,
-                error: result.error.message,
-                task: task,
-                description: description,
-              }
-            else
-              # On success, return just the content string
-              result.content
-            end
-          rescue StandardError => e
-            {
-              success: false,
-              error: e.message,
-              task: task,
-              description: description,
-            }
-          end
-        end
-      end
-    end
-  end
-end

data/lib/swarm_cli/commands/mcp_tools.rb

@@ -1,148 +0,0 @@
-# frozen_string_literal: true
-
-module SwarmCLI
-  module Commands
-    # McpTools command starts an MCP server that exposes SwarmSDK tools.
-    #
-    # Usage:
-    #   swarm mcp tools              # Expose all available tools
-    #   swarm mcp tools Bash Grep    # Expose only Bash and Grep
-    #
-    # The server uses stdio transport and exposes SwarmSDK tools as MCP tools.
-    class McpTools
-      attr_reader :options
-
-      def initialize(options)
-        @options = options
-        # Create volatile scratchpad for MCP server
-        # Note: Scratchpad is always volatile - data is not persisted between sessions
-        @scratchpad = SwarmSDK::Tools::Stores::ScratchpadStorage.new
-      end
-
-      def execute
-        # Validate options
-        options.validate!
-
-        # Determine which tools to expose
-        tools_to_expose = determine_tools
-
-        if tools_to_expose.empty?
-          $stderr.puts "Error: No tools available to expose"
-          exit(1)
-        end
-
-        # Start the MCP server
-        start_mcp_server(tools_to_expose)
-      rescue Interrupt
-        # User cancelled (Ctrl+C) - silent exit
-        exit(130)
-      rescue StandardError => e
-        # Unexpected errors - always log to stderr
-        $stderr.puts "Fatal error: #{e.message}"
-        $stderr.puts e.backtrace.first(5).join("\n") if ENV["DEBUG"]
-        exit(1)
-      end
-
-      private
-
-      def determine_tools
-        if options.tool_names.any?
-          # Use specified tools
-          options.tool_names.map(&:to_sym)
-        else
-          # Default: expose all available tools
-          SwarmSDK::Tools::Registry.available_names
-        end
-      end
-
-      def start_mcp_server(tool_names)
-        require "fast_mcp"
-
-        # Create the server
-        server = FastMcp::Server.new(
-          name: "swarm-tools-server",
-          version: SwarmCLI::VERSION,
-        )
-
-        # Register each tool
-        tool_names.each do |tool_name|
-          tool_class = create_mcp_tool_wrapper(tool_name)
-          server.register_tool(tool_class)
-        end
-
-        # Start with stdio transport (default)
-        server.start
-      end
-
-      def create_special_tool_instance(tool_name)
-        case tool_name
-        when :Read
-          SwarmSDK::Tools::Read.create_for_agent(:mcp)
-        when :Write
-          SwarmSDK::Tools::Write.create_for_agent(:mcp)
-        when :Edit
-          SwarmSDK::Tools::Edit.create_for_agent(:mcp)
-        when :MultiEdit
-          SwarmSDK::Tools::MultiEdit.create_for_agent(:mcp)
-        when :TodoWrite
-          SwarmSDK::Tools::TodoWrite.create_for_agent(:mcp)
-        when :ScratchpadWrite
-          SwarmSDK::Tools::ScratchpadWrite.create_for_scratchpad(@scratchpad)
-        when :ScratchpadRead
-          SwarmSDK::Tools::ScratchpadRead.create_for_scratchpad(@scratchpad)
-        when :ScratchpadList
-          SwarmSDK::Tools::ScratchpadList.create_for_scratchpad(@scratchpad)
-        else
-          raise "Unknown special tool: #{tool_name}"
-        end
-      end
-
-      def create_mcp_tool_wrapper(tool_name)
-        sdk_tool_class_or_special = SwarmSDK::Tools::Registry.get(tool_name)
-
-        # Get the actual tool instance for special tools
-        sdk_tool = if sdk_tool_class_or_special == :special
-          create_special_tool_instance(tool_name)
-        else
-          sdk_tool_class_or_special.new
-        end
-
-        # Get tool metadata
-        tool_description = sdk_tool.respond_to?(:description) ? sdk_tool.description : "SwarmSDK #{tool_name} tool"
-        tool_params = sdk_tool.class.respond_to?(:parameters) ? sdk_tool.class.parameters : {}
-
-        # Create an MCP tool wrapper
-        Class.new(FastMcp::Tool) do
-          tool_name tool_name.to_s
-          description tool_description
-
-          # Map RubyLLM parameters to fast-mcp arguments
-          arguments do
-            tool_params.each do |param_name, param_obj|
-              param_type = param_obj.type == "integer" ? :integer : :string
-              if param_obj.required
-                required(param_name).filled(param_type).description(param_obj.description || "")
-              else
-                optional(param_name).filled(param_type).description(param_obj.description || "")
-              end
-            end
-          end
-
-          # Capture sdk_tool in closure
-          define_method(:call) do |**kwargs|
-            result = sdk_tool.execute(**kwargs)
-
-            # Return string output for MCP
-            if result.is_a?(Hash)
-              result[:output] || result[:content] || result[:files]&.join("\n") || result.to_s
-            else
-              result.to_s
-            end
-          rescue StandardError => e
-            "Error: #{e.message}"
-          end
-        end
-      end
-    end
-  end
-end

data/lib/swarm_cli/commands/migrate.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-module SwarmCLI
-  module Commands
-    # Migrate command converts Claude Swarm v1 configurations to SwarmSDK v2 format.
-    #
-    # Usage:
-    #   swarm migrate old-config.yml
-    #   swarm migrate old-config.yml --output new-config.yml
-    #
-    class Migrate
-      attr_reader :options
-
-      def initialize(options)
-        @options = options
-      end
-
-      def execute
-        # Validate options
-        options.validate!
-
-        # Create migrator
-        migrator = Migrator.new(options.input_file)
-
-        # Perform migration
-        migrated_yaml = migrator.migrate
-
-        # Write to output file or stdout
-        if options.output
-          File.write(options.output, migrated_yaml)
-          $stderr.puts "✓ Migration complete! Converted configuration saved to: #{options.output}"
-        else
-          puts migrated_yaml
-        end
-
-        exit(0)
-      rescue SwarmCLI::ExecutionError => e
-        handle_error(e)
-        exit(1)
-      rescue Interrupt
-        $stderr.puts "\n\nMigration cancelled by user"
-        exit(130)
-      rescue StandardError => e
-        handle_error(e)
-        exit(1)
-      end
-
-      private
-
-      def handle_error(error)
-        $stderr.puts "Error: #{error.message}"
-      end
-    end
-  end
-end

data/lib/swarm_cli/commands/run.rb

@@ -1,173 +0,0 @@
-# frozen_string_literal: true
-
-module SwarmCLI
-  module Commands
-    # Run command executes a swarm with the given configuration and prompt.
-    #
-    # Supports both YAML (.yml, .yaml) and Ruby DSL (.rb) configuration files.
-    #
-    # Usage:
-    #   swarm run config.yml -p "Build a REST API"
-    #   swarm run config.rb -p "Build a REST API"
-    #   echo "Build a REST API" | swarm run config.yml
-    #   swarm run config.yml -p "Task" --output-format json
-    #
-    class Run
-      attr_reader :options
-
-      def initialize(options)
-        @options = options
-      end
-
-      def execute
-        # Validate options
-        options.validate!
-
-        # Load swarm configuration
-        swarm = load_swarm
-
-        # Check if interactive mode (no prompt provided and stdin is a tty)
-        if options.interactive_mode?
-          run_interactive_mode(swarm)
-        else
-          run_non_interactive_mode(swarm)
-        end
-      rescue SwarmSDK::ConfigurationError, SwarmSDK::AgentNotFoundError => e
-        # Configuration errors - show user-friendly message
-        handle_error(e, formatter: create_formatter)
-        exit(1)
-      rescue SwarmCLI::ExecutionError => e
-        # CLI-specific errors (e.g., missing prompt)
-        handle_error(e, formatter: create_formatter)
-        exit(1)
-      rescue Interrupt
-        # User cancelled (Ctrl+C)
-        $stderr.puts "\n\nExecution cancelled by user"
-        exit(130)
-      rescue StandardError => e
-        # Unexpected errors
-        handle_error(e, formatter: create_formatter)
-        exit(1)
-      end
-
-      private
-
-      def run_interactive_mode(swarm)
-        # Launch the interactive REPL with optional initial message
-        initial_message = options.initial_message
-        repl = SwarmCLI::InteractiveREPL.new(
-          swarm: swarm,
-          options: options,
-          initial_message: initial_message,
-        )
-        repl.run
-        exit(0)
-      end
-
-      def run_non_interactive_mode(swarm)
-        # Create formatter based on output format
-        formatter = create_formatter
-
-        # Get prompt text
-        prompt = options.prompt_text
-
-        # Notify formatter of start
-        formatter.on_start(
-          config_path: options.config_file,
-          swarm_name: swarm.name,
-          lead_agent: swarm.lead_agent,
-          prompt: prompt,
-        )
-
-        # Emit validation warnings before execution
-        emit_validation_warnings(swarm, formatter)
-
-        # Execute swarm with logging
-        start_time = Time.now
-        result = swarm.execute(prompt) do |log_entry|
-          # Skip model warnings - already emitted above
-          next if log_entry[:type] == "model_lookup_warning"
-
-          formatter.on_log(log_entry)
-        end
-
-        # Check for errors
-        if result.failure?
-          duration = Time.now - start_time
-          formatter.on_error(error: result.error, duration: duration)
-          exit(1)
-        end
-
-        # Notify formatter of success
-        formatter.on_success(result: result)
-
-        # Exit successfully
-        exit(0)
-      end
-
-      def load_swarm
-        config_path = options.config_file
-
-        ConfigLoader.load(config_path)
-      rescue SwarmCLI::ConfigurationError => e
-        # ConfigLoader already provides good context
-        raise SwarmCLI::ExecutionError, e.message
-      rescue SwarmSDK::ConfigurationError => e
-        # SDK errors - add context
-        raise SwarmCLI::ExecutionError, "Configuration error: #{e.message}"
-      end
-
-      def create_formatter
-        case options.output_format
-        when "json"
-          Formatters::JsonFormatter.new
-        when "human"
-          Formatters::HumanFormatter.new(
-            quiet: options.quiet?,
-            truncate: options.truncate?,
-            verbose: options.verbose?,
-          )
-        else
-          raise SwarmCLI::ExecutionError, "Unknown output format: #{options.output_format}"
-        end
-      end
-
-      def emit_validation_warnings(swarm, formatter)
-        # Setup temporary logging to capture and emit warnings
-        SwarmSDK::LogCollector.subscribe(filter: { type: "model_lookup_warning" }) do |log_entry|
-          formatter.on_log(log_entry)
-        end
-
-        SwarmSDK::LogStream.emitter = SwarmSDK::LogCollector
-
-        # Emit validation warnings as log events
-        swarm.emit_validation_warnings
-
-        # Clean up
-        SwarmSDK::LogCollector.reset!
-        SwarmSDK::LogStream.reset!
-      rescue StandardError
-        # Ignore errors during validation emission
-        begin
-          SwarmSDK::LogCollector.reset!
-        rescue
-          nil
-        end
-        begin
-          SwarmSDK::LogStream.reset!
-        rescue
-          nil
-        end
-      end
-
-      def handle_error(error, formatter: nil)
-        if formatter
-          formatter.on_error(error: error)
-        else
-          # Fallback if formatter not available
-          $stderr.puts "Error: #{error.message}"
-        end
-      end
-    end
-  end
-end

data/lib/swarm_cli/config_loader.rb

@@ -1,98 +0,0 @@
-# frozen_string_literal: true
-
-module SwarmCLI
-  # ConfigLoader handles loading swarm configurations from both YAML and Ruby DSL files.
-  #
-  # Supports:
-  # - YAML files (.yml, .yaml) - loaded via SwarmSDK.load_file
-  # - Ruby DSL files (.rb) - executed and expected to return a SwarmSDK::Swarm or SwarmSDK::Workflow instance
-  #
-  # @example Load YAML config
-  #   swarm = ConfigLoader.load("config.yml")
-  #
-  # @example Load Ruby DSL config
-  #   swarm = ConfigLoader.load("config.rb")
-  #
-  class ConfigLoader
-    class << self
-      # Load a swarm configuration from file (YAML or Ruby DSL)
-      #
-      # Detects file type by extension:
-      # - .yml, .yaml -> Load as YAML using SwarmSDK.load_file
-      # - .rb -> Execute as Ruby DSL and expect SwarmSDK::Swarm or SwarmSDK::Workflow instance
-      #
-      # @param path [String, Pathname] Path to configuration file
-      # @return [SwarmSDK::Swarm, SwarmSDK::Workflow] Configured swarm or workflow instance
-      # @raise [SwarmCLI::ConfigurationError] If file not found or invalid format
-      def load(path)
-        path = Pathname.new(path).expand_path
-
-        unless path.exist?
-          raise ConfigurationError, "Configuration file not found: #{path}"
-        end
-
-        case path.extname.downcase
-        when ".yml", ".yaml"
-          load_yaml(path)
-        when ".rb"
-          load_ruby_dsl(path)
-        else
-          raise ConfigurationError,
-            "Unsupported configuration file format: #{path.extname}. " \
-              "Supported formats: .yml, .yaml (YAML), .rb (Ruby DSL)"
-        end
-      end
-
-      private
-
-      # Load YAML configuration file
-      #
-      # @param path [Pathname] Path to YAML file
-      # @return [SwarmSDK::Swarm] Configured swarm instance
-      def load_yaml(path)
-        SwarmSDK.load_file(path.to_s)
-      rescue SwarmSDK::ConfigurationError => e
-        # Re-raise with CLI context
-        raise ConfigurationError, "Configuration error in #{path}: #{e.message}"
-      end
-
-      # Load Ruby DSL configuration file
-      #
-      # Executes the Ruby file in a clean binding and expects it to return
-      # a SwarmSDK::Swarm or SwarmSDK::Workflow instance. The file should
-      # use SwarmSDK.build or SwarmSDK.workflow or create a Swarm/Workflow instance directly.
-      #
-      # @param path [Pathname] Path to Ruby DSL file
-      # @return [SwarmSDK::Swarm, SwarmSDK::Workflow] Configured swarm or workflow instance
-      # @raise [ConfigurationError] If file doesn't return a valid instance
-      def load_ruby_dsl(path)
-        # Read the file content
-        content = path.read
-
-        # Execute in a clean binding with SwarmSDK available
-        # This allows the DSL file to use SwarmSDK.build or SwarmSDK.workflow directly
-        result = eval(content, binding, path.to_s, 1) # rubocop:disable Security/Eval
-
-        # Validate result is a Swarm or Workflow instance
-        # Both have the same execute(prompt) interface
-        unless result.is_a?(SwarmSDK::Swarm) || result.is_a?(SwarmSDK::Workflow)
-          raise ConfigurationError,
-            "Ruby DSL file must return a SwarmSDK::Swarm or SwarmSDK::Workflow instance. " \
-              "Got: #{result.class}. " \
-              "Use: SwarmSDK.build { ... } or SwarmSDK.workflow { ... }"
-        end
-
-        result
-      rescue SwarmSDK::ConfigurationError => e
-        # Re-raise SDK configuration errors with CLI context
-        raise ConfigurationError, "Configuration error in #{path}: #{e.message}"
-      rescue SyntaxError => e
-        # Ruby syntax errors
-        raise ConfigurationError, "Syntax error in #{path}: #{e.message}"
-      rescue StandardError => e
-        # Other Ruby errors during execution
-        raise ConfigurationError, "Error loading #{path}: #{e.message}"
-      end
-    end
-  end
-end