kdeploy 0.1.0 → 0.3.0

data/lib/kdeploy/cli.rb

@@ -1,1452 +1,201 @@
 # frozen_string_literal: true
 
-# Add String truncate method if not available
-class String
-  def truncate(length)
-    return self if size <= length
-
-    "#{self[0, length - 3]}..."
-  end
-end
+require 'thor'
+require 'pastel'
+require 'tty-table'
+require 'tty-box'
+require 'fileutils'
 
 module Kdeploy
-  # Command Line Interface for kdeploy
   class CLI < Thor
-    # Fix Thor deprecation warning
+    extend DSL
+
     def self.exit_on_failure?
       true
     end
 
-    # Common options for commands that execute scripts
-    SCRIPT_OPTIONS = {
-      config: { aliases: '-c', desc: 'Configuration file path' },
-      inventory: { aliases: '-i', desc: 'Inventory file path' },
-      dry_run: { aliases: '-d', type: :boolean, desc: 'Perform dry run without executing' },
-      verbose: { aliases: '-v', type: :boolean, desc: 'Enable verbose output' },
-      log_file: { aliases: '-l', desc: 'Log file path' }
-    }.freeze
-
-    desc 'execute SCRIPT', 'Execute deployment script'
-    SCRIPT_OPTIONS.each { |name, opts| option(name, opts) }
-    def execute(script_file)
-      setup_configuration
-      setup_logging
-
-      validate_script_file(script_file)
-
-      begin
-        options[:dry_run] ? perform_dry_run(script_file) : execute_script(script_file)
-      rescue Kdeploy::Error => e
-        handle_deployment_error(e)
-      rescue StandardError => e
-        handle_unexpected_error(e)
-      end
-    end
-
-    desc 'deploy SCRIPT', 'Execute deployment script (alias for execute)'
-    SCRIPT_OPTIONS.each { |name, opts| option(name, opts) }
-    def deploy(script_file)
-      execute(script_file)
-    end
-
-    desc 'init [PROJECT_NAME]', 'Initialize new deployment project'
-    option :name, aliases: '-n', desc: 'Specify project name'
-    def init(project_name = nil)
-      show_kdeploy_banner
-      project_name = determine_project_name(project_name)
-
-      display_init_header(project_name)
-      create_project_structure(project_name)
-      display_init_success(project_name)
-    end
-
-    desc 'validate SCRIPT', 'Validate deployment script'
-    option :config, aliases: '-c', desc: 'Configuration file path'
-    option :inventory, aliases: '-i', desc: 'Inventory file path'
-    def validate(script_file)
-      show_kdeploy_banner
-      setup_configuration
-
-      display_validation_header(script_file)
-      validate_script_file(script_file)
-
-      begin
-        pipeline = Kdeploy.load_script(script_file)
-        validation_errors = pipeline.validate
-
-        if validation_errors.empty?
-          display_validation_success(pipeline)
-        else
-          display_validation_errors(validation_errors)
-        end
-      rescue Kdeploy::Error => e
-        display_validation_failure(e)
-      end
-    end
-
-    desc 'config', 'Show configuration'
-    option :config, aliases: '-c', desc: 'Configuration file path'
-    option :inventory, aliases: '-i', desc: 'Inventory file path'
-    option :verbose, aliases: '-v', type: :boolean, desc: 'Enable verbose output'
-    option :log_file, aliases: '-l', desc: 'Log file path'
-    def config
-      show_kdeploy_banner
-      setup_configuration
-
-      display_configuration(Kdeploy.configuration)
-    end
+    map %w[--help -h] => :help
+    map %w[--version -v] => :version
 
-    desc 'version', 'Show version'
+    desc 'version', 'Show version information'
     def version
-      show_kdeploy_banner
-      display_version_info
+      puts Kdeploy::Banner.show_version
     end
 
-    desc 'help [COMMAND]', 'Describe available commands or one specific command'
+    desc 'help [COMMAND]', 'Show help information'
     def help(command = nil)
-      show_kdeploy_banner
-      puts ''
-      puts '📖 Available Commands:'.colorize(:yellow)
-      puts ''
-
       if command
         super
       else
-        display_available_commands
-      end
-    end
-
-    desc 'stats [COMMAND]', 'Show deployment statistics'
-    option :days, aliases: '-d', type: :numeric, default: 30, desc: 'Number of days to analyze'
-    option :format, aliases: '-f', type: :string, default: 'text', desc: 'Output format (text, json, csv)'
-    option :output, aliases: '-o', type: :string, desc: 'Output file path'
-    def stats(command = 'summary')
-      case command.downcase
-      when 'summary'
-        show_summary_stats
-      when 'deployments'
-        show_deployment_stats
-      when 'tasks'
-        show_task_stats
-      when 'failures'
-        show_failure_stats
-      when 'trends'
-        show_trend_stats
-      when 'global'
-        show_global_stats
-      when 'clear'
-        clear_statistics
-      when 'export'
-        export_statistics
-      else
-        error "Unknown stats command: #{command}"
-        puts ''
-        puts 'Available commands: summary, deployments, tasks, failures, trends, global, clear, export'
-        exit 1
-      end
-    end
-
-    private
-
-    def display_configuration(config)
-      puts ''
-      puts '⚙️  Current Configuration'.colorize(:yellow)
-      puts '=' * 50
+        pastel = Pastel.new
+        puts Kdeploy::Banner.show
+        puts <<~HELP
+          #{pastel.bright_white('📖 Available Commands:')}
 
-      display_execution_settings(config)
-      display_network_settings(config)
-      display_file_settings(config)
-      display_logging_settings(config)
-      display_ssh_options(config) if config.respond_to?(:ssh_options) && config.ssh_options&.any?
+          #{pastel.bright_yellow('🚀')} #{pastel.bright_white('execute TASK_FILE [TASK]')}     Execute deployment tasks from file
+          #{pastel.dim('    --limit HOSTS')}              Limit to specific hosts (comma-separated)
+          #{pastel.dim('    --parallel NUM')}             Number of parallel executions (default: 5)
+          #{pastel.dim('    --dry-run')}                  Show what would be done without executing
 
-      puts ''
-      puts '💡 Use --config FILE to load custom configuration'.colorize(:yellow)
-      puts ''
-    end
+          #{pastel.bright_yellow('🆕')} #{pastel.bright_white('init [DIR]')}                  Initialize new deployment project
+          #{pastel.bright_yellow('ℹ️')} #{pastel.bright_white('version')}                    Show version information
+          #{pastel.bright_yellow('❓')} #{pastel.bright_white('help [COMMAND]')}              Show help information
 
-    def display_execution_settings(config)
-      puts ''
-      puts '🔧 Execution Settings'.colorize(:cyan)
-      puts "  Max Concurrent Tasks: #{config.max_concurrent_tasks}".colorize(:light_blue)
-      puts "  Retry Count: #{config.retry_count}".colorize(:light_blue)
-      puts "  Retry Delay: #{config.retry_delay}s".colorize(:light_blue)
-    end
+          #{pastel.bright_white('💡 Examples:')}
 
