taski 0.7.0 → 0.8.0

data/lib/taski/execution/plain_progress_display.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative "base_progress_display"
+
+module Taski
+  module Execution
+    # PlainProgressDisplay provides plain text output without terminal escape codes.
+    # Designed for non-TTY environments (CI, log files, piped output).
+    #
+    # Output format:
+    #   [START] TaskName
+    #   [DONE] TaskName (123.4ms)
+    #   [FAIL] TaskName: Error message
+    #
+    # Enable with: TASKI_PROGRESS_MODE=plain
+    class PlainProgressDisplay < BaseProgressDisplay
+      def initialize(output: $stderr)
+        super
+        @output.sync = true if @output.respond_to?(:sync=)
+      end
+
+      protected
+
+      # Template method: Called when a section impl is registered
+      def on_section_impl_registered(_section_class, impl_class)
+        @tasks[impl_class] ||= TaskProgress.new
+      end
+
+      # Template method: Called when a task state is updated
+      def on_task_updated(task_class, state, duration, error)
+        case state
+        when :running
+          @output.puts "[START] #{short_name(task_class)}"
+        when :completed
+          duration_str = duration ? " (#{format_duration(duration)})" : ""
+          @output.puts "[DONE] #{short_name(task_class)}#{duration_str}"
+        when :failed
+          error_msg = error ? ": #{error.message}" : ""
+          @output.puts "[FAIL] #{short_name(task_class)}#{error_msg}"
+        when :cleaning
+          @output.puts "[CLEAN] #{short_name(task_class)}"
+        when :clean_completed
+          duration_str = duration ? " (#{format_duration(duration)})" : ""
+          @output.puts "[CLEAN DONE] #{short_name(task_class)}#{duration_str}"
+        when :clean_failed
+          error_msg = error ? ": #{error.message}" : ""
+          @output.puts "[CLEAN FAIL] #{short_name(task_class)}#{error_msg}"
+        end
+        @output.flush
+      end
+
+      # Template method: Called when display starts
+      def on_start
+        if @root_task_class
+          @output.puts "[TASKI] Starting #{short_name(@root_task_class)}"
+          @output.flush
+        end
+      end
+
+      # Template method: Called when display stops
+      def on_stop
+        total_duration = @start_time ? ((Time.now - @start_time) * 1000).to_i : 0
+        completed = @tasks.values.count { |t| t.run_state == :completed }
+        failed = @tasks.values.count { |t| t.run_state == :failed }
+        total = @tasks.size
+
+        if failed > 0
+          @output.puts "[TASKI] Failed: #{failed}/#{total} tasks (#{total_duration}ms)"
+        else
+          @output.puts "[TASKI] Completed: #{completed}/#{total} tasks (#{total_duration}ms)"
+        end
+        @output.flush
+      end
+    end
+  end
+end

