swarm_cli 2.0.0.pre.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 796c9d34130105fe9e4a2d6896fa01e5ec73222f7c334e430b5c2d736055905e
-  data.tar.gz: a9abe83f5e316339e27ea9d2ca52fcffbb29d0c0efcc20dd98ba6131cf2ee2e7
+  metadata.gz: c76f2194c98896ffdd5f1c16a08e0ce0460d3430efc9c4f21adc4999c1af73f7
+  data.tar.gz: c004295295b56474ba2eafad610fb2804ae9e8d171d1103b08faa5d7e93881a0
 SHA512:
-  metadata.gz: 87f901492c2bc58b85b64e4a06e925eed25629e69b4732acbb07056211cb2920f65fd4c79f8305720c4cd62bac49dd20436e16864dd713ba89c6f9b922aae1f2
-  data.tar.gz: 0b7f8c5736f63f5c427a60a530f88f32939c654d2a2295313152b70235e95d06f3288d3ede7576b5f9f6e13f7cf2c4e12340d0d2cbf83d278c81e6f927484983
+  metadata.gz: 8203e59b81a125b4d1ae7188e3a90e9158c228882e15237be1475e64a9ace7489ad0879f8a6507cdd1d0fba7f09ed448e574cbe5df424727f0ddafd06e4d4bd3
+  data.tar.gz: f433f4105c2adeec9e37b8d0539a81180ba5d66d0b979529acd604906fecb1c575f80c352c6620ce89faff6300d0e4ab40b76714c8af71b11e87f25f494da81e

data/lib/swarm_cli/cli.rb

@@ -34,6 +34,8 @@ module SwarmCLI
         run_command(@args[1..])
       when "mcp"
         mcp_command(@args[1..])
+      when "migrate"
+        migrate_command(@args[1..])
       else
         $stderr.puts "Unknown command: #{command}"
         $stderr.puts
@@ -108,22 +110,39 @@ module SwarmCLI
       exit(1)
     end
 
+    def migrate_command(args)
+      # Parse options
+      options = MigrateOptions.new
+      options.parse(args)
+
+      # Execute migrate command
+      Commands::Migrate.new(options).execute
+    rescue TTY::Option::InvalidParameter, TTY::Option::InvalidArgument => e
+      $stderr.puts "Error: #{e.message}"
+      $stderr.puts
+      $stderr.puts options.help
+      exit(1)
+    end
+
     def print_help
       puts
       puts "SwarmCLI v#{VERSION} - AI Agent Orchestration"
       puts
       puts "Usage:"
       puts "  swarm run CONFIG_FILE -p PROMPT [options]"
+      puts "  swarm migrate INPUT_FILE [--output OUTPUT_FILE]"
       puts "  swarm mcp serve CONFIG_FILE"
       puts "  swarm mcp tools [TOOL_NAMES...]"
       puts
       puts "Commands:"
       puts "  run           Execute a swarm with AI agents"
+      puts "  migrate       Migrate Claude Swarm v1 config to SwarmSDK v2 format"
       puts "  mcp serve     Start an MCP server exposing swarm lead agent"
       puts "  mcp tools     Start an MCP server exposing SwarmSDK tools"
       puts
       puts "Options:"
       puts "  -p, --prompt PROMPT          Task prompt for the swarm"
+      puts "  -o, --output FILE            Output file for migrated config (default: stdout)"
       puts "  --output-format FORMAT       Output format: 'human' or 'json' (default: human)"
       puts "  -q, --quiet                  Suppress progress output (human format only)"
       puts "  --truncate                   Truncate long outputs for concise view"
@@ -135,6 +154,8 @@ module SwarmCLI
       puts "  swarm run team.yml -p 'Build a REST API'"
       puts "  echo 'Build a REST API' | swarm run team.yml"
       puts "  swarm run team.yml -p 'Refactor code' --output-format json"
+      puts "  swarm migrate old-config.yml"
+      puts "  swarm migrate old-config.yml --output new-config.yml"
       puts "  swarm mcp serve team.yml"
       puts "  swarm mcp tools                              # Expose all SwarmSDK tools"
       puts "  swarm mcp tools Bash Grep Read               # Space-separated tools"

data/lib/swarm_cli/commands/migrate.rb

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

@@ -4,8 +4,11 @@ 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
     #
@@ -23,6 +26,45 @@ module SwarmCLI
         # 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
 
@@ -37,9 +79,15 @@ module SwarmCLI
           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
 
@@ -55,36 +103,17 @@ module SwarmCLI
 
         # Exit successfully
         exit(0)
-      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 load_swarm
         config_path = options.config_file
 
-        unless File.exist?(config_path)
-          raise SwarmCLI::ExecutionError, "Configuration file not found: #{config_path}"
-        end
-
-        SwarmSDK::Swarm.load(config_path)
+        ConfigLoader.load(config_path)
+      rescue SwarmCLI::ConfigurationError => e
+        # ConfigLoader already provides good context
+        raise SwarmCLI::ExecutionError, e.message
       rescue SwarmSDK::ConfigurationError => e
-        # Re-raise with more context
+        # SDK errors - add context
         raise SwarmCLI::ExecutionError, "Configuration error: #{e.message}"
       end
 
@@ -103,6 +132,34 @@ module SwarmCLI
         end
       end
 
+      def emit_validation_warnings(swarm, formatter)
+        # Setup temporary logging to capture and emit warnings
+        SwarmSDK::LogCollector.on_log do |log_entry|
+          formatter.on_log(log_entry) if log_entry[:type] == "model_lookup_warning"
+        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)

data/lib/swarm_cli/config_loader.rb

@@ -0,0 +1,97 @@
+# 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::Swarm.load
+  # - Ruby DSL files (.rb) - executed and expected to return a SwarmSDK::Swarm 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::Swarm.load
+      # - .rb -> Execute as Ruby DSL and expect SwarmSDK::Swarm instance
+      #
+      # @param path [String, Pathname] Path to configuration file
+      # @return [SwarmSDK::Swarm] Configured swarm 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::Swarm.load(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 instance. The file should use SwarmSDK.build or
+      # create a Swarm instance directly.
+      #
+      # @param path [Pathname] Path to Ruby DSL file
+      # @return [SwarmSDK::Swarm] Configured swarm instance
+      # @raise [ConfigurationError] If file doesn't return a Swarm 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 directly
+        result = eval(content, binding, path.to_s, 1) # rubocop:disable Security/Eval
+
+        # Validate result is a Swarm instance
+        unless result.is_a?(SwarmSDK::Swarm)
+          raise ConfigurationError,
+            "Ruby DSL file must return a SwarmSDK::Swarm instance. " \
+              "Got: #{result.class}. " \
+              "Use: SwarmSDK.build { ... } or Swarm.new(...)"
+        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