-    def display_network_settings(config)
-      puts ''
-      puts '🌐 Network & SSH Settings'.colorize(:cyan)
-      puts "  SSH Timeout: #{config.ssh_timeout}s".colorize(:light_blue)
-      puts "  Command Timeout: #{config.command_timeout}s".colorize(:light_blue)
-      puts "  Default User: #{config.default_user}".colorize(:light_blue)
-      puts "  Default Port: #{config.default_port}".colorize(:light_blue)
-    end
+          #{pastel.dim('# Initialize a new project')}
+          #{pastel.bright_cyan('kdeploy init my-deployment')}
 
-    def display_file_settings(config)
-      puts ''
-      puts '📁 File & Directory Settings'.colorize(:cyan)
-      puts "  Inventory File: #{config.inventory_file || 'not specified'}".colorize(:light_blue)
-      puts "  Template Directory: #{config.template_dir}".colorize(:light_blue)
-    end
+          #{pastel.dim('# Deploy to web servers')}
+          #{pastel.bright_cyan('kdeploy execute deploy.rb deploy_web')}
 
-    def display_logging_settings(config)
-      puts ''
-      puts '📋 Logging Settings'.colorize(:cyan)
-      puts "  Log Level: #{config.log_level}".colorize(:light_blue)
-      puts "  Log File: #{config.log_file || 'stdout'}".colorize(:light_blue)
-    end
+          #{pastel.dim('# Backup database')}
+          #{pastel.bright_cyan('kdeploy execute deploy.rb backup_db')}
 
-    def display_ssh_options(config)
-      puts ''
-      puts '🔐 SSH Options'.colorize(:cyan)
-      config.ssh_options.each do |key, value|
-        puts "  #{key.to_s.capitalize.gsub('_', ' ')}: #{value}".colorize(:light_blue)
-      end
-    end
+          #{pastel.dim('# Run maintenance on specific hosts')}
+          #{pastel.bright_cyan('kdeploy execute deploy.rb maintenance --limit web01')}
 
-    def display_version_info
-      puts ''
-      puts "🔖 Version: #{Kdeploy::VERSION}".colorize(:green)
-      puts '📅 Released: 2025'.colorize(:light_blue)
-      puts '🏠 Homepage: https://github.com/kevin197011/kdeploy'.colorize(:light_blue)
-      puts '📚 Documentation: https://github.com/kevin197011/kdeploy/wiki'.colorize(:light_blue)
-      puts ''
-    end
+          #{pastel.dim('# Preview deployment')}
+          #{pastel.bright_cyan('kdeploy execute deploy.rb deploy_web --dry-run')}
 
-    def display_available_commands
-      puts "  🚀 #{'deploy SCRIPT'.ljust(25)} Execute deployment script"
-      puts "  ⚡ #{'execute SCRIPT'.ljust(25)} Execute deployment script (alias for deploy)"
-      puts "  🆕 #{'init [PROJECT_NAME]'.ljust(25)} Initialize new deployment project"
-      puts "  ✅ #{'validate SCRIPT'.ljust(25)} Validate deployment script"
-      puts "  ⚙️  #{'config'.ljust(25)} Show configuration"
-      puts "  📊 #{'stats [COMMAND]'.ljust(25)} Show deployment statistics"
-      puts "  🔖 #{'version'.ljust(25)} Show version"
-      puts ''
-      puts '💡 For more details on a command:'.colorize(:yellow)
-      puts '   kdeploy help COMMAND'.colorize(:light_blue)
-      puts ''
-    end
+          #{pastel.bright_white('📚 Documentation:')}
+          #{pastel.bright_cyan('https://github.com/kevin197011/kdeploy')}
 
-    def setup_configuration
-      Kdeploy.configure do |config|
-        config.config_file = options[:config] if options[:config]
-        config.inventory_file = options[:inventory] if options[:inventory]
-        config.log_level = options[:verbose] ? :debug : :info
-        config.log_file = options[:log_file] if options[:log_file]
+        HELP
       end
     end
 