data/lib/taski/execution/simple_progress_display.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+require_relative "base_progress_display"
+
+module Taski
+  module Execution
+    # SimpleProgressDisplay provides a minimalist single-line progress display
+    # that shows task execution status in a compact format:
+    #
+    #   ⠹ [3/5] DeployTask | Uploading files...
+    #
+    # This is an alternative to TreeProgressDisplay for users who prefer
+    # less verbose output.
+    class SimpleProgressDisplay < BaseProgressDisplay
+      SPINNER_FRAMES = %w[⠋ ⠙ ⠹ ⠸ ⠼ ⠴ ⠦ ⠧ ⠇ ⠏].freeze
+      RENDER_INTERVAL = 0.1
+
+      ICONS = {
+        success: "✓",
+        failure: "✗",
+        pending: "○"
+      }.freeze
+
+      COLORS = {
+        green: "\e[32m",
+        red: "\e[31m",
+        yellow: "\e[33m",
+        dim: "\e[2m",
+        reset: "\e[0m"
+      }.freeze
+
+      def initialize(output: $stdout)
+        super
+        @spinner_index = 0
+        @renderer_thread = nil
+        @running = false
+      end
+
+      protected
+
+      # Template method: Called when root task is set
+      def on_root_task_set
+        build_tree_structure
+      end
+
+      # Template method: Called when a section impl is registered
+      def on_section_impl_registered(_section_class, impl_class)
+        @tasks[impl_class] ||= TaskProgress.new
+        @tasks[impl_class].is_impl_candidate = false
+      end
+
+      # Template method: Determine if display should activate
+      def should_activate?
+        tty?
+      end
+
+      # Template method: Called when display starts
+      def on_start
+        @running = true
+        @output.print "\e[?25l" # Hide cursor
+        @renderer_thread = Thread.new do
+          loop do
+            break unless @running
+            render_live
+            sleep RENDER_INTERVAL
+          end
+        end
+      end
+
+      # Template method: Called when display stops
+      def on_stop
+        @running = false
+        @renderer_thread&.join
+        @output.print "\e[?25h" # Show cursor
+        render_final
+      end
+
+      private
+
+      def build_tree_structure
+        return unless @root_task_class
+
+        # Use TreeProgressDisplay's static method for tree building
+        tree = TreeProgressDisplay.build_tree_node(@root_task_class)
+        register_tasks_from_tree(tree)
+      end
+
+      def render_live
+        @monitor.synchronize do
+          @spinner_index = (@spinner_index + 1) % SPINNER_FRAMES.size
+          line = build_status_line
+          # Clear line and write new content
+          @output.print "\r\e[K#{line}"
+          @output.flush
+        end
+      end
+
+      def render_final
+        @monitor.synchronize do
+          total_duration = @start_time ? ((Time.now - @start_time) * 1000).to_i : 0
+          completed = @tasks.values.count { |p| p.run_state == :completed }
+          failed = @tasks.values.count { |p| p.run_state == :failed }
+          total = @tasks.size
+
+          line = if failed > 0
+            failed_tasks = @tasks.select { |_, p| p.run_state == :failed }
+            first_error = failed_tasks.values.first&.run_error
+            error_msg = first_error ? ": #{first_error.message}" : ""
+            "#{COLORS[:red]}#{ICONS[:failure]}#{COLORS[:reset]} [#{completed}/#{total}] " \
+              "#{failed_tasks.keys.first} failed#{error_msg}"
+          else
+            "#{COLORS[:green]}#{ICONS[:success]}#{COLORS[:reset]} [#{completed}/#{total}] " \
+              "All tasks completed (#{total_duration}ms)"
+          end
+
+          @output.print "\r\e[K#{line}\n"
+          @output.flush
+        end
+      end
+
+      def build_status_line
+        running_tasks = @tasks.select { |_, p| p.run_state == :running }
+        cleaning_tasks = @tasks.select { |_, p| p.clean_state == :cleaning }
+        completed = @tasks.values.count { |p| p.run_state == :completed }
+        failed = @tasks.values.count { |p| p.run_state == :failed }
+        total = @tasks.size
+
+        spinner = SPINNER_FRAMES[@spinner_index]
+        status_icon = if failed > 0
+          "#{COLORS[:red]}#{ICONS[:failure]}#{COLORS[:reset]}"
+        elsif running_tasks.any? || cleaning_tasks.any?
+          "#{COLORS[:yellow]}#{spinner}#{COLORS[:reset]}"
+        else
+          "#{COLORS[:green]}#{ICONS[:success]}#{COLORS[:reset]}"
+        end
+
+        # Get current task names
+        current_tasks = if cleaning_tasks.any?
+          cleaning_tasks.keys.map { |t| short_name(t) }
+        else
+          running_tasks.keys.map { |t| short_name(t) }
+        end
+
+        task_names = current_tasks.first(3).join(", ")
+        task_names += "..." if current_tasks.size > 3
+
+        # Get last output message if available
+        output_suffix = build_output_suffix(running_tasks.keys.first || cleaning_tasks.keys.first)
+
+        parts = ["#{status_icon} [#{completed}/#{total}]"]
+        parts << task_names if task_names && !task_names.empty?
+        parts << "|" << output_suffix if output_suffix
+
+        parts.join(" ")
+      end
+
+      def build_output_suffix(task_class)
+        return nil unless @output_capture && task_class
+
+        last_line = @output_capture.last_line_for(task_class)
+        return nil unless last_line && !last_line.strip.empty?
+
+        # Truncate if too long
+        max_length = 40
+        if last_line.length > max_length
+          last_line[0, max_length - 3] + "..."
+        else
+          last_line
+        end
+      end
+    end
+  end
+end

