kdeploy 1.2.30 → 1.2.38

data/lib/kdeploy/output_formatter.rb

@@ -24,64 +24,60 @@ module Kdeploy
       @pastel.bright_white("  #{host.ljust(20)} #{status_str}")
     end
 
-    def format_upload_steps(steps, shown)
-      format_file_steps(steps, shown, :upload, @pastel.green('  === Upload ==='), 'upload: ')
+    # Prefix for per-step lines to make multi-host logs easier to scan.
+    def host_prefix(host)
+      @pastel.dim("  #{host.ljust(20)} ")
     end
 
-    def format_template_steps(steps, shown)
-      format_file_steps(steps, shown, :upload_template, @pastel.yellow('  === Template ==='), 'upload_template: ')
+    def format_host_completed(duration)
+      @pastel.dim("    [completed in #{format('%.2f', duration)}s]")
     end
 
-    def format_sync_steps(steps, shown)
-      output = []
-      steps.each do |step|
-        next if step_already_shown?(step, :sync, shown)
+    def calculate_host_duration(result)
+      return 0.0 unless result.is_a?(Hash)
 
-        mark_step_as_shown(step, :sync, shown)
-        output << format_sync_step(step)
-      end
-      output
+      Array(result[:output]).sum { |step| step[:duration].to_f }
     end
 
-    def format_file_steps(steps, shown, type, _header, prefix)
-      output = []
-      steps.each do |step|
-        next if step_already_shown?(step, type, shown)
+    def format_upload_steps(steps, _shown = nil)
+      format_file_steps(steps, :upload, 'upload: ')
+    end
 
-        mark_step_as_shown(step, type, shown)
-        output << format_file_step(step, type, prefix)
-      end
-      output
+    def format_template_steps(steps, _shown = nil)
+      format_file_steps(steps, :upload_template, 'upload_template: ')
+    end
+
+    def format_sync_steps(steps, _shown = nil)
+      steps.map { |step| format_sync_step(step) }
+    end
+
+    def format_file_steps(steps, type, prefix)
+      steps.map { |step| format_file_step(step, type, prefix) }
     end
 
     def format_file_step(step, type, prefix)
       duration_str = format_duration(step[:duration])
+      status_str = format_step_status(step)
       icon = type == :upload ? '📤' : '📝'
       file_path = step[:command].sub(prefix, '')
       # Truncate long paths for cleaner output
       display_path = file_path.length > 50 ? "...#{file_path[-47..]}" : file_path
       color_method = type == :upload ? :green : :yellow
-      @pastel.dim("    #{icon} ") + @pastel.send(color_method, display_path) + duration_str
+      @pastel.dim("    #{icon} ") + @pastel.send(color_method, display_path) + duration_str + " #{status_str}"
     end
 
-    def format_run_steps(steps, shown)
-      output = []
-      steps.each do |step|
-        next if step_already_shown?(step, :run, shown)
-
-        mark_step_as_shown(step, :run, shown)
-        output.concat(format_single_run_step(step))
-      end
-      output
+    def format_run_steps(steps, _shown = nil)
+      steps.flat_map { |step| format_single_run_step(step) }
     end
 
     def format_single_run_step(step)
       output = []
       duration_str = format_duration(step[:duration])
-      command_line = step[:command].to_s.lines.first.strip
+      status_str = format_step_status(step)
+      command_line = first_meaningful_command_line(step[:command].to_s)
       # Truncate long commands for cleaner output
       display_cmd = command_line.length > 60 ? "#{command_line[0..57]}..." : command_line
-      output << (@pastel.dim('    • ') + @pastel.cyan(display_cmd) + duration_str)
+      output << (@pastel.dim('    • ') + @pastel.cyan(display_cmd) + duration_str + " #{status_str}")
       # Only show multiline details in debug mode
       if @debug
         output.concat(format_multiline_command(step[:command]))
@@ -187,6 +183,17 @@ module Kdeploy
       output
     end
 
+    def first_meaningful_command_line(command)
+      lines = command.to_s.lines.map(&:strip)
+      lines.each do |line|
+        next if line.empty?
+        next if line.start_with?('#')
+
+        return line
+      end
+      lines.first.to_s
+    end
+
     def format_command_output(output)
       result = []
       return result unless output
@@ -240,18 +247,9 @@ module Kdeploy
       result
     end
 
-    def step_already_shown?(step, type, shown)
-      key = [step[:command], type].hash
-      shown[key]
-    end
-
-    def mark_step_as_shown(step, type, shown)
-      key = [step[:command], type].hash
-      shown[key] = true
-    end
-
     def format_sync_step(step)
       duration_str = format_duration(step[:duration])
+      status_str = format_step_status(step)
       sync_path = step[:command].sub('sync: ', '')
       # Truncate long paths for cleaner output
       display_path = sync_path.length > 50 ? "...#{sync_path[-47..]}" : sync_path
@@ -266,7 +264,15 @@ module Kdeploy
       stats << @pastel.yellow("#{deleted} deleted") if deleted.positive?
       stats_str = stats.any? ? " (#{stats.join(', ')})" : " (#{total} files)"
 