-    def setup_logging
-      config = Kdeploy.configuration
-      KdeployLogger.setup(
-        level: config.log_level,
-        log_file: config.log_file
-      )
-    end
-
-    def perform_dry_run(script_file)
-      info '🔍 Performing dry run...'
-      pipeline = Kdeploy.load_script(script_file)
-
-      puts ''
-      puts '📋 Pipeline Summary:'.colorize(:cyan)
-      puts "  Name: #{pipeline.name}".colorize(:light_blue)
-      puts "  Hosts: #{pipeline.hosts.size}".colorize(:light_blue)
-      puts "  Tasks: #{pipeline.tasks.size}".colorize(:light_blue)
-
-      display_target_hosts(pipeline.hosts) if pipeline.hosts.any?
-      display_tasks(pipeline.tasks) if pipeline.tasks.any?
-
-      success '✅ Dry run completed'
-    end
-
-    def execute_script(script_file)
-      show_kdeploy_banner
-      info "🚀 Executing deployment script: #{script_file}"
-
-      pipeline = Kdeploy.load_script(script_file)
-      result = pipeline.execute
-
-      if result[:success]
-        success '✅ Deployment completed successfully'
-      else
-        error '❌ Deployment failed'
-        exit 1
-      end
-    end
-
-    def show_kdeploy_banner
-      Banner.show
-    end
-
-    def info(message)
-      puts message.colorize(:blue)
-    end
-
-    def success(message)
-      puts message.colorize(:green)
-    end
-
-    def error(message)
-      puts message.colorize(:red)
-    end
-
-    def create_project_structure(project_name)
-      create_project_directories(project_name)
-      create_sample_files(project_name)
-      create_sample_scripts(project_name)
-      create_sample_templates(project_name)
-    end
-
-    def create_project_directories(project_name)
-      dirs = [
-        project_name,
-        "#{project_name}/config",
-        "#{project_name}/scripts",
-        "#{project_name}/templates"
-      ]
-
-      dirs.each do |dir|
-        FileUtils.mkdir_p(dir)
-        info "Created directory: #{dir}"
-      end
-    end
-
-    def create_sample_files(project_name)
-      create_deploy_script(project_name)
-      create_inventory_file(project_name)
-      create_config_file(project_name)
-    end
-
-    def create_deploy_script(project_name)
-      content = <<~RUBY
-        # frozen_string_literal: true
-
-        # Main deployment script
-        pipeline 'main' do
-          # Define target hosts
-          host 'app1.example.com', roles: [:app, :web]
-          host 'app2.example.com', roles: [:app, :web]
-          host 'db.example.com', roles: [:db]
-
-          # Set global variables
-          set :app_name, 'my_app'
-          set :deploy_to, '/var/www/${app_name}'
-          set :keep_releases, 5
-
-          # Define tasks
-          task :check_requirements do
-            run 'ruby -v'
-            run 'node -v'
-            run 'git --version'
-          end
-
-          task :setup_directories do
-            run "mkdir -p ${deploy_to}"
-            run "mkdir -p ${deploy_to}/releases"
-            run "mkdir -p ${deploy_to}/shared"
-          end
-
-          task :deploy do
-            depends_on :check_requirements, :setup_directories
-
-            run 'git clone https://github.com/user/repo.git ${deploy_to}/releases/$(date +%Y%m%d%H%M%S)'
-            run 'ln -sfn ${deploy_to}/releases/$(ls -t ${deploy_to}/releases | head -n1) ${deploy_to}/current'
-          end
-
-          task :restart_services do
-            run 'sudo systemctl restart nginx'
-            run 'sudo systemctl restart app'
-          end
-
-          task :cleanup do
-            run "cd ${deploy_to}/releases && ls -t | tail -n +${keep_releases + 1} | xargs rm -rf"
-          end
-        end
-      RUBY
-
-      write_file("#{project_name}/deploy.rb", content)
-      info "Created deployment script: #{project_name}/deploy.rb"
-    end
-
-    def create_inventory_file(project_name)
-      content = <<~YAML
-        # Server inventory configuration
-        groups:
-          production:
-            hosts:
-              - hostname: app1.example.com
-                roles: [app, web]
-                user: deploy
-                port: 22
-              - hostname: app2.example.com
-                roles: [app, web]
-                user: deploy
-                port: 22
-              - hostname: db.example.com
-                roles: [db]
-                user: deploy
-                port: 22
-                vars:
-                  db_name: production_db
-                  db_user: app_user
-
-          staging:
-            hosts:
-              - hostname: staging.example.com
-                roles: [app, web, db]
-                user: deploy
-                port: 22
-                vars:
-                  rails_env: staging
-                  node_env: staging
-      YAML
-
-      write_file("#{project_name}/inventory.yml", content)
-      info "Created inventory file: #{project_name}/inventory.yml"
-    end
-
-    def create_config_file(project_name)
-      content = <<~YAML
-        # Deployment configuration
-        max_concurrent_tasks: 5
-        retry_count: 3
-        retry_delay: 5
-        ssh_timeout: 30
-        command_timeout: 300
-
-        default_user: deploy
-        default_port: 22
-
-        template_dir: templates
-        inventory_file: inventory.yml
-
-        ssh_options:
-          forward_agent: true
-          verify_host_key: true
-          keepalive: true
-          keepalive_interval: 30
-
-        logging:
-          level: info
-          file: kdeploy.log
-      YAML
-
-      write_file("#{project_name}/config/kdeploy.yml", content)
-      info "Created configuration file: #{project_name}/config/kdeploy.yml"
-    end
-
-    def create_sample_scripts(project_name)
-      create_setup_script(project_name)
-      create_database_script(project_name)
-      create_backup_script(project_name)
-      create_monitoring_script(project_name)
-      create_rollback_script(project_name)
-      create_cleanup_script(project_name)
-    end
-
-    def create_setup_script(project_name)
-      content = <<~RUBY
-        # frozen_string_literal: true
-
-        # Server setup script
-        pipeline 'setup' do
-          # Target all hosts
-          host 'app1.example.com', roles: [:app, :web]
-          host 'app2.example.com', roles: [:app, :web]
-          host 'db.example.com', roles: [:db]
-
-          # Set global variables
-          set :ruby_version, '3.2.0'
-          set :node_version, '18.x'
-
-          task :install_dependencies do
-            run <<~BASH
-              # Update package lists
-              sudo apt-get update
-
-              # Install essential packages
-              sudo apt-get install -y build-essential git curl
-              sudo apt-get install -y nginx redis-server
-            BASH
-          end
-
-          task :setup_ruby do
-            run <<~BASH
-              # Install rbenv
-              git clone https://github.com/rbenv/rbenv.git ~/.rbenv
-              echo 'export PATH="$HOME/.rbenv/bin:$PATH"' >> ~/.bashrc
-              echo 'eval "$(rbenv init -)"' >> ~/.bashrc
-              source ~/.bashrc
-
-              # Install ruby-build
-              git clone https://github.com/rbenv/ruby-build.git ~/.rbenv/plugins/ruby-build
-
-              # Install Ruby
-              rbenv install ${ruby_version}
-              rbenv global ${ruby_version}
-            BASH
-          end
-
-          task :setup_node do
-            run <<~BASH
-              # Install Node.js
-              curl -fsSL https://deb.nodesource.com/setup_${node_version} | sudo -E bash -
-              sudo apt-get install -y nodejs
-
-              # Install Yarn
-              curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | sudo apt-key add -
-              echo "deb https://dl.yarnpkg.com/debian/ stable main" | sudo tee /etc/apt/sources.list.d/yarn.list
-              sudo apt-get update && sudo apt-get install -y yarn
-            BASH
-          end
-
-          task :setup_nginx do
-            # Upload nginx configuration
-            upload_template 'nginx.conf', '/etc/nginx/sites-available/app'
-            run 'sudo ln -sf /etc/nginx/sites-available/app /etc/nginx/sites-enabled/app'
-            run 'sudo nginx -t && sudo systemctl restart nginx'
-          end
-
-          task :setup_app_service do
-            # Upload systemd service configuration
-            upload_template 'app.service', '/etc/systemd/system/app.service'
-            run 'sudo systemctl daemon-reload'
-            run 'sudo systemctl enable app'
-          end
-
-          task :setup do
-            depends_on :install_dependencies,
-                      :setup_ruby,
-                      :setup_node,
-                      :setup_nginx,
-                      :setup_app_service
-          end
-        end
-      RUBY
-
-      write_file("#{project_name}/scripts/setup.rb", content)
-      info "Created setup script: #{project_name}/scripts/setup.rb"
-    end
-
-    def create_database_script(project_name)
-      content = <<~RUBY
-        # frozen_string_literal: true
-
-        # Database management script
-        pipeline 'database' do
-          # Target database hosts
-          host 'db.example.com', roles: [:db]
-
-          # Set database configuration
-          set :db_name, 'app_production'
-          set :db_user, 'app_user'
-          set :db_password, ENV['DB_PASSWORD']
-
-          task :create_database do
-            run <<~SQL
-              psql -U postgres -c "CREATE USER ${db_user} WITH PASSWORD '${db_password}';"
-              psql -U postgres -c "CREATE DATABASE ${db_name} OWNER ${db_user};"
-            SQL
-          end
-
-          task :migrate do
-            run 'cd /var/www/app/current && RAILS_ENV=production bundle exec rake db:migrate'
-          end
-
-          task :seed do
-            run 'cd /var/www/app/current && RAILS_ENV=production bundle exec rake db:seed'
-          end
-
-          task :backup do
-            run <<~BASH
-              timestamp=$(date +%Y%m%d_%H%M%S)
-              pg_dump -U ${db_user} ${db_name} > /var/backups/${db_name}_${timestamp}.sql
-              gzip /var/backups/${db_name}_${timestamp}.sql
-            BASH
-          end
-
-          task :restore do
-            run <<~BASH
-              latest_backup=$(ls -t /var/backups/${db_name}_*.sql.gz | head -n1)
-              gunzip -c $latest_backup | psql -U ${db_user} ${db_name}
-            BASH
-          end
-        end
-      RUBY
-
-      write_file("#{project_name}/scripts/database.rb", content)
-      info "Created database script: #{project_name}/scripts/database.rb"
-    end
-
-    def create_backup_script(project_name)
-      content = <<~RUBY
-        # frozen_string_literal: true
-
-        # Backup operations script
-        pipeline 'backup' do
-          # Target all hosts
-          host 'app1.example.com', roles: [:app, :web]
-          host 'app2.example.com', roles: [:app, :web]
-          host 'db.example.com', roles: [:db]
-
-          # Set backup configuration
-          set :backup_dir, '/var/backups'
-          set :keep_backups, 10
-
-          task :backup_database do
-            only :db
-            run <<~BASH
-              timestamp=$(date +%Y%m%d_%H%M%S)
-              pg_dump -U ${db_user} ${db_name} > ${backup_dir}/${db_name}_${timestamp}.sql
-              gzip ${backup_dir}/${db_name}_${timestamp}.sql
-            BASH
-          end
-
-          task :backup_uploads do
-            only [:app, :web]
-            run <<~BASH
-              timestamp=$(date +%Y%m%d_%H%M%S)
-              tar -czf ${backup_dir}/uploads_${timestamp}.tar.gz /var/www/app/shared/public/uploads
-            BASH
-          end
-
-          task :backup_logs do
-            run <<~BASH
-              timestamp=$(date +%Y%m%d_%H%M%S)
-              tar -czf ${backup_dir}/logs_${timestamp}.tar.gz /var/log/app
-            BASH
-          end
-
-          task :cleanup_old_backups do
-            run <<~BASH
-              cd ${backup_dir}
-              ls -t *.sql.gz | tail -n +${keep_backups + 1} | xargs rm -f
-              ls -t *.tar.gz | tail -n +${keep_backups + 1} | xargs rm -f
-            BASH
-          end
-
-          task :backup do
-            depends_on :backup_database,
-                      :backup_uploads,
-                      :backup_logs,
-                      :cleanup_old_backups
-          end
-        end
-      RUBY
-
-      write_file("#{project_name}/scripts/backup.rb", content)
-      info "Created backup script: #{project_name}/scripts/backup.rb"
+    desc 'init [DIR]', 'Initialize a new deployment project'
+    def init(dir = '.')
+      initializer = Initializer.new(dir)
+      initializer.run
+    rescue StandardError => e
+      puts Kdeploy::Banner.show_error(e.message)
+      exit 1
     end
 
