taski 0.9.1 → 0.9.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7c7ea0740de2f0d1fcf24a72fe5b32e75128fa4d793718b3ac12a2c041c37628
-  data.tar.gz: 8fb45c4d390a98709d934f4b59f14a613d689ed7538df630cb4328bc405b2803
+  metadata.gz: 6cf783b65df1fdbbb8c8f19d78467243ea1d054c1b47097cae24b11d22d30c56
+  data.tar.gz: f5a88d4f88a6babb6e121b93cd22066691563a539c722cd8a3e336258ebfe495
 SHA512:
-  metadata.gz: 7cba0b749c9f5b5e76f990731017d18c550407215f851877129d2c6b1c9872fccfb3d0e088b01db19a92064f92592971a085ca9eecca3bcd8742e44b7374a9e5
-  data.tar.gz: 211b4d9ed455e19688bbb29acc7beb5043150703e144bb38f973b68f6bbf5fb3aa942c7fd2d77faa4332df243cb5f0d50e4a06813c7786b7c954f5a8eb674900
+  metadata.gz: ff7ccc6b57e2ed321a84406e2e8e913aac4ec5d9cf2e6f3d00f28cc9b22bbb6609147d500a3fca1dde7fe37bb921cd8ba00380c9b52962f71ea5e2331bef8e16
+  data.tar.gz: 5978f76dab28ef8cc3f57338a89996e9ba45fce7c897cf7739e7ada9076e5fc0006bb5663a1723c5492140fec8e14f5811100a8325e96dc56ebdf35684aeca0b

data/CHANGELOG.md