-      @pastel.dim('    📁 ') + @pastel.cyan(display_path) + @pastel.dim(stats_str) + duration_str
+      @pastel.dim('    📁 ') + @pastel.cyan(display_path) + @pastel.dim(stats_str) + duration_str + " #{status_str}"
+    end
+
+    def format_step_status(step)
+      if step.is_a?(Hash) && step.key?(:error) && step[:error] && !step[:error].to_s.empty?
+        @pastel.red('✗ failed')
+      else
+        @pastel.green('✓ ok')
+      end
     end
   end
 end

data/lib/kdeploy/runner.rb

@@ -6,21 +6,23 @@ module Kdeploy
   # Concurrent task runner for executing tasks across multiple hosts
   class Runner
     def initialize(hosts, tasks, parallel: Configuration.default_parallel, output: ConsoleOutput.new,
-                   debug: false, base_dir: nil)
+                   debug: false, base_dir: nil, retries: Configuration.default_retries,
+                   retry_delay: Configuration.default_retry_delay)
       @hosts = hosts
       @tasks = tasks
       @parallel = parallel
       @output = output
       @debug = debug
       @base_dir = base_dir
+      @retries = retries
+      @retry_delay = retry_delay
       @pool = Concurrent::FixedThreadPool.new(@parallel)
       @results = Concurrent::Hash.new
     end
 
     def run(task_name)
       task = find_task(task_name)
-      results = execute_concurrent_tasks(task)
-      results
+      execute_concurrent_tasks(task, task_name)
     ensure
       @pool.shutdown
     end
@@ -33,16 +35,12 @@ module Kdeploy
       task
     end
 
-    def execute_concurrent_tasks(task)
-      futures = create_task_futures(task)
+    def execute_concurrent_tasks(task, task_name)
+      futures = create_task_futures(task, task_name)
 
       # If no hosts, return empty results immediately
       return @results if futures.empty?
 
-      # Show progress while waiting for tasks to complete
-      total = futures.length
-      completed = 0
-
       # Collect results from futures
       futures.each_with_index do |future, index|
         host_name = @host_names[index] # Get host name from the stored list
@@ -84,74 +82,78 @@ module Kdeploy
           # Ensure we always have a result for this host
           @results[host_name] ||= { status: :unknown, error: 'No result collected', output: [] }
         end
-
-        completed += 1
-        # Show progress for multiple hosts
-        next unless total > 1
-
-        pastel = @output.respond_to?(:pastel) ? @output.pastel : Pastel.new
-        @output.write_line(pastel.dim("    [Progress: #{completed}/#{total} hosts completed]"))
-        @output.flush if @output.respond_to?(:flush)
       end
 
       @results
     end
 
-    def create_task_futures(task)
+    def create_task_futures(task, task_name)
       # Store host names in order to match with futures
       @host_names = @hosts.keys
       @hosts.map do |name, config|
         Concurrent::Future.execute(executor: @pool) do
-          execute_task_for_host(name, config, task)
+          execute_task_for_host(name, config, task, task_name)
         end
       end
     end
 
     private
 
-    def execute_task_for_host(name, config, task)
+    def execute_task_for_host(name, config, task, task_name)
       # Add base_dir to config for path resolution
       config_with_base_dir = config.merge(base_dir: @base_dir)
       executor = Executor.new(config_with_base_dir)
-      command_executor = CommandExecutor.new(executor, @output, debug: @debug)
+      command_executor = CommandExecutor.new(
+        executor,
+        @output,
+        debug: @debug,
+        retries: @retries,
+        retry_delay: @retry_delay
+      )
       result = { status: :success, output: [] }
 
       begin
-        execute_grouped_commands(task, command_executor, name, result)
+        execute_commands(task, command_executor, name, result, task_name)
       rescue StandardError => e
-        # Ensure result is always set, even on error
-        # Don't re-raise, as it would cause future.value to fail
-        result = { status: :failed, error: e.message, output: [] }
+        # Keep any already collected step output for troubleshooting.
+        result[:status] = :failed
+        result[:error] = "#{e.class}: #{e.message}"
       end
 
       # Return the result so it can be collected from the future
       [name, result]
     end
 
-    def execute_grouped_commands(task, command_executor, name, result)
+    def execute_commands(task, command_executor, name, result, task_name)
       commands = task[:block].call
-      grouped_commands = CommandGrouper.group(commands)
 
-      grouped_commands.each_value do |command_group|
-        execute_command_group(command_group, command_executor, name, result)
+      commands.each do |command|
+        step_result = execute_command(command_executor, command, name)
+        result[:output] << step_result
+      rescue StandardError => e
+        step = step_description(command)
+        result[:status] = :failed
+        result[:error] = "task=#{task_name} host=#{name} step=#{step} error=#{e.class}: #{e.message}"
+        result[:output] << {
+          type: command[:type],
+          command: step_command_string(command),
+          duration: 0.0,
+          error: "#{e.class}: #{e.message}",
+          output: error_output_for_step(e)
+        }
+        break
       end
     end
 