-    def create_monitoring_script(project_name)
-      content = <<~RUBY
-        # frozen_string_literal: true
-
-        # Health checks and monitoring script
-        pipeline 'monitoring' do
-          # Target all hosts
-          host 'app1.example.com', roles: [:app, :web]
-          host 'app2.example.com', roles: [:app, :web]
-          host 'db.example.com', roles: [:db]
-
-          task :check_system_resources do
-            run <<~BASH
-              echo "Memory Usage:"
-              free -h
-              echo "\\nDisk Usage:"
-              df -h
-              echo "\\nCPU Load:"
-              uptime
-            BASH
-          end
-
-          task :check_services do
-            run <<~BASH
-              echo "Nginx Status:"
-              sudo systemctl status nginx
-              echo "\\nApp Status:"
-              sudo systemctl status app
-              echo "\\nRedis Status:"
-              sudo systemctl status redis-server
-            BASH
-          end
+    desc 'execute TASK_FILE [TASK]', 'Execute deployment tasks from file'
+    method_option :limit, type: :string, desc: 'Limit to specific hosts (comma-separated)'
+    method_option :parallel, type: :numeric, default: 5, desc: 'Number of parallel executions'
+    method_option :dry_run, type: :boolean, desc: 'Show what would be done'
+    def execute(task_file, task_name = nil)
+      load_task_file(task_file)
 
-          task :check_logs do
-            run <<~BASH
-              echo "Last 50 lines of application log:"
-              tail -n 50 /var/www/app/current/log/production.log
-              echo "\\nLast 50 lines of nginx error log:"
-              sudo tail -n 50 /var/log/nginx/error.log
-            BASH
-          end
+      tasks_to_run = if task_name
+                       [task_name.to_sym]
+                     else
+                       self.class.kdeploy_tasks.keys
+                     end
 
-          task :check_database do
-            only :db
-            run <<~BASH
-              echo "PostgreSQL Status:"
-              sudo systemctl status postgresql
-              echo "\\nDatabase Size:"
-              psql -U ${db_user} -d ${db_name} -c "\\l+"
-            BASH
-          end
+      tasks_to_run.each do |task|
+        task_hosts = self.class.get_task_hosts(task)
+        hosts = filter_hosts(options[:limit], task_hosts)
 
-          task :monitor do
-            depends_on :check_system_resources,
-                      :check_services,
-                      :check_logs,
-                      :check_database
-          end
+        if hosts.empty?
+          puts Kdeploy::Banner.show_error("No hosts found for task: #{task}")
+          next
         end
-      RUBY
-
-      write_file("#{project_name}/scripts/monitoring.rb", content)
-      info "Created monitoring script: #{project_name}/scripts/monitoring.rb"
-    end
-
-    def create_rollback_script(project_name)
-      content = <<~RUBY
-        # frozen_string_literal: true
 
-        # Rollback operations script
-        pipeline 'rollback' do
-          # Target application hosts
-          host 'app1.example.com', roles: [:app, :web]
-          host 'app2.example.com', roles: [:app, :web]
-
-          # Set deployment configuration
-          set :app_name, 'my_app'
-          set :deploy_to, '/var/www/${app_name}'
-
-          task :list_releases do
-            run "ls -lt ${deploy_to}/releases"
-          end
-
-          task :rollback_code do
-            run <<~BASH
-              current_release=$(readlink ${deploy_to}/current)
-              previous_release=$(ls -t ${deploy_to}/releases | head -n 2 | tail -n 1)
-              ln -sfn ${deploy_to}/releases/$previous_release ${deploy_to}/current
-            BASH
-          end
-
-          task :rollback_database do
-            run 'cd ${deploy_to}/current && RAILS_ENV=production bundle exec rake db:rollback STEP=1'
-          end
-
-          task :restart_services do
-            run 'sudo systemctl restart app'
-            run 'sudo systemctl restart nginx'
-          end
-
-          task :rollback do
-            depends_on :list_releases,
-                      :rollback_code,
-                      :rollback_database,
-                      :restart_services
-          end
+        if options[:dry_run]
+          print_dry_run(hosts, task)
+          next
         end