data/lib/taski/execution/task_output_router.rb

@@ -18,14 +18,42 @@ module Taski
       include MonitorMixin
 
       POLL_TIMEOUT = 0.05 # 50ms timeout for IO.select
+      POLL_INTERVAL = 0.1 # 100ms between polls (matches TreeProgressDisplay)
       READ_BUFFER_SIZE = 4096
+      MAX_RECENT_LINES = 30 # Maximum number of recent lines to keep per task
 
       def initialize(original_stdout)
         super()
         @original = original_stdout
-        @pipes = {}       # task_class => TaskOutputPipe
-        @thread_map = {}  # Thread => task_class
-        @last_lines = {}  # task_class => String
+        @pipes = {}         # task_class => TaskOutputPipe
+        @thread_map = {}    # Thread => task_class
+        @recent_lines = {}  # task_class => Array<String>
+        @poll_thread = nil
+        @polling = false
+      end
+
+      # Start the background polling thread
+      # This ensures pipes are drained even when display doesn't poll
+      def start_polling
+        synchronize do
+          return if @polling
+          @polling = true
+        end
+
+        @poll_thread = Thread.new do
+          loop do
+            break unless @polling
+            poll
+            sleep POLL_INTERVAL
+          end
+        end
+      end
+
+      # Stop the background polling thread
+      def stop_polling
+        synchronize { @polling = false }
+        @poll_thread&.join(0.5)
+        @poll_thread = nil
       end
 
       # Start capturing output for the current thread
@@ -41,8 +69,11 @@ module Taski
       end
 
       # Stop capturing output for the current thread
-      # Closes the write end of the pipe
+      # Closes the write end of the pipe and drains remaining data
       def stop_capture
+        task_class = nil
+        pipe = nil
+
         synchronize do
           task_class = @thread_map.delete(Thread.current)
           unless task_class
@@ -54,6 +85,29 @@ module Taski
           pipe&.close_write
           debug_log("Stopped capture for #{task_class} on thread #{Thread.current.object_id}")
         end
+
+        # Drain any remaining data from the pipe after closing write end
+        drain_pipe(pipe) if pipe
+      end
+
+      # Drain all remaining data from a pipe
+      # Called after close_write to ensure all output is captured
+      def drain_pipe(pipe)
+        return if pipe.read_closed?
+
+        loop do
+          data = pipe.read_io.read_nonblock(READ_BUFFER_SIZE)
+          debug_log("drain_pipe read #{data.bytesize} bytes for #{pipe.task_class}")
+          store_output_lines(pipe.task_class, data)
+        rescue IO::WaitReadable
+          # Check if there's more data with a very short timeout
+          ready, = IO.select([pipe.read_io], nil, nil, 0.001)
+          break unless ready
+        rescue IOError
+          # All data has been read (EOFError) or pipe was closed by another thread
+          synchronize { pipe.close_read }
+          break
+        end
       end
 
       # Poll all open pipes for available data
@@ -64,7 +118,8 @@ module Taski
         end
         return if readable_pipes.empty?
 