-    def execute_command_group(command_group, command_executor, name, result)
-      first_cmd = command_group.first
-      task_desc = CommandGrouper.task_description(first_cmd)
-      show_task_header(task_desc)
-
-      command_group.each_with_index do |command, index|
-        # Show progress for multiple commands
-        if command_group.length > 1
-          pastel = @output.respond_to?(:pastel) ? @output.pastel : Pastel.new
-          @output.write_line(pastel.dim("    [Step #{index + 1}/#{command_group.length}]"))
-        end
+    def error_output_for_step(error)
+      return nil unless error.is_a?(Kdeploy::SSHError)
 
-        step_result = execute_command(command_executor, command, name)
-        result[:output] << step_result
-      end
+      {
+        stdout: error.stdout,
+        stderr: error.stderr,
+        exit_status: error.exit_status,
+        command: error.command
+      }
     end
 
     def execute_command(command_executor, command, host_name)
@@ -169,9 +171,35 @@ module Kdeploy
       end
     end
 
-    def show_task_header(task_desc)
-      # Don't show command header during execution - it will be shown in results
-      # This reduces noise during execution
+    def step_command_string(command)
+      case command[:type]
+      when :run
+        command[:command].to_s
+      when :upload
+        "upload: #{command[:source]} -> #{command[:destination]}"
+      when :upload_template
+        "upload_template: #{command[:source]} -> #{command[:destination]}"
+      when :sync
+        "sync: #{command[:source]} -> #{command[:destination]}"
+      else
+        command[:type].to_s
+      end
+    end
+
+    def step_description(command)
+      case command[:type]
+      when :run
+        first = command[:command].to_s.lines.first&.strip
+        "run: #{first}"
+      when :upload
+        "upload: #{command[:source]} -> #{command[:destination]}"
+      when :upload_template
+        "upload_template: #{command[:source]} -> #{command[:destination]}"
+      when :sync
+        "sync: #{command[:source]} -> #{command[:destination]}"
+      else
+        command[:type].to_s
+      end
     end
   end
 end

data/lib/kdeploy/version.rb

@@ -2,5 +2,5 @@
 
 # Kdeploy module for version management
 module Kdeploy
-  VERSION = '1.2.30' unless const_defined?(:VERSION)
+  VERSION = '1.2.38' unless const_defined?(:VERSION)
 end

data/lib/kdeploy.rb

@@ -8,7 +8,6 @@ require_relative 'kdeploy/banner'
 require_relative 'kdeploy/file_filter'
 require_relative 'kdeploy/dsl'
 require_relative 'kdeploy/executor'
-require_relative 'kdeploy/command_grouper'
 require_relative 'kdeploy/command_executor'
 require_relative 'kdeploy/output_formatter'
 require_relative 'kdeploy/help_formatter'

data/r.md

@@ -0,0 +1 @@
+# Your product documentation

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kdeploy
 version: !ruby/object:Gem::Version
-  version: 1.2.30
+  version: 1.2.38
 platform: ruby
 authors:
 - Kk
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-11-21 00:00:00.000000000 Z
+date: 2026-02-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bcrypt_pbkdf
@@ -160,6 +160,7 @@ extensions:
 - ext/mkrf_conf.rb
 extra_rdoc_files: []
 files:
+- AGENTS.md
 - README.md
 - README_EN.md
 - exe/kdeploy
@@ -168,7 +169,6 @@ files:
 - lib/kdeploy/banner.rb
 - lib/kdeploy/cli.rb
 - lib/kdeploy/command_executor.rb
-- lib/kdeploy/command_grouper.rb
 - lib/kdeploy/completions/kdeploy.bash
 - lib/kdeploy/completions/kdeploy.zsh
 - lib/kdeploy/configuration.rb
@@ -184,6 +184,7 @@ files:
 - lib/kdeploy/runner.rb
 - lib/kdeploy/template.rb
 - lib/kdeploy/version.rb
+- r.md
 homepage: https://github.com/kevin197011/kdeploy
 licenses:
 - MIT

data/lib/kdeploy/command_grouper.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-module Kdeploy
-  # Groups commands by type and generates task descriptions
-  class CommandGrouper
-    def self.group(commands)
-      commands.group_by do |cmd|
-        group_key_for(cmd)
-      end
-    end
-
-    def self.group_key_for(cmd)
-      case cmd[:type]
-      when :upload, :upload_template, :sync
-        "#{cmd[:type]}_#{cmd[:source]}"
-      when :run
-        "#{cmd[:type]}_#{cmd[:command].to_s.lines.first.strip}"
-      else
-        cmd[:type].to_s
-      end
-    end
-
-    def self.task_description(command)
-      case command[:type]
-      when :upload
-        "upload #{command[:source]}"
-      when :upload_template
-        "template #{command[:source]}"
-      when :sync
-        "sync #{command[:source]}"
-      when :run
-        command[:command].to_s.lines.first.strip
-      else
-        command[:type].to_s
-      end
-    end
-  end
-end