-      RUBY
-
-      write_file("#{project_name}/scripts/rollback.rb", content)
-      info "Created rollback script: #{project_name}/scripts/rollback.rb"
-    end
-
-    def create_cleanup_script(project_name)
-      content = <<~RUBY
-        # frozen_string_literal: true
-
-        # Cleanup operations script
-        pipeline 'cleanup' do
-          # Target all hosts
-          host 'app1.example.com', roles: [:app, :web]
-          host 'app2.example.com', roles: [:app, :web]
-          host 'db.example.com', roles: [:db]
-
-          # Set cleanup configuration
-          set :app_name, 'my_app'
-          set :deploy_to, '/var/www/${app_name}'
-          set :keep_releases, 5
-          set :keep_logs, 7
-
-          task :cleanup_releases do
-            run <<~BASH
-              cd ${deploy_to}/releases
-              ls -t | tail -n +${keep_releases + 1} | xargs rm -rf
-            BASH
-          end
 
-          task :cleanup_logs do
-            run <<~BASH
-              find /var/www/app/current/log -name "*.log.*" -mtime +${keep_logs} -exec rm {} \\;
-              find /var/log/nginx -name "*.log.*" -mtime +${keep_logs} -exec sudo rm {} \\;
-            BASH
-          end
-
-          task :cleanup_temp do
-            run <<~BASH
-              find /tmp -name "#{app_name}-*" -mtime +1 -exec rm -rf {} \\;
-              find /var/tmp -name "#{app_name}-*" -mtime +1 -exec rm -rf {} \\;
-            BASH
-          end
-
-          task :cleanup do
-            depends_on :cleanup_releases,
-                      :cleanup_logs,
-                      :cleanup_temp
-          end
-        end
-      RUBY
-
-      write_file("#{project_name}/scripts/cleanup.rb", content)
-      info "Created cleanup script: #{project_name}/scripts/cleanup.rb"
-    end
-
-    def create_sample_templates(project_name)
-      create_nginx_template(project_name)
-      create_app_service_template(project_name)
-      create_deploy_script_template(project_name)
-      create_backup_script_template(project_name)
-    end
-
-    def create_nginx_template(project_name)
-      content = <<~ERB
-        # Nginx configuration for <%= app_name %>
-        upstream app_server {
-          server unix:/var/www/<%= app_name %>/shared/tmp/sockets/puma.sock fail_timeout=0;
-        }
-
-        server {
-          listen 80;
-          server_name <%= server_name %>;
-          root /var/www/<%= app_name %>/current/public;
-
-          location ^~ /assets/ {
-            gzip_static on;
-            expires max;
-            add_header Cache-Control public;
-          }
-
-          try_files $uri/index.html $uri @app;
-
-          location @app {
-            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
-            proxy_set_header Host $http_host;
-            proxy_redirect off;
-            proxy_pass http://app_server;
-          }
-
-          error_page 500 502 503 504 /500.html;
-          client_max_body_size 4G;
-          keepalive_timeout 10;
-        }
-      ERB
-
-      write_file("#{project_name}/templates/nginx.conf.erb", content)
-      info "Created nginx template: #{project_name}/templates/nginx.conf.erb"
-    end
-
-    def create_app_service_template(project_name)
-      content = <<~ERB
-        [Unit]
-        Description=<%= app_name %> application server
-        After=network.target
-
-        [Service]
-        Type=simple
-        User=<%= app_user %>
-        WorkingDirectory=/var/www/<%= app_name %>/current
-        Environment=RAILS_ENV=production
-        Environment=PATH=/home/<%= app_user %>/.rbenv/shims:/usr/local/bin:/usr/bin:/bin
-        ExecStart=/home/<%= app_user %>/.rbenv/shims/bundle exec puma -C config/puma.rb
-        Restart=always
-        RestartSec=1
-
-        [Install]
-        WantedBy=multi-user.target
-      ERB
-
-      write_file("#{project_name}/templates/app.service.erb", content)
-      info "Created app service template: #{project_name}/templates/app.service.erb"
-    end
-
-    def create_deploy_script_template(project_name)
-      content = <<~ERB
-        #!/bin/bash
-        # Deployment script for <%= app_name %>
-
-        set -e
-
-        APP_ROOT="/var/www/<%= app_name %>"
-        CURRENT="$APP_ROOT/current"
-        SHARED="$APP_ROOT/shared"
-        RELEASE="$APP_ROOT/releases/$(date +%Y%m%d%H%M%S)"
-
-        echo "Deploying <%= app_name %> to $RELEASE"
-
-        # Create release directory
-        mkdir -p $RELEASE
-
-        # Clone repository
-        git clone <%= repository_url %> $RELEASE
-
-        # Install dependencies
-        cd $RELEASE
-        bundle install --deployment --without development test
-        yarn install --production
-
-        # Compile assets
-        bundle exec rake assets:precompile RAILS_ENV=production
-
-        # Create symlinks
-        ln -s $SHARED/config/database.yml $RELEASE/config/database.yml
-        ln -s $SHARED/config/master.key $RELEASE/config/master.key
-        ln -s $SHARED/public/uploads $RELEASE/public/uploads
-
-        # Update current symlink
-        ln -sfn $RELEASE $CURRENT
-
-        # Restart application
-        sudo systemctl restart <%= app_name %>
-
-        echo "Deployment completed successfully!"
-      ERB
-
-      write_file("#{project_name}/templates/deploy.sh.erb", content)
-      info "Created deploy script template: #{project_name}/templates/deploy.sh.erb"
-    end
-
-    def create_backup_script_template(project_name)
-      content = <<~ERB
-        #!/bin/bash
-        # Backup script for <%= app_name %>
-
-        set -e
-
-        TIMESTAMP=$(date +%Y%m%d_%H%M%S)
-        BACKUP_DIR="<%= backup_dir %>"
-        DB_NAME="<%= db_name %>"
-        APP_ROOT="/var/www/<%= app_name %>"
-
-        echo "Starting backup for <%= app_name %>"
-
-        # Create backup directory
-        mkdir -p $BACKUP_DIR
-
-        # Backup database
-        echo "Backing up database..."
-        pg_dump -U <%= db_user %> $DB_NAME > $BACKUP_DIR/${DB_NAME}_${TIMESTAMP}.sql
-        gzip $BACKUP_DIR/${DB_NAME}_${TIMESTAMP}.sql
-
-        # Backup uploads
-        echo "Backing up uploads..."
-        tar -czf $BACKUP_DIR/uploads_${TIMESTAMP}.tar.gz $APP_ROOT/shared/public/uploads
-
-        # Backup configuration
-        echo "Backing up configuration..."
-        tar -czf $BACKUP_DIR/config_${TIMESTAMP}.tar.gz $APP_ROOT/shared/config
-
-        # Cleanup old backups
-        echo "Cleaning up old backups..."
-        find $BACKUP_DIR -name "*.sql.gz" -mtime +<%= keep_days %> -delete
-        find $BACKUP_DIR -name "*.tar.gz" -mtime +<%= keep_days %> -delete
-
-        echo "Backup completed successfully!"
-      ERB
-
-      write_file("#{project_name}/templates/backup.sh.erb", content)
-      info "Created backup script template: #{project_name}/templates/backup.sh.erb"
-    end
-
-    def write_file(path, content)
-      File.write(path, content)
-    end
-
-    def determine_project_name(project_name)
-      project_name || options[:name] || File.basename(Dir.pwd)
-    end
-
-    def display_init_header(project_name)
-      puts ''
-      puts "🆕 Initializing kdeploy project: #{project_name}".colorize(:yellow)
-      puts ''
-    end
-
-    def display_init_success(project_name)
-      puts ''
-      puts '✅ Project initialized successfully!'.colorize(:green)
-      puts ''
-      display_project_structure(project_name)
-      display_next_steps(project_name)
-      display_available_scripts
-    end
-
-    def display_project_structure(project_name)
-      puts '📁 Project Structure Created:'.colorize(:cyan)
-      puts "  #{project_name}/".colorize(:light_blue)
-      puts '  ├── deploy.rb           # Main deployment script'.colorize(:light_blue)
-      puts '  ├── inventory.yml       # Server inventory'.colorize(:light_blue)
-      puts '  ├── config/             # Configuration files'.colorize(:light_blue)
-      puts '  │   └── kdeploy.yml     # Deployment configuration'.colorize(:light_blue)
-      puts '  ├── scripts/            # Additional scripts'.colorize(:light_blue)
-      puts '  │   ├── setup.rb        # Server setup script'.colorize(:light_blue)
-      puts '  │   ├── database.rb     # Database management'.colorize(:light_blue)
-      puts '  │   ├── backup.rb       # Backup operations'.colorize(:light_blue)
-      puts '  │   ├── monitoring.rb   # Health checks & monitoring'.colorize(:light_blue)
-      puts '  │   ├── rollback.rb     # Rollback operations'.colorize(:light_blue)
-      puts '  │   └── cleanup.rb      # Cleanup operations'.colorize(:light_blue)
-      puts '  └── templates/          # Configuration templates'.colorize(:light_blue)
-      puts '      ├── nginx.conf.erb  # Nginx configuration'.colorize(:light_blue)
-      puts '      ├── app.service.erb # Systemd service'.colorize(:light_blue)
-      puts '      ├── deploy.sh.erb   # Deployment script'.colorize(:light_blue)
-      puts '      └── backup.sh.erb   # Backup script'.colorize(:light_blue)
-      puts ''
-    end
-
-    def display_next_steps(project_name)
-      puts '🚀 Next Steps:'.colorize(:cyan)
-      puts "  1. cd #{project_name}".colorize(:light_blue)
-      puts '  2. Edit deploy.rb to configure your deployment'.colorize(:light_blue)
-      puts '  3. Update inventory.yml with your servers'.colorize(:light_blue)
-      puts '  4. Run: kdeploy deploy scripts/setup.rb        # Setup servers'.colorize(:light_blue)
-      puts '  5. Run: kdeploy deploy deploy.rb               # Deploy application'.colorize(:light_blue)
-      puts ''
-    end
-
-    def display_available_scripts
-      puts '💡 Available Scripts:'.colorize(:cyan)
-      puts '  kdeploy deploy scripts/setup.rb      # Initial server setup'.colorize(:light_blue)
-      puts '  kdeploy deploy scripts/database.rb   # Database operations'.colorize(:light_blue)
-      puts '  kdeploy deploy scripts/backup.rb     # Backup operations'.colorize(:light_blue)
-      puts '  kdeploy deploy scripts/monitoring.rb # Health checks'.colorize(:light_blue)
-      puts '  kdeploy deploy scripts/rollback.rb   # Rollback operations'.colorize(:light_blue)
-      puts '  kdeploy deploy scripts/cleanup.rb    # Cleanup operations'.colorize(:light_blue)
-      puts ''
-      puts '💡 Need help? Run: kdeploy help deploy'.colorize(:yellow)
-      puts ''
-    end
-
-    def validate_script_file(script_file)
-      return if File.exist?(script_file)
-
-      error "Script file not found: #{script_file}"
-      exit 1
-    end
-
-    def display_validation_header(script_file)
-      puts ''
-      puts "🔍 Validating deployment script: #{script_file}".colorize(:yellow)
-      puts ''
-    end
-
-    def display_validation_success(pipeline)
-      puts '✅ Script validation passed'.colorize(:green)
-      puts ''
-      display_pipeline_summary(pipeline)
-      display_target_hosts(pipeline.hosts) if pipeline.hosts.any?
-      display_tasks(pipeline.tasks) if pipeline.tasks.any?
-      puts ''
-    end
-
-    def display_pipeline_summary(pipeline)
-      puts '📋 Pipeline Summary:'.colorize(:cyan)
-      puts "  Name: #{pipeline.name}".colorize(:light_blue)
-      puts "  Hosts: #{pipeline.hosts.size}".colorize(:light_blue)
-      puts "  Tasks: #{pipeline.tasks.size}".colorize(:light_blue)
-    end
-
-    def display_target_hosts(hosts)
-      puts ''
-      puts '🖥️  Target Hosts:'.colorize(:cyan)
-      hosts.each do |host|
-        puts "  • #{host.hostname}:#{host.port} (#{host.user})".colorize(:light_blue)
-      end
-    end
-
-    def display_tasks(tasks)
-      puts ''
-      puts '🔧 Tasks to Execute:'.colorize(:cyan)
-      tasks.each_with_index do |task, index|
-        puts "  #{index + 1}. #{task.name}".colorize(:light_blue)
+        runner = Runner.new(hosts, self.class.kdeploy_tasks, parallel: options[:parallel])
+        results = runner.run(task)
+        print_results(results)
       end