-        ready, _, _ = IO.select(readable_pipes, nil, nil, POLL_TIMEOUT)
+        # Handle race condition: pipe may be closed between check and select
+        ready, = IO.select(readable_pipes, nil, nil, POLL_TIMEOUT)
         return unless ready
 
         ready.each do |read_io|
@@ -73,13 +128,22 @@ module Taski
 
           read_from_pipe(pipe)
         end
+      rescue IOError
+        # Pipe was closed by another thread (drain_pipe), ignore
       end
 
       # Get the last output line for a task
       # @param task_class [Class] The task class
       # @return [String, nil] The last output line
       def last_line_for(task_class)
-        synchronize { @last_lines[task_class] }
+        synchronize { @recent_lines[task_class]&.last }
+      end
+
+      # Get recent output lines for a task (up to MAX_RECENT_LINES)
+      # @param task_class [Class] The task class
+      # @return [Array<String>] Recent output lines
+      def recent_lines_for(task_class)
+        synchronize { (@recent_lines[task_class] || []).dup }
       end
 
       # Close all pipes and clean up
@@ -104,14 +168,13 @@ module Taski
       def write(str)
         pipe = current_thread_pipe
         if pipe && !pipe.write_closed?
-          pipe.write_io.write(str)
-        else
-          # Fallback to original stdout - log why capture failed
-          if @thread_map.empty?
-            debug_log("Output not captured: no threads registered")
-          else
-            debug_log("Output not captured: thread #{Thread.current.object_id} not mapped")
+          begin
+            pipe.write_io.write(str)
+          rescue IOError
+            # Pipe was closed by another thread (e.g., stop_capture), fall back to original
+            @original.write(str)
           end
+        else
           @original.write(str)
         end
       end
@@ -189,27 +252,35 @@ module Taski
 
       def read_from_pipe(pipe)
         data = pipe.read_io.read_nonblock(READ_BUFFER_SIZE)
-        update_last_line(pipe.task_class, data)
+        store_output_lines(pipe.task_class, data)
       rescue IO::WaitReadable
         # No data available yet
-      rescue EOFError
-        # Pipe closed by writer, close read end
+      rescue IOError
+        # Pipe closed by writer (EOFError) or by another thread, close read end
         synchronize { pipe.close_read }
       end
 
-      def update_last_line(task_class, data)
+      def store_output_lines(task_class, data)
         return if data.nil? || data.empty?
 
         lines = data.lines
-        last_non_empty = lines.reverse.find { |l| !l.strip.empty? }
         synchronize do
-          @last_lines[task_class] = last_non_empty&.strip if last_non_empty
+          @recent_lines[task_class] ||= []
+          lines.each do |line|
+            stripped = line.chomp
+            @recent_lines[task_class] << stripped unless stripped.strip.empty?
+          end
+          # Keep only the last MAX_RECENT_LINES
+          if @recent_lines[task_class].size > MAX_RECENT_LINES
+            @recent_lines[task_class] = @recent_lines[task_class].last(MAX_RECENT_LINES)
+          end
+          debug_log("store_output_lines: #{task_class} now has #{@recent_lines[task_class].size} lines")
         end
       end
 
       def debug_log(message)
         return unless ENV["TASKI_DEBUG"]
-        @original.puts "[TaskOutputRouter] #{message}"
+        warn "[TaskOutputRouter] #{message}"
       end
     end
   end

data/lib/taski/execution/task_wrapper.rb

@@ -38,10 +38,12 @@ module Taski
       # @param [Object] task - The task instance being wrapped.
       # @param [Object] registry - The registry used to query abort status and coordinate execution.
       # @param [Object, nil] execution_context - Optional execution context used to trigger and report execution and cleanup.
-      def initialize(task, registry:, execution_context: nil)
+      # @param [Hash, nil] args - User-defined arguments for Task.new usage.
+      def initialize(task, registry:, execution_context: nil, args: nil)
         @task = task
         @registry = registry
         @execution_context = execution_context