@@ -7,6 +7,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.9.2] - 2026-02-16
+
+### Added
+- Progress::Config API for declarative layout/theme configuration ([#180](https://github.com/ahogappa/taski/pull/180))
+- Split Layout::Tree into Tree::Live (TTY) and Tree::Event (non-TTY) with `Tree.for` factory ([#181](https://github.com/ahogappa/taski/pull/181))
+
+### Fixed
+- Add base64 as runtime dependency ([#182](https://github.com/ahogappa/taski/pull/182))
+- Use done_count instead of completed_count in completion display ([#179](https://github.com/ahogappa/taski/pull/179))
+- Pass skipped_count in Simple layout's render_final ([#179](https://github.com/ahogappa/taski/pull/179))
+- Show most recently started tasks first in simple progress display ([#178](https://github.com/ahogappa/taski/pull/178))
+
 ## [0.9.1] - 2026-02-16
 
 ### Changed

data/lib/taski/progress/config.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Taski
+  module Progress
+    # Configuration for progress display.
+    # Holds class references for Layout and Theme, and builds display instances lazily.
+    #
+    # @example
+    #   Taski.progress.layout = Taski::Progress::Layout::Tree
+    #   Taski.progress.theme = Taski::Progress::Theme::Detail
+    class Config
+      attr_reader :layout, :theme, :output
+
+      # @param on_invalidate [Proc, nil] Called when config changes (to clear external caches)
+      def initialize(&on_invalidate)
+        @layout = nil
+        @theme = nil
+        @output = nil
+        @cached_display = nil
+        @on_invalidate = on_invalidate
+      end
+
+      def layout=(klass)
+        validate_layout!(klass) if klass
+        @layout = klass
+        invalidate!
+      end
+
+      def theme=(klass)
+        validate_theme!(klass) if klass
+        @theme = klass
+        invalidate!
+      end
+
+      def output=(io)
+        @output = io
+        invalidate!
+      end
+
+      # Build a Layout instance from the current config.
+      # Returns a cached instance if config hasn't changed.
+      def build
+        @cached_display ||= build_display
+      end
+
+      # Reset all settings to defaults.
+      def reset
+        @layout = nil
+        @theme = nil
+        @output = nil
+        invalidate!
+      end
+
+      private
+
+      def invalidate!
+        @cached_display = nil
+        @on_invalidate&.call
+      end
+
+      def build_display
+        layout_ref = @layout || Layout::Simple
+        args = {}
+        args[:theme] = @theme.new if @theme
+        args[:output] = @output if @output
+
+        if layout_ref.respond_to?(:for)
+          layout_ref.for(**args)
+        else
+          layout_ref.new(**args)
+        end
+      end
+
+      def validate_layout!(klass)
+        # Accept a Class that inherits from Base, or a Module with .for factory
+        valid = (klass.is_a?(Class) && klass <= Layout::Base) ||
+          (klass.is_a?(Module) && klass.respond_to?(:for))
+        unless valid
+          raise ArgumentError, "layout must be a Layout::Base subclass or a module with .for, got #{klass.inspect}"
+        end
+      end
+
+      def validate_theme!(klass)
+        unless klass.is_a?(Class) && klass <= Theme::Base
+          raise ArgumentError, "theme must be a subclass of Taski::Progress::Theme::Base, got #{klass.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/taski/progress/layout/base.rb

@@ -267,7 +267,7 @@ module Taski
           if failed_count > 0
             render_execution_failed(failed_count: failed_count, total_count: total_count, total_duration: total_duration, skipped_count: skipped_count)
           else
-            render_execution_completed(completed_count: completed_count, total_count: total_count, total_duration: total_duration, skipped_count: skipped_count)
+            render_execution_completed(done_count: done_count, total_count: total_count, total_duration: total_duration, skipped_count: skipped_count)
           end
         end
 
@@ -372,8 +372,8 @@ module Taski
         end
 
         # Render execution complete event
-        def render_execution_completed(completed_count:, total_count:, total_duration:, skipped_count: 0)
-          execution = ExecutionDrop.new(state: :completed, completed_count:, total_count:, total_duration:, skipped_count:)
+        def render_execution_completed(done_count:, total_count:, total_duration:, skipped_count: 0)
+          execution = ExecutionDrop.new(state: :completed, done_count:, total_count:, total_duration:, skipped_count:)
           render_execution_template(:execution_complete, execution:)
         end
 
@@ -515,6 +515,28 @@ module Taski
           task_class.name || task_class.to_s
         end
 
+        # Start a periodic render loop in a background thread.
+        # Starts spinner timer and calls the given block at @theme.render_interval.
+        # @yield Block to execute each render cycle (called under @monitor.synchronize)
+        def render_loop(&block)
+          @render_thread_running = true
+          start_spinner_timer
+          @render_thread = Thread.new do
+            while @render_thread_running
+              @monitor.synchronize(&block)
+              sleep @theme.render_interval
+            end
+          end
+        end
+
+        # Stop the periodic render loop and spinner timer.
+        def stop_render_loop
+          @render_thread_running = false
+          @render_thread&.join
+          @render_thread = nil
+          stop_spinner_timer
+        end
+
         # Check if output is a TTY
         def tty?
           @output.tty?

data/lib/taski/progress/layout/simple.rb

@@ -36,9 +36,6 @@ module Taski
         def initialize(output: $stdout, theme: nil)
           theme ||= Theme::Compact.new
           super
-          @renderer_thread = nil
-          @running = false
-          @running_mutex = Mutex.new
         end
 
         protected
@@ -70,38 +67,26 @@ module Taski
         end
 
         def handle_start
-          @running_mutex.synchronize { @running = true }
-          start_spinner_timer
           @output.print "\e[?25l"  # Hide cursor
-          @renderer_thread = Thread.new do
-            loop do
-              break unless @running_mutex.synchronize { @running }
-              render_live
-              sleep @theme.render_interval
-            end
-          end
+          render_loop { render_status_line }
         end
 
         def handle_stop
-          @running_mutex.synchronize { @running = false }
-          @renderer_thread&.join
-          stop_spinner_timer
+          stop_render_loop
           @output.print "\e[?25h"  # Show cursor
           render_final
         end
 
         private
 
-        def render_live
-          @monitor.synchronize do
-            line = build_status_line
-            # Truncate line to terminal width to prevent line wrap
-            max_width = terminal_width - 1  # Leave space for cursor
-            line = line[0, max_width] if line.length > max_width
-            # Clear line and write new content
-            @output.print "\r\e[K#{line}"
-            @output.flush
-          end
+        def render_status_line
+          line = build_status_line
+          # Truncate line to terminal width to prevent line wrap
+          max_width = terminal_width - 1  # Leave space for cursor
+          line = line[0, max_width] if line.length > max_width
+          # Clear line and write new content
+          @output.print "\r\e[K#{line}"
+          @output.flush
         end
 
         def terminal_width
@@ -113,9 +98,9 @@ module Taski
         def render_final
           @monitor.synchronize do
             line = if failed_count > 0
-              render_execution_failed(failed_count: failed_count, total_count: total_count, total_duration: total_duration)
+              render_execution_failed(failed_count: failed_count, total_count: total_count, total_duration: total_duration, skipped_count: skipped_count)
             else
-              render_execution_completed(completed_count: completed_count, total_count: total_count, total_duration: total_duration)
+              render_execution_completed(done_count: done_count, total_count: total_count, total_duration: total_duration, skipped_count: skipped_count)
             end
 
             @output.print "\r\e[K#{line}\n"
@@ -126,7 +111,7 @@ module Taski
         def build_status_line
           task_names = collect_current_task_names
 
-          primary_task = running_tasks.keys.first || cleaning_tasks.keys.first
+          primary_task = running_tasks.keys.last || cleaning_tasks.keys.last
           task_stdout = build_task_stdout(primary_task)
 
           render_execution_running(
@@ -139,12 +124,13 @@ module Taski
 
         def collect_current_task_names
           # Prioritize: cleaning > running > pending
+          # Reverse so most recently started tasks appear first
           current_tasks = if cleaning_tasks.any?
-            cleaning_tasks.keys
+            cleaning_tasks.keys.reverse
           elsif running_tasks.any?
-            running_tasks.keys
+            running_tasks.keys.reverse
           elsif pending_tasks.any?
-            pending_tasks.keys
+            pending_tasks.keys.reverse
           else
             []
           end

data/lib/taski/progress/layout/theme_drop.rb

@@ -76,7 +76,7 @@ module Taski
       #   failed_count, total_count, total_duration, root_task_name, task_names
       #
       # @example Using in Liquid template
-      #   [{{ execution.completed_count }}/{{ execution.total_count }}]
+      #   [{{ execution.done_count }}/{{ execution.total_count }}]
       #   {{ execution.total_duration | format_duration }}
       class ExecutionDrop < DataDrop; end
     end

data/lib/taski/progress/layout/tree/event.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "../base"
+require_relative "../../theme/detail"
+require_relative "structure"
+
+module Taski
+  module Progress
+    module Layout
+      module Tree
+        # Non-TTY event-driven tree layout.
+        # Outputs lines immediately with tree prefixes as events arrive.
+        # Used for logs, CI, piped output, and static tree display.
+        class Event < Base
+          include Structure
+
+          def initialize(output: $stderr, theme: nil)
+            theme ||= Theme::Detail.new
+            super
+            init_tree_structure
+          end
+
+          protected
+
+          def handle_ready
+            build_ready_tree
+          end
+
+          def handle_task_update(task_class, current_state, phase)
+            progress = @tasks[task_class]
+            duration = compute_duration(progress, phase)
+            text = render_for_task_event(task_class, current_state, duration, nil, phase)
+            output_with_prefix(task_class, text) if text
+          end
+
+          def handle_group_started(task_class, group_name, phase)
+            text = render_group_started(task_class, group_name: group_name)
+            output_with_prefix(task_class, text) if text
+          end
+
+          def handle_group_completed(task_class, group_name, phase, duration)
+            text = render_group_succeeded(task_class, group_name: group_name, task_duration: duration)
+            output_with_prefix(task_class, text) if text
+          end
+        end
+      end
+    end
+  end
+end

data/lib/taski/progress/layout/tree/live.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative "../base"
+require_relative "../../theme/detail"
+require_relative "structure"
+
+module Taski
+  module Progress
+    module Layout
+      module Tree
+        # TTY periodic-update tree layout.
+        # Refreshes the entire tree display at regular intervals with spinner animation.
+        # Used for interactive terminal output.
+        class Live < Base
+          include Structure
+
+          def initialize(output: $stderr, theme: nil)
+            theme ||= Theme::Detail.new
+            super
+            init_tree_structure
+            @last_line_count = 0
+          end
+
+          protected
+
+          def handle_ready
+            build_ready_tree
+          end
+
+          # TTY mode: skip per-event output, tree is updated by render_loop
+          def handle_task_update(_task_class, _current_state, _phase)
+          end
+
+          def handle_group_started(_task_class, _group_name, _phase)
+          end
+
+          def handle_group_completed(_task_class, _group_name, _phase, _duration)
+          end
+
+          def should_activate?
+            tty?
+          end
+
+          def handle_start
+            @output.print "\e[?25l" # Hide cursor
+            render_loop { render_tree_live }
+          end
+
+          def handle_stop
+            stop_render_loop
+            @output.print "\e[?25h" # Show cursor
+            render_final
+          end
+
+          private
+
+          def render_tree_live
+            lines = build_tree_lines
+            clear_previous_output
+            lines.each { |line| @output.puts line }
+            @output.flush
+            @last_line_count = lines.size
+          end
+
+          def render_final
+            @monitor.synchronize do
+              lines = build_tree_lines
+              clear_previous_output
+
+              lines.each { |line| @output.puts line }
+              @output.puts render_execution_summary
+              @output.flush
+            end
+          end
+
+          def clear_previous_output
+            return if @last_line_count == 0
+            # Move cursor up and clear lines
+            @output.print "\e[#{@last_line_count}A\e[J"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/taski/progress/layout/tree/structure.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module Taski
+  module Progress
+    module Layout
+      module Tree
+        # Shared tree structure logic for Tree::Live and Tree::Event.
+        # Provides tree building, node registration, prefix generation,
+        # and tree rendering methods.
+        module Structure
+          # Tree connector characters
+          BRANCH = "├── "
+          LAST_BRANCH = "└── "
+          VERTICAL = "│   "
+          SPACE = "    "
+
+          # Returns the tree structure as a string.
+          # Uses the current theme to render task content for each node.
+          def render_tree
+            build_tree_lines.join("\n") + "\n"
+          end
+
+          protected
+
+          def init_tree_structure
+            @tree_nodes = {}
+            @node_depths = {}
+            @node_is_last = {}
+          end
+
+          def build_ready_tree
+            graph = context&.dependency_graph
+            root = context&.root_task_class
+            return unless graph && root
+
+            tree = build_tree_from_graph(root, graph)
+            register_tree_nodes(tree, depth: 0, is_last: true, ancestors_last: [])
+          end
+
+          # Output text with tree prefix for the given task
+          def output_with_prefix(task_class, text)
+            prefix = build_tree_prefix(task_class)
+            output_line("#{prefix}#{text}")
+          end
+
+          private
+
+          def build_tree_from_graph(task_class, graph, ancestors = Set.new)
+            is_circular = ancestors.include?(task_class)
+            node = {task_class: task_class, is_circular: is_circular, children: []}
+            return node if is_circular
+
+            new_ancestors = ancestors + [task_class]
+            deps = graph.dependencies_for(task_class)
+            deps.each do |dep|
+              child_node = build_tree_from_graph(dep, graph, new_ancestors)
+              node[:children] << child_node
+            end
+            node
+          end
+
+          def register_tree_nodes(node, depth:, is_last:, ancestors_last:)
+            return unless node
+
+            task_class = node[:task_class]
+            @tasks[task_class] ||= new_task_progress
+            @tree_nodes[task_class] = node
+            @node_depths[task_class] = depth
+            @node_is_last[task_class] = {is_last: is_last, ancestors_last: ancestors_last.dup}
+
+            children = node[:children]
+            children.each_with_index do |child, index|
+              child_is_last = (index == children.size - 1)
+              new_ancestors_last = ancestors_last + [is_last]
+              register_tree_nodes(child, depth: depth + 1, is_last: child_is_last, ancestors_last: new_ancestors_last)
+            end
+          end
+
+          def build_tree_lines
+            return [] unless @root_task_class
+
+            lines = []
+            root_node = @tree_nodes[@root_task_class]
+            build_node_lines(root_node, lines)
+            lines
+          end
+
+          def build_node_lines(node, lines)
+            return unless node
+
+            task_class = node[:task_class]
+            prefix = build_tree_prefix(task_class)
+            content = build_task_content(task_class)
+            lines << "#{prefix}#{content}"
+
+            node[:children].each do |child|
+              build_node_lines(child, lines)
+            end
+          end
+
+          def build_task_content(task_class)
+            progress = @tasks[task_class]
+
+            case progress&.dig(:run_state)
+            when :running
+              render_task_started(task_class)
+            when :completed
+              render_task_succeeded(task_class, task_duration: compute_duration(progress, :run))
+            when :failed
+              render_task_failed(task_class, error: nil)
+            when :skipped
+              render_task_skipped(task_class)
+            else
+              task = TaskDrop.new(name: task_class_name(task_class), state: :pending)
+              render_task_template(:task_pending, task:, execution: execution_drop)
+            end
+          end
+
+          def build_tree_prefix(task_class)
+            depth = @node_depths[task_class]
+            return "" if depth.nil? || depth == 0
+
+            last_info = @node_is_last[task_class]
+            return "" unless last_info
+
+            ancestors_last = last_info[:ancestors_last]
+            is_last = last_info[:is_last]
+
+            prefix = ""
+            # Skip the first ancestor (root) since root has no visual prefix
+            ancestors_last[1..].each do |ancestor_is_last|
+              prefix += ancestor_is_last ? SPACE : VERTICAL
+            end
+
+            prefix += is_last ? LAST_BRANCH : BRANCH
+            prefix
+          end
+        end
+      end
+    end
+  end
+end

data/lib/taski/progress/layout/tree.rb

@@ -1,299 +1,41 @@
 # frozen_string_literal: true
 
-require_relative "base"
-require_relative "../theme/detail"
+require_relative "tree/structure"
+require_relative "tree/live"
+require_relative "tree/event"
 
 module Taski
   module Progress
     module Layout
-      # Tree layout for hierarchical task display.
-      # Renders tasks in a tree structure with visual connectors (├──, └──, │).
+      # Tree layout module for hierarchical task display.
+      # Renders tasks in a tree structure with visual connectors.
       #
-      # Operates in two modes:
-      # - TTY mode: Periodic full-tree refresh with spinner animation
-      # - Non-TTY mode: Incremental output with tree prefixes (for logs/tests)
+      # Contains two implementations:
+      # - Tree::Live  — TTY periodic-update with spinner animation
+      # - Tree::Event — Non-TTY event-driven incremental output
       #
-      # Output format (live updating):
-      #   BuildApplication
-      #   ├── ⠹ SetupDatabase
-      #   │   ├── ✓ CreateSchema (50ms)
-      #   │   └── ⠹ SeedData
-      #   ├── ○ ExtractLayers
-      #   │   ├── ✓ DownloadLayer1 (100ms)
-      #   │   └── ○ DownloadLayer2
-      #   └── ✓ RunSystemCommand (200ms)
+      # Use Tree.for to automatically select the appropriate implementation.
       #
-      # The tree structure (prefixes) is added by this Layout.
-      # The task content (icons, names, duration) comes from the Theme.
+      # @example Auto-select based on output TTY
+      #   layout = Taski::Progress::Layout::Tree.for
       #
-      # This demonstrates the Theme/Layout separation:
-      # - Theme defines "what one line looks like" (icons, colors, formatting)
-      # - Layout defines "how lines are arranged" (tree structure, prefixes)
-      #
-      # @example Using with Theme::Default
-      #   layout = Taski::Progress::Layout::Tree.new(theme: Taski::Progress::Theme::Default.new)
-      class Tree < Base
-        # Tree connector characters
-        BRANCH = "├── "
-        LAST_BRANCH = "└── "
-        VERTICAL = "│   "
-        SPACE = "    "
-
-        def initialize(output: $stderr, theme: nil)
-          theme ||= Theme::Detail.new
-          super
-          @tree_nodes = {}
-          @node_depths = {}
-          @node_is_last = {}
-          @renderer_thread = nil
-          @running = false
-          @running_mutex = Mutex.new
-          @last_line_count = 0
-          @non_tty_started = false
-        end
-
-        # Returns the tree structure as a string.
-        # Uses the current theme to render task content for each node.
-        def render_tree
-          build_tree_lines.join("\n") + "\n"
-        end
-
-        # Override on_start to handle non-TTY mode
-        def on_start
-          @monitor.synchronize do
-            @nest_level += 1
-            return if @nest_level > 1
-
-            @start_time = Time.now
-
-            if should_activate?
-              @active = true
-            else
-              # Non-TTY mode: output execution start message
-              @non_tty_started = true
-              output_line(render_execution_started(@root_task_class)) if @root_task_class
-            end
-          end
-
-          handle_start if @active
-        end
-
-        # Override on_stop to handle non-TTY mode
-        def on_stop
-          was_active = false
-          non_tty_was_started = false
-          @monitor.synchronize do
-            @nest_level -= 1 if @nest_level > 0
-            return unless @nest_level == 0
-            was_active = @active
-            non_tty_was_started = @non_tty_started
-            @active = false
-            @non_tty_started = false
-          end
-
-          if was_active
-            handle_stop
-          elsif non_tty_was_started
-            # Non-TTY mode: output execution summary
-            output_execution_summary
-          end
-          flush_queued_messages
-        end
-
-        protected
-
-        def handle_ready
-          graph = context&.dependency_graph
-          root = context&.root_task_class
-          return unless graph && root
-
-          tree = build_tree_from_graph(root, graph)
-          register_tree_nodes(tree, depth: 0, is_last: true, ancestors_last: [])
-        end
-
-        # In TTY mode, tree is updated by render_live periodically.
-        # In non-TTY mode, output lines immediately with tree prefix.
-        def handle_task_update(task_class, current_state, phase)
-          return if @active  # TTY mode: skip per-event output
-
-          # Non-TTY mode: output with tree prefix
-          progress = @tasks[task_class]
-          duration = compute_duration(progress, phase)
-          text = render_for_task_event(task_class, current_state, duration, nil, phase)
-          output_with_prefix(task_class, text) if text
-        end
-
-        def handle_group_started(task_class, group_name, phase)
-          return if @active  # TTY mode: skip per-event output
-
-          # Non-TTY mode: output with tree prefix
-          text = render_group_started(task_class, group_name: group_name)
-          output_with_prefix(task_class, text) if text
-        end
-
-        def handle_group_completed(task_class, group_name, phase, duration)
-          return if @active  # TTY mode: skip per-event output
-
-          # Non-TTY mode: output with tree prefix
-          text = render_group_succeeded(task_class, group_name: group_name, task_duration: duration)
-          output_with_prefix(task_class, text) if text
-        end
-
-        def should_activate?
-          tty?
-        end
-
-        def handle_start
-          @running_mutex.synchronize { @running = true }
-          start_spinner_timer
-          @output.print "\e[?25l" # Hide cursor
-          @renderer_thread = Thread.new do
-            loop do
-              break unless @running_mutex.synchronize { @running }
-              render_live
-              sleep @theme.render_interval
-            end
-          end
-        end
-
-        def handle_stop
-          @running_mutex.synchronize { @running = false }
-          @renderer_thread&.join
-          stop_spinner_timer
-          @output.print "\e[?25h" # Show cursor
-          render_final
-        end
-
-        private
-
-        # Output text with tree prefix for the given task
-        def output_with_prefix(task_class, text)
-          prefix = build_tree_prefix(task_class)
-          output_line("#{prefix}#{text}")
-        end
-
-        # Output execution summary for non-TTY mode
-        def output_execution_summary
-          output_line(render_execution_summary)
-        end
-
-        def build_tree_from_graph(task_class, graph, ancestors = Set.new)
-          is_circular = ancestors.include?(task_class)
-          node = {task_class: task_class, is_circular: is_circular, children: []}
-          return node if is_circular
-
-          new_ancestors = ancestors + [task_class]
-          deps = graph.dependencies_for(task_class)
-          deps.each do |dep|
-            child_node = build_tree_from_graph(dep, graph, new_ancestors)
-            node[:children] << child_node
-          end
-          node
-        end
-
-        def register_tree_nodes(node, depth:, is_last:, ancestors_last:)
-          return unless node
-
-          task_class = node[:task_class]
-          @tasks[task_class] ||= new_task_progress
-          @tree_nodes[task_class] = node
-          @node_depths[task_class] = depth
-          @node_is_last[task_class] = {is_last: is_last, ancestors_last: ancestors_last.dup}
-
-          children = node[:children]
-          children.each_with_index do |child, index|
-            child_is_last = (index == children.size - 1)
-            new_ancestors_last = ancestors_last + [is_last]
-            register_tree_nodes(child, depth: depth + 1, is_last: child_is_last, ancestors_last: new_ancestors_last)
-          end
-        end
-
-        def render_live
-          @monitor.synchronize do
-            lines = build_tree_lines
-            clear_previous_output
-            lines.each { |line| @output.puts line }
-            @output.flush
-            @last_line_count = lines.size
-          end
-        end
-
-        def render_final
-          @monitor.synchronize do
-            lines = build_tree_lines
-            clear_previous_output
-
-            lines.each { |line| @output.puts line }
-            @output.puts render_execution_summary
-            @output.flush
-          end
-        end
-
-        def clear_previous_output
-          return if @last_line_count == 0
-          # Move cursor up and clear lines
-          @output.print "\e[#{@last_line_count}A\e[J"
-        end
-
-        def build_tree_lines
-          return [] unless @root_task_class
-
-          lines = []
-          root_node = @tree_nodes[@root_task_class]
-          build_node_lines(root_node, lines)
-          lines
-        end
-
-        def build_node_lines(node, lines)
-          return unless node
-
-          task_class = node[:task_class]
-          prefix = build_tree_prefix(task_class)
-          content = build_task_content(task_class)
-          lines << "#{prefix}#{content}"
-
-          node[:children].each do |child|
-            build_node_lines(child, lines)
-          end
-        end
-
-        def build_task_content(task_class)
-          progress = @tasks[task_class]
-
-          case progress&.dig(:run_state)
-          when :running
-            render_task_started(task_class)
-          when :completed
-            render_task_succeeded(task_class, task_duration: compute_duration(progress, :run))
-          when :failed
-            render_task_failed(task_class, error: nil)
-          when :skipped
-            render_task_skipped(task_class)
+      # @example Explicit selection
+      #   layout = Taski::Progress::Layout::Tree::Live.new   # TTY
+      #   layout = Taski::Progress::Layout::Tree::Event.new  # non-TTY
+      module Tree
+        # Factory method to create the appropriate tree layout.
+        # Returns Tree::Live for TTY outputs, Tree::Event otherwise.
+        #
+        # @param output [IO] Output stream (default: $stderr)
+        # @param theme [Theme::Base, nil] Theme instance
+        # @return [Tree::Live, Tree::Event]
+        def self.for(output: $stderr, theme: nil)
+          if output.respond_to?(:tty?) && output.tty?
+            Live.new(output: output, theme: theme)
           else
-            task = TaskDrop.new(name: task_class_name(task_class), state: :pending)
-            render_task_template(:task_pending, task:, execution: execution_drop)
+            Event.new(output: output, theme: theme)
           end
         end
-
-        def build_tree_prefix(task_class)
-          depth = @node_depths[task_class]
-          return "" if depth.nil? || depth == 0
-
-          last_info = @node_is_last[task_class]
-          return "" unless last_info
-
-          ancestors_last = last_info[:ancestors_last]
-          is_last = last_info[:is_last]
-
-          prefix = ""
-          # Skip the first ancestor (root) since root has no visual prefix
-          ancestors_last[1..].each do |ancestor_is_last|
-            prefix += ancestor_is_last ? SPACE : VERTICAL
-          end
-
-          prefix += is_last ? LAST_BRANCH : BRANCH
-          prefix
-        end
       end
     end
   end

data/lib/taski/progress/theme/base.rb

@@ -84,7 +84,7 @@ module Taski
         end
 
         def execution_complete
-          "[TASKI] Completed: {{ execution.completed_count }}/{{ execution.total_count }} tasks ({{ execution.total_duration | format_duration }})"
+          "[TASKI] Completed: {{ execution.done_count }}/{{ execution.total_count }} tasks ({{ execution.total_duration | format_duration }})"
         end
 
         def execution_fail

data/lib/taski/progress/theme/compact.rb

@@ -45,7 +45,7 @@ module Taski
 
         # Execution complete with icon
         def execution_complete
-          "{% icon %} [TASKI] Completed: {{ execution.completed_count }}/{{ execution.total_count }} tasks ({{ execution.total_duration | format_duration }})"
+          "{% icon %} [TASKI] Completed: {{ execution.done_count }}/{{ execution.total_count }} tasks ({{ execution.total_duration | format_duration }})"
         end
 
         # Execution fail with icon

data/lib/taski/task.rb

@@ -115,7 +115,7 @@ module Taski
       def tree
         output = StringIO.new
         theme = Progress::Theme::Plain.new
-        layout = Progress::Layout::Tree.new(output: output, theme: theme)
+        layout = Progress::Layout::Tree.for(output: output, theme: theme)
         context = Execution::ExecutionFacade.new(root_task_class: self)
         layout.context = context
         layout.on_ready

data/lib/taski/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Taski
-  VERSION = "0.9.1"
+  VERSION = "0.9.2"
 end

data/lib/taski.rb

@@ -16,6 +16,7 @@ require_relative "taski/execution/executor"
 require_relative "taski/progress/layout/log"
 require_relative "taski/progress/layout/simple"
 require_relative "taski/progress/layout/tree"
+require_relative "taski/progress/config"
 require_relative "taski/args"
 require_relative "taski/env"
 require_relative "taski/logging"
@@ -267,14 +268,28 @@ module Taski
     reset_args! if created_args
   end
 
-  NOT_CONFIGURED = Object.new.freeze
   PROGRESS_MONITOR = Monitor.new
-  @progress_display = NOT_CONFIGURED
+  PROGRESS_NOT_SET = Object.new.freeze
+  @progress_display = PROGRESS_NOT_SET
+  @progress_config = Progress::Config.new {
+    PROGRESS_MONITOR.synchronize do
+      unless @progress_display.equal?(PROGRESS_NOT_SET)
+        @progress_display.stop if @progress_display.respond_to?(:stop)
+      end
+      @progress_display = PROGRESS_NOT_SET
+    end
+  }
+
+  # Get the progress configuration singleton.
+  # @return [Progress::Config]
+  def self.progress
+    PROGRESS_MONITOR.synchronize { @progress_config }
+  end
 
   def self.progress_display
     PROGRESS_MONITOR.synchronize do
-      if @progress_display.equal?(NOT_CONFIGURED)
-        @progress_display = Progress::Layout::Simple.new
+      if @progress_display.equal?(PROGRESS_NOT_SET)
+        @progress_display = @progress_config.build
       end
       @progress_display
     end
@@ -282,7 +297,7 @@ module Taski
 
   def self.progress_display=(display)
     PROGRESS_MONITOR.synchronize do
-      unless @progress_display.equal?(NOT_CONFIGURED)
+      unless @progress_display.equal?(PROGRESS_NOT_SET)
         @progress_display.stop if @progress_display.respond_to?(:stop)
       end
       @progress_display = display
@@ -291,10 +306,11 @@ module Taski
 
   def self.reset_progress_display!
     PROGRESS_MONITOR.synchronize do
-      unless @progress_display.equal?(NOT_CONFIGURED)
+      unless @progress_display.equal?(PROGRESS_NOT_SET)
         @progress_display.stop if @progress_display.respond_to?(:stop)
       end
-      @progress_display = NOT_CONFIGURED
+      @progress_display = PROGRESS_NOT_SET
+      @progress_config.reset
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: taski
 version: !ruby/object:Gem::Version
-  version: 0.9.1
+  version: 0.9.2
 platform: ruby
 authors:
 - ahogappa
@@ -9,6 +9,20 @@ bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: liquid
   requirement: !ruby/object:Gem::Requirement
@@ -93,6 +107,7 @@ files:
 - lib/taski/execution/task_wrapper.rb
 - lib/taski/execution/worker_pool.rb
 - lib/taski/logging.rb
+- lib/taski/progress/config.rb
 - lib/taski/progress/layout/base.rb
 - lib/taski/progress/layout/filters.rb
 - lib/taski/progress/layout/log.rb
@@ -100,6 +115,9 @@ files:
 - lib/taski/progress/layout/tags.rb
 - lib/taski/progress/layout/theme_drop.rb
 - lib/taski/progress/layout/tree.rb
+- lib/taski/progress/layout/tree/event.rb
+- lib/taski/progress/layout/tree/live.rb
+- lib/taski/progress/layout/tree/structure.rb
 - lib/taski/progress/theme/base.rb
 - lib/taski/progress/theme/compact.rb
 - lib/taski/progress/theme/default.rb