-    end
-
-    def display_validation_errors(errors)
-      puts '❌ Script validation failed:'.colorize(:red)
-      puts ''
-      errors.each { |err| puts "  • #{err}".colorize(:red) }
-      puts ''
-      exit 1
-    end
-
-    def display_validation_failure(error)
-      puts "❌ Validation failed: #{error.message}".colorize(:red)
-      puts ''
-      exit 1
-    end
-
-    def handle_deployment_error(error)
-      error "Deployment failed: #{error.message}"
-      exit 1
-    end
-
-    def handle_unexpected_error(error)
-      error "Unexpected error: #{error.message}"
-      KdeployLogger.debug("Backtrace: #{error.backtrace.join("\n")}")
+    rescue StandardError => e
+      puts Kdeploy::Banner.show_error(e.message)
       exit 1
     end
 
-    def show_summary_stats
-      show_kdeploy_banner
-      stats = Kdeploy.statistics
-      deployment_summary = stats.deployment_summary(days: options[:days])
-      task_summary = stats.task_summary(days: options[:days])
-      global_summary = stats.global_summary
-
-      case options[:format].downcase
-      when 'json'
-        display_json_summary(deployment_summary, task_summary, global_summary)
-      else
-        print_summary_table(deployment_summary, task_summary, global_summary)
-      end
-    end
-
-    def show_deployment_stats
-      show_kdeploy_banner
-      stats = Kdeploy.statistics
-      summary = stats.deployment_summary(days: options[:days])
-
-      case options[:format].downcase
-      when 'json'
-        puts JSON.pretty_generate(summary)
-      else
-        print_deployment_table(summary)
-      end
-    end
-
-    def show_task_stats
-      show_kdeploy_banner
-      stats = Kdeploy.statistics
-      summary = stats.task_summary(days: options[:days])
-
-      case options[:format].downcase
-      when 'json'
-        puts JSON.pretty_generate(summary)
-      else
-        print_task_table(summary)
-      end
-    end
-
-    def show_failure_stats
-      show_kdeploy_banner
-      stats = Kdeploy.statistics
-      failed_tasks = stats.top_failed_tasks(limit: 10, days: options[:days])
-
-      case options[:format].downcase
-      when 'json'
-        puts JSON.pretty_generate(failed_tasks)
-      else
-        print_failure_table(failed_tasks)
-      end
-    end
-
-    def show_trend_stats
-      show_kdeploy_banner
-      stats = Kdeploy.statistics
-      trends = stats.performance_trends(days: options[:days])
-
-      case options[:format].downcase
-      when 'json'
-        puts JSON.pretty_generate(trends)
-      else
-        print_trend_table(trends)
-      end
-    end
-
-    def show_global_stats
-      show_kdeploy_banner
-      stats = Kdeploy.statistics
-      global_summary = stats.global_summary
+    private
 