+        @args = args
         @result = nil
         @clean_result = nil
         @error = nil
@@ -261,14 +263,18 @@ module Taski
       ##
       # Ensures args are set during block execution, then resets if they weren't set before.
       # This allows Task.new.run usage without requiring explicit args setup.
+      # If args are already set (e.g., from Task.run class method), just yields the block.
+      # Uses stored @args if set (from Task.new), otherwise uses empty hash.
       # @yield The block to execute with args lifecycle management
       # @return [Object] The result of the block
-      def with_args_lifecycle
-        args_was_nil = Taski.args.nil?
-        Taski.start_args(options: {}, root_task: @task.class) if args_was_nil
-        yield
-      ensure
-        Taski.reset_args! if args_was_nil
+      def with_args_lifecycle(&block)
+        # If args are already set, just execute the block
+        return yield if Taski.args
+
+        options = @args || {}
+        Taski.send(:with_env, root_task: @task.class) do
+          Taski.send(:with_args, options: options, &block)
+        end
       end
 
       ##
@@ -276,26 +282,11 @@ module Taski
       # If the task is pending, triggers execution (via the configured ExecutionContext when present, otherwise via Executor) outside the monitor; if the task is running, waits until it becomes completed; if already completed, returns immediately.
       # @raise [Taski::TaskAbortException] If the registry requested an abort before execution begins.
       def trigger_execution_and_wait
-        should_execute = false
-        @monitor.synchronize do
-          case @state
-          when STATE_PENDING
-            check_abort!
-            should_execute = true
-          when STATE_RUNNING
-            @condition.wait_until { @state == STATE_COMPLETED }
-          when STATE_COMPLETED
-            # Already done
-          end
-        end
-
-        if should_execute
-          # Execute outside the lock to avoid deadlock
-          # Use ensure_execution_context to create a shared context if not set
-          context = ensure_execution_context
-          context.trigger_execution(@task.class, registry: @registry)
-          # After execution returns, the task is completed
-        end
+        trigger_and_wait(
+          state_accessor: -> { @state },
+          condition: @condition,
+          trigger: ->(ctx) { ctx.trigger_execution(@task.class, registry: @registry) }
+        )
       end
 
       ##
@@ -304,14 +295,27 @@ module Taski
       # If an ExecutionContext is configured the cleanup is invoked through it; otherwise a fallback executor is used.
       # @raise [Taski::TaskAbortException] if the registry has requested an abort.
       def trigger_clean_and_wait
+        trigger_and_wait(
+          state_accessor: -> { @clean_state },
+          condition: @clean_condition,
+          trigger: ->(ctx) { ctx.trigger_clean(@task.class, registry: @registry) }
+        )
+      end
+
+      # Generic trigger-and-wait implementation for both run and clean phases.
+      # @param state_accessor [Proc] Lambda returning the current state
+      # @param condition [MonitorMixin::ConditionVariable] Condition to wait on
+      # @param trigger [Proc] Lambda receiving context to trigger execution
+      # @raise [Taski::TaskAbortException] If the registry requested an abort
+      def trigger_and_wait(state_accessor:, condition:, trigger:)
         should_execute = false
         @monitor.synchronize do
-          case @clean_state
+          case state_accessor.call
           when STATE_PENDING
             check_abort!
             should_execute = true
           when STATE_RUNNING
-            @clean_condition.wait_until { @clean_state == STATE_COMPLETED }
+            condition.wait_until { state_accessor.call == STATE_COMPLETED }
           when STATE_COMPLETED
             # Already done
           end
@@ -319,9 +323,8 @@ module Taski
 
         if should_execute
           # Execute outside the lock to avoid deadlock
-          # Use ensure_execution_context to reuse the context from run phase
           context = ensure_execution_context
-          context.trigger_clean(@task.class, registry: @registry)
+          trigger.call(context)
           # After execution returns, the task is completed
         end
       end