taski 0.5.0 → 0.7.1

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/registry.rb

@@ -16,7 +16,9 @@ module Taski
       # @yield Block to create the task instance if it doesn't exist
       # @return [Object] The task instance
       def get_or_create(task_class)
-        @tasks[task_class] ||= yield
+        @monitor.synchronize do
+          @tasks[task_class] ||= yield
+        end
       end
 
       # @param task_class [Class] The task class
@@ -61,6 +63,20 @@ module Taski
         @monitor.synchronize { @abort_requested }
       end
 
+      # @return [Array<TaskWrapper>] All wrappers that have errors
+      def failed_wrappers
+        @monitor.synchronize do
+          @tasks.values.select { |w| w.error }
+        end
+      end
+
+      # @return [Array<TaskWrapper>] All wrappers that have clean errors
+      def failed_clean_wrappers
+        @monitor.synchronize do
+          @tasks.values.select { |w| w.clean_error }
+        end
+      end
+
       # @param task_class [Class] The task class to run
       # @param exported_methods [Array<Symbol>] Methods to call to trigger execution
       # @return [Object] The result of the task execution

data/lib/taski/execution/scheduler.rb

@@ -0,0 +1,308 @@
+# frozen_string_literal: true
+
+module Taski
+  module Execution
+    # Scheduler manages task dependency state and determines execution order.
+    # It tracks which tasks are pending, enqueued, or completed, and provides
+    # methods to determine which tasks are ready to execute.
+    #
+    # == Responsibilities
+    #
+    # - Build dependency graph from root task via static analysis
+    # - Track task states: pending, enqueued, completed
+    # - Determine which tasks are ready to execute (all dependencies completed)
+    # - Provide next_ready_tasks for the Executor's event loop
+    # - Build reverse dependency graph for clean operations
+    # - Track clean states independently from run states
+    # - Provide next_ready_clean_tasks for reverse dependency order execution
+    #
+    # == API
+    #
+    # Run operations:
+    # - {#build_dependency_graph} - Initialize dependency graph from root task
+    # - {#next_ready_tasks} - Get tasks ready for execution
+    # - {#mark_enqueued} - Mark task as sent to worker pool
+    # - {#mark_completed} - Mark task as finished
+    # - {#completed?} - Check if task is completed
+    # - {#running_tasks?} - Check if any tasks are currently executing
+    #
+    # Clean operations:
+    # - {#build_reverse_dependency_graph} - Build reverse graph for clean order
+    # - {#next_ready_clean_tasks} - Get tasks ready for clean (reverse order)
+    # - {#mark_clean_enqueued} - Mark task as sent for clean
+    # - {#mark_clean_completed} - Mark task as clean finished
+    # - {#clean_completed?} - Check if task clean is completed
+    # - {#running_clean_tasks?} - Check if any clean tasks are currently executing
+    #
+    # == Thread Safety
+    #
+    # Scheduler is only accessed from the main thread in Executor,
+    # so no synchronization is needed. The Executor serializes all
+    # access to the Scheduler through its event loop.
+    class Scheduler
+      # Task execution states
+      STATE_PENDING = :pending
+      STATE_ENQUEUED = :enqueued
+      STATE_COMPLETED = :completed
+
+      # Clean execution states (independent from run states)
+      CLEAN_STATE_PENDING = :clean_pending
+      CLEAN_STATE_ENQUEUED = :clean_enqueued
+      CLEAN_STATE_COMPLETED = :clean_completed
+
+      ##
+      # Initializes internal data structures used to track normal and clean task execution.
+      #
+      # Sets up:
+      # - @dependencies: map from task class to its dependency task classes.
+      # - @task_states: map from task class to its normal execution state.
+      # - @completed_tasks: set of task classes that have completed normal execution.
+      # - @reverse_dependencies: map from task class to dependent task classes (used for clean ordering).
+      # - @clean_task_states: map from task class to its clean execution state.
+      # - @clean_completed_tasks: set of task classes that have completed clean execution.
+      def initialize
+        # Run execution state
+        @dependencies = {}
+        @task_states = {}
+        @completed_tasks = Set.new
+
+        # Clean execution state (independent tracking)
+        @reverse_dependencies = {}
+        @clean_task_states = {}
+        @clean_completed_tasks = Set.new
+      end
+
+      # Build dependency graph by traversing from root task.
+      # Populates internal state with all tasks and their dependencies.
+      #
+      # @param root_task_class [Class] The root task class to start from
+      def build_dependency_graph(root_task_class)
+        # @type var queue: Array[singleton(Taski::Task)]
+        queue = [root_task_class]
+
+        while (task_class = queue.shift)
+          next if @task_states.key?(task_class)
+
+          deps = task_class.cached_dependencies
+          @dependencies[task_class] = deps.dup
+          @task_states[task_class] = STATE_PENDING
+
+          deps.each { |dep| queue << dep }
+        end
+      end
+
+      # Get all tasks that are ready to execute.
+      # A task is ready when all its dependencies are completed.
+      #
+      # @return [Array<Class>] Array of task classes ready for execution
+      def next_ready_tasks
+        ready = []
+        @task_states.each_key do |task_class|
+          next unless @task_states[task_class] == STATE_PENDING
+          next unless ready_to_execute?(task_class)
+          ready << task_class
+        end
+        ready
+      end
+
+      # Mark a task as enqueued for execution.
+      #
+      # @param task_class [Class] The task class to mark
+      def mark_enqueued(task_class)
+        @task_states[task_class] = STATE_ENQUEUED
+      end
+
+      # Mark a task as completed.
+      #
+      # @param task_class [Class] The task class to mark
+      def mark_completed(task_class)
+        @task_states[task_class] = STATE_COMPLETED
+        @completed_tasks.add(task_class)
+      end
+
+      # Check if a task is completed.
+      #
+      # @param task_class [Class] The task class to check
+      # @return [Boolean] true if the task is completed
+      def completed?(task_class)
+        @completed_tasks.include?(task_class)
+      end
+
+      # Check if there are any running (enqueued) tasks.
+      #
+      ##
+      # Indicates whether any tasks are currently enqueued for execution.
+      # @return [Boolean] `true` if any task is enqueued, `false` otherwise.
+      def running_tasks?
+        @task_states.values.any? { |state| state == STATE_ENQUEUED }
+      end
+
+      # ========================================
+      # Runtime Dependency Merging
+      # ========================================
+
+      # Merge runtime dependencies into the dependency graph.
+      # Used to incorporate dynamically selected dependencies (e.g., Section implementations)
+      # that were determined during the run phase.
+      #
+      # This method also updates reverse dependencies if they exist (for clean operations).
+      # This method is idempotent - calling it multiple times with the same data is safe.
+      #
+      # @param runtime_deps [Hash{Class => Set<Class>}] Runtime dependencies from ExecutionContext
+      def merge_runtime_dependencies(runtime_deps)
+        runtime_deps.each do |from_class, to_classes|
+          # Ensure the from_class exists in the graph
+          @dependencies[from_class] ||= Set.new
+          @task_states[from_class] ||= STATE_PENDING
+
+          to_classes.each do |to_class|
+            # Add the dependency relationship
+            @dependencies[from_class].add(to_class)
+
+            # Add the to_class to the graph if not present
+            unless @dependencies.key?(to_class)
+              @dependencies[to_class] = to_class.cached_dependencies
+              @task_states[to_class] = STATE_PENDING
+            end
+
+            # Update reverse dependencies if they exist (for clean operations)
+            # If A depends on B (from_class→to_class), then B→[A] in reverse graph
+            if @reverse_dependencies.any?
+              @reverse_dependencies[to_class] ||= Set.new
+              @reverse_dependencies[to_class].add(from_class)
+
+              # Ensure to_class has clean state initialized
+              @clean_task_states[to_class] ||= CLEAN_STATE_PENDING
+            end
+          end
+        end
+      end
+
+      # ========================================
+      # Clean Operations (Reverse Dependency Order)
+      # ========================================
+
+      # Build reverse dependency graph for clean operations.
+      # Clean operations run in reverse order: if A depends on B, then B must
+      # be cleaned after A (so A→[B] in reverse graph means B depends on A's clean).
+      #
+      # Also initializes clean states for all tasks to CLEAN_STATE_PENDING.
+      #
+      ##
+      # Builds the reverse dependency graph and initializes per-task clean execution state starting from the given root task.
+      #
+      # Ensures the forward dependency graph is present, clears prior clean-state data, initializes each discovered task with
+      # an empty reverse-dependency set and `CLEAN_STATE_PENDING`, and populates reverse mappings so a task's clean run
+      # depends on the clean completion of tasks that depend on it.
+      # @param [Class] root_task_class The root task class from which to discover tasks and their dependencies.
+      def build_reverse_dependency_graph(root_task_class)
+        # First, ensure we have the forward dependency graph
+        build_dependency_graph(root_task_class) if @dependencies.empty?
+
+        # Clear previous clean state
+        @reverse_dependencies.clear
+        @clean_task_states.clear
+        @clean_completed_tasks.clear
+
+        # Initialize all tasks with empty reverse dependency sets
+        @dependencies.each_key do |task_class|
+          @reverse_dependencies[task_class] = Set.new
+          @clean_task_states[task_class] = CLEAN_STATE_PENDING
+        end
+
+        # Build reverse mappings: if A depends on B, then B→[A] in reverse graph
+        # This means B's clean depends on A's clean completing first
+        @dependencies.each do |task_class, deps|
+          deps.each do |dep_class|
+            @reverse_dependencies[dep_class].add(task_class)
+          end
+        end
+      end
+
+      # Get all tasks that are ready to clean.
+      # A task is ready to clean when all its reverse dependencies (dependents)
+      # have completed their clean operation.
+      #
+      ##
+      # Lists task classes that are ready for clean execution.
+      # A task is considered ready when its clean state is `CLEAN_STATE_PENDING` and all of its reverse dependencies have completed their clean execution.
+      # @return [Array<Class>] Array of task classes ready for clean execution.
+      def next_ready_clean_tasks
+        ready = []
+        @clean_task_states.each_key do |task_class|
+          next unless @clean_task_states[task_class] == CLEAN_STATE_PENDING
+          next unless ready_to_clean?(task_class)
+          ready << task_class
+        end
+        ready
+      end
+
+      # Mark a task as enqueued for clean execution.
+      #
+      ##
+      # Marks the given task class as enqueued for clean execution.
+      # @param [Class] task_class The task class to mark as enqueued for clean execution.
+      def mark_clean_enqueued(task_class)
+        @clean_task_states[task_class] = CLEAN_STATE_ENQUEUED
+      end
+
+      # Mark a task as clean completed.
+      #
+      ##
+      # Marks the clean execution of the given task class as completed and records it.
+      # @param [Class] task_class - The task class to mark as clean completed.
+      def mark_clean_completed(task_class)
+        @clean_task_states[task_class] = CLEAN_STATE_COMPLETED
+        @clean_completed_tasks.add(task_class)
+      end
+
+      # Check if a task's clean is completed.
+      #
+      # @param task_class [Class] The task class to check
+      ##
+      # Checks whether a task class has completed its clean execution.
+      # @param [Class] task_class - The task class to check.
+      # @return [Boolean] `true` if the task's clean is completed, `false` otherwise.
+      def clean_completed?(task_class)
+        @clean_completed_tasks.include?(task_class)
+      end
+
+      # Check if there are any running (enqueued) clean tasks.
+      #
+      ##
+      # Indicates whether any clean tasks are currently enqueued for execution.
+      # @return [Boolean] `true` if at least one clean task is enqueued, `false` otherwise.
+      def running_clean_tasks?
+        @clean_task_states.values.any? { |state| state == CLEAN_STATE_ENQUEUED }
+      end
+
+      private
+
+      # Check if a task is ready to execute (all dependencies completed).
+      #
+      # @param task_class [Class] The task class to check
+      ##
+      # Determines whether a task's dependencies have all completed.
+      # @param [Class] task_class - The task class to check.
+      # @return [Boolean] `true` if every dependency of `task_class` is in the set of completed tasks, `false` otherwise.
+      def ready_to_execute?(task_class)
+        task_deps = @dependencies[task_class] || Set.new
+        task_deps.subset?(@completed_tasks)
+      end
+
+      # Check if a task is ready to clean (all reverse dependencies completed).
+      # Reverse dependencies are tasks that depend on this task, which must
+      # be cleaned before this task can be cleaned.
+      #
+      # @param task_class [Class] The task class to check
+      ##
+      # Determines whether a task is ready for clean execution.
+      # @param [Class] task_class - The task class to check.
+      # @return [Boolean] `true` if all tasks that depend on `task_class` have completed their clean execution, `false` otherwise.
+      def ready_to_clean?(task_class)
+        reverse_deps = @reverse_dependencies[task_class] || Set.new
+        reverse_deps.subset?(@clean_completed_tasks)
+      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_pipe.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Taski
+  module Execution
+    # Manages a single IO pipe for capturing task output
+    # Each task gets its own dedicated pipe for stdout capture
+    class TaskOutputPipe
+      attr_reader :read_io, :write_io, :task_class
+
+      def initialize(task_class)
+        @task_class = task_class
+        @read_io, @write_io = IO.pipe
+        @write_io.sync = true
+      end
+
+      def close_write
+        @write_io.close unless @write_io.closed?
+      end
+
+      def close_read
+        @read_io.close unless @read_io.closed?
+      end
+
+      def close
+        close_write
+        close_read
+      end
+
+      def write_closed?
+        @write_io.closed?
+      end
+
+      def read_closed?
+        @read_io.closed?
+      end
+
+      def closed?
+        write_closed? && read_closed?
+      end
+    end
+  end
+end