-      case options[:format].downcase
-      when 'json'
-        puts JSON.pretty_generate(global_summary)
-      else
-        print_global_table(global_summary)
+    def load_task_file(file)
+      unless File.exist?(file)
+        puts Kdeploy::Banner.show_error("Task file not found: #{file}")
+        exit 1
       end
-    end
 
-    def clear_statistics
-      show_kdeploy_banner
-      prompt = TTY::Prompt.new
-      if prompt.yes?('Are you sure you want to clear all statistics? This cannot be undone.')
-        Kdeploy.statistics.clear_statistics!
-        success 'Statistics cleared successfully'
-      else
-        info 'Statistics clearing cancelled'
-      end
+      self.class.class_eval(File.read(file), file)
     end
 
-    def export_statistics
-      show_kdeploy_banner
-      export_file = options[:output] || generate_export_filename
-      format = determine_export_format(export_file)
+    def filter_hosts(limit, task_hosts)
+      hosts = self.class.kdeploy_hosts.select { |name, _| task_hosts.include?(name) }
+      return hosts unless limit
 
-      Kdeploy.statistics.export_statistics(export_file, format: format)
-      success "Statistics exported to #{export_file}"
+      host_names = limit.split(',').map(&:strip)
+      hosts.select { |name, _| host_names.include?(name) }
     end
 
-    def display_json_summary(deployment_summary, task_summary, global_summary)
-      puts JSON.pretty_generate(
-        {
-          deployment_summary: deployment_summary,
-          task_summary: task_summary,
-          global_summary: global_summary
+    def print_dry_run(hosts, task_name)
+      puts Kdeploy::Banner.show
+      pastel = Pastel.new
+      puts TTY::Box.frame(
+        'Showing what would be done without executing any commands',
+        title: { top_left: ' Dry Run Mode ', bottom_right: ' Kdeploy ' },
+        style: {
+          border: {
+            fg: :blue
+          }
         }
       )
-    end
-
-    def print_summary_table(deployment_summary, task_summary, global_summary)
-      puts "\n📊 Kdeploy Statistics Summary (Last #{options[:days]} days)".colorize(:cyan)
-      puts '=' * 60
-
-      print_deployment_section(deployment_summary)
-      print_task_section(task_summary)
-      print_global_section(global_summary)
-    end
-
-    def print_deployment_section(summary)
-      puts "\n📦 Deployment Statistics".colorize(:yellow)
-      if summary[:total_deployments].positive?
-        puts "  Total Deployments: #{summary[:total_deployments]}"
-        puts "  Successful: #{summary[:successful_deployments]} (#{summary[:success_rate]}%)"
-        puts "  Failed: #{summary[:failed_deployments]}"
-        puts "  Average Duration: #{summary[:avg_duration]}s"
-        puts "  Total Duration: #{format_duration(summary[:total_duration])}"
-      else
-        puts "  No deployments in the last #{options[:days]} days"
-      end
-    end
-
-    def print_task_section(summary)
-      puts "\n🔧 Task Statistics".colorize(:yellow)
-      if summary[:total_task_executions].positive?
-        puts "  Total Task Executions: #{summary[:total_task_executions]}"
-        puts "  Unique Tasks: #{summary[:unique_tasks]}"
-        print_top_tasks(summary[:tasks]) if summary[:tasks].any?
-      else
-        puts "  No task executions in the last #{options[:days]} days"
-      end
-    end
-
-    def print_top_tasks(tasks)
-      puts '  Top Tasks:'
-      sorted_tasks = tasks.sort_by { |_, stats| -stats[:total_executions] }.first(5)
-      sorted_tasks.each do |name, stats|
-        puts "    #{name}: #{stats[:total_executions]} executions (#{stats[:success_rate]}% success)"
-      end
-    end
-
-    def print_global_section(summary)
-      puts "\n🌍 Global Statistics".colorize(:yellow)
-      puts "  Total Deployments: #{summary[:total_deployments]}"
-      puts "  Total Tasks: #{summary[:total_tasks]}"
-      puts "  Total Commands: #{summary[:total_commands]}"
-      puts "  Total Execution Time: #{format_duration(summary[:total_execution_time])}"
-      puts "  Session Duration: #{format_duration(summary[:session_duration])}"
-      puts ''
-    end
-
-    def print_deployment_table(summary)
-      puts "\n📦 Deployment Statistics (Last #{options[:days]} days)".colorize(:cyan)
-      puts '=' * 60
-
-      if summary[:total_deployments].zero?
-        puts 'No deployments found'
-        return
-      end
-
-      display_deployment_stats(summary)
-    end
-
-    def display_deployment_stats(summary)
-      puts "Total Deployments: #{summary[:total_deployments]}"
-      puts "Successful: #{summary[:successful_deployments]} (#{summary[:success_rate]}%)"
-      puts "Failed: #{summary[:failed_deployments]}"
-      puts "Average Duration: #{summary[:avg_duration]}s"
-      puts "Min Duration: #{summary[:min_duration]}s"
-      puts "Max Duration: #{summary[:max_duration]}s"
-      puts "Total Duration: #{format_duration(summary[:total_duration])}"
-      puts ''
-    end
-
-    def print_task_table(summary)
-      puts "\n🔧 Task Statistics (Last #{options[:days]} days)".colorize(:cyan)
-      puts '=' * 60
-
-      if summary[:total_task_executions].zero?
-        puts 'No task executions found'
-        return
-      end
-
-      display_task_summary(summary)
-      display_task_details(summary[:tasks]) if summary[:tasks].any?
-    end
-
-    def display_task_summary(summary)
-      puts "Total Executions: #{summary[:total_task_executions]}"
-      puts "Unique Tasks: #{summary[:unique_tasks]}"
-      puts ''
-    end
-
-    def display_task_details(tasks)
-      puts 'Task Details:'
-      print_task_header
-      tasks.each { |name, stats| print_task_row(name, stats) }
-      puts ''
-    end
-
-    def print_task_header
-      printf "%-30s %10s %10s %10s %12s %12s\n",
-             'Task Name', 'Executions', 'Success', 'Failed', 'Success Rate', 'Avg Duration'
-      puts '-' * 95
-    end
-
-    def print_task_row(name, stats)
-      printf "%-30s %10d %10d %10d %11.1f%% %11.2fs\n",
-             name.truncate(28),
-             stats[:total_executions],
-             stats[:successful],
-             stats[:failed],
-             stats[:success_rate],
-             stats[:avg_duration]
-    end
-
-    def print_failure_table(failed_tasks)
-      puts "\n❌ Top Failed Tasks (Last #{options[:days]} days)".colorize(:red)
-      puts '=' * 60
-
-      if failed_tasks.empty?
-        puts 'No failed tasks found'
-        return
-      end
-
-      print_failure_header
-      failed_tasks.each { |task| print_failure_row(task) }
-      puts ''
-    end
-
-    def print_failure_header
-      printf "%-30s %10s %20s\n", 'Task Name', 'Failures', 'Last Failure'
-      puts '-' * 62
-    end
-
-    def print_failure_row(task)
-      last_failure_time = Time.at(task[:last_failure][:timestamp]).strftime('%Y-%m-%d %H:%M:%S')
-      printf "%-30s %10d %20s\n",
-             task[:task_name].truncate(28),
-             task[:failure_count],
-             last_failure_time
-    end
-
-    def print_trend_table(trends)
-      puts "\n📈 Performance Trends (Last #{options[:days]} days)".colorize(:cyan)
-      puts '=' * 80
-
-      if trends[:trends].empty?
-        puts 'No trend data available'
-        return
+      puts
+
+      hosts.each do |name, config|
+        commands = self.class.kdeploy_tasks[task_name][:block].call
+        output = commands.map do |command|
+          case command[:type]
+          when :run
+            "#{pastel.green('>')} #{command[:command]}"
+          when :upload
+            "#{pastel.blue('>')} Upload: #{command[:source]} -> #{command[:destination]}"
+          end
+        end.join("\n")
+
+        puts TTY::Box.frame(
+          output,
+          title: { top_left: " #{name} (#{config[:ip]}) " },
+          style: {
+            border: {
+              fg: :yellow
+            }
+          }
+        )
+        puts
       end
-
-      print_trend_header
-      trends[:trends].each { |date, stats| print_trend_row(date, stats) }
-      puts ''
-    end
-
-    def print_trend_header
-      printf "%-12s %10s %10s %10s %12s %12s\n",
-             'Date', 'Total', 'Success', 'Failed', 'Success Rate', 'Avg Duration'
-      puts '-' * 78
-    end
-
-    def print_trend_row(date, stats)
-      printf "%-12s %10d %10d %10d %11.1f%% %11.2fs\n",
-             date,
-             stats[:total],
-             stats[:successful],
-             stats[:failed],
-             stats[:success_rate],
-             stats[:avg_duration]
-    end
-
-    def print_global_table(global_summary)
-      puts "\n🌍 Global Statistics".colorize(:cyan)
-      puts '=' * 60
-
-      print_global_deployment_stats(global_summary)
-      print_global_task_stats(global_summary)
-      print_global_command_stats(global_summary)
-      print_global_execution_stats(global_summary)
     end
 
-    def print_global_deployment_stats(summary)
-      puts 'Deployments:'
-      puts "  Total: #{summary[:total_deployments]}"
-      puts "  Successful: #{summary[:successful_deployments]}"
-      puts "  Failed: #{summary[:failed_deployments]}"
-    end
-
-    def print_global_task_stats(summary)
-      puts "\nTasks:"
-      puts "  Total: #{summary[:total_tasks]}"
-      puts "  Successful: #{summary[:successful_tasks]}"
-      puts "  Failed: #{summary[:failed_tasks]}"
-    end
+    def print_results(results)
+      puts Kdeploy::Banner.show
+      pastel = Pastel.new
 
-    def print_global_command_stats(summary)
-      puts "\nCommands:"
-      puts "  Total: #{summary[:total_commands]}"
-      puts "  Successful: #{summary[:successful_commands]}"
-      puts "  Failed: #{summary[:failed_commands]}"
-    end
-
-    def print_global_execution_stats(summary)
-      puts "\nExecution Time:"
-      puts "  Total: #{format_duration(summary[:total_execution_time])}"
-      puts "  Session: #{format_duration(summary[:session_duration])}"
-      puts "  Session Started: #{summary[:session_start_time].strftime('%Y-%m-%d %H:%M:%S')}"
-      puts ''
-    end
+      results.each do |host, result|
+        status = if result[:status] == :success
+                   pastel.green('✓ Success')
+                 else
+                   pastel.red('✗ Failed')
+                 end
 
-    def format_duration(seconds)
-      return '0s' if seconds.nil? || seconds.zero?
+        puts "#{pastel.bright_white(host)} - #{status}"
 
-      if seconds < 60
-        "#{seconds.round(1)}s"
-      elsif seconds < 3600
-        format_minutes(seconds)
-      else
-        format_hours(seconds)
+        if result[:status] == :success
+          result[:output].each do |cmd|
+            puts "  #{pastel.bright_yellow('$')} #{cmd[:command]}"
+            if cmd[:output].is_a?(Hash)
+              puts "  #{cmd[:output][:stdout]}" unless cmd[:output][:stdout].empty?
+              puts "  #{pastel.red(cmd[:output][:stderr])}" unless cmd[:output][:stderr].empty?
+            elsif cmd[:output]
+              puts "  #{cmd[:output]}"
+            end
+            puts
+          end
+        else
+          puts "  #{pastel.red(result[:error])}"
+        end
+        puts
       end
     end
-
-    def format_minutes(seconds)
-      minutes = (seconds / 60).to_i
-      remaining_seconds = (seconds % 60).to_i
-      "#{minutes}m #{remaining_seconds}s"
-    end
-
-    def format_hours(seconds)
-      hours = (seconds / 3600).to_i
-      remaining_minutes = ((seconds % 3600) / 60).to_i
-      "#{hours}h #{remaining_minutes}m"
-    end
-
-    def generate_export_filename
-      "kdeploy_stats_#{Time.now.strftime('%Y%m%d_%H%M%S')}.json"
-    end
-
-    def determine_export_format(filename)
-      File.extname(filename) == '.csv' ? :csv : :json
-    end
   end
 end