kettle-family 1.0.6 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 55c4dcb2f4f8b001f5e41fa816f63e0d1cc2996c28d864a1834ef264fe610cc6
-  data.tar.gz: 4586ac1f9e25c405579cc62f17ddf5206a9ba81cd8a76f1d9f127e895783e8f7
+  metadata.gz: 2aaa5d7e3543091f4cc86ed298afe481609e4c57bd85a3b4d69e0e0ec587bc80
+  data.tar.gz: 36524c2f96f04ccd148048cbbaee7222e844f78e1fa5b5dd85dcd49c53975123
 SHA512:
-  metadata.gz: 487b01bd066f0c03b5ce37fee27325c273353c03880dd29e90b93efc1c4bea0724e3dd46a9def8b0c8bdde5f9163b8226533bbdb7e4f9fc6acd67b69ab0c13d6
-  data.tar.gz: 125aecb410e6ec7f2562455e18e38cc2672899378631e96b5f0d063f61bb902161b0b1736cb8e0552b8d645c067a0e8bd467cdcd735f42541a32eaef60ea1b80
+  metadata.gz: b9efc18d3efbcfa9e16aaa867a22a8b9e59fc337f9eb41f03f02829a88c6a4707eee5ff00c5c0b24931ea428d46841bf649af572a3a1fd84416b06aa46417d7d
+  data.tar.gz: fe0e3717d364977801a8272976d2e22ae41ae3b5fdf4d4066fe57b698a28ec45089b4b88fd0b1645d57402fd427a9b8bb457439c49352b8e39bb3aac62be660e

data/CHANGELOG.md

@@ -30,6 +30,27 @@ Please file a bug if you notice a violation of semantic versioning.
 
 ### Security
 
+## [1.1.0] - 2026-07-23
+
+- TAG: [v1.1.0][1.1.0t]
+- COVERAGE: 94.37% -- 2934/3109 lines in 25 files
+- BRANCH COVERAGE: 76.29% -- 1049/1375 branches in 25 files
+- 28.68% documented
+
+### Changed
+
+- `kettle-family state` now includes a `bump` boolean column, documents the
+  boolean release-state columns above the table, and accepts `--only bump` to
+  select members with unreleased changes whose `V.rb` differs from `V.rel`.
+- `--only` release-state filters now accept the short table column names
+  `unrel`, `prep`, and `pend` in addition to `unreleased`, `prepared`, and
+  `pending`.
+- The `kettle-family` executable now supports `-v` / `--version` and prints a
+  standard startup header on normal runs.
+- Template and release workflows now use `tty-progressbar`-backed multi-line
+  member progress in normal TTY output, with kettle-jem NDJSON marks rendered
+  as a fixed-width sliding event tape instead of dots or raw event dumps.
+
 ## [1.0.6] - 2026-07-23
 
 - TAG: [v1.0.6][1.0.6t]
@@ -890,7 +911,9 @@ Please file a bug if you notice a violation of semantic versioning.
 - Fixed CI load failures on engines without compatible `pty` support by falling back to Open3 for interactive release commands.
 - Fixed Ruby 3.2 version-bump support by loading Prism lazily and wiring the Prism gem only for MRI versions that need it.
 
-[Unreleased]: https://github.com/kettle-dev/kettle-family/compare/v1.0.6...HEAD
+[Unreleased]: https://github.com/kettle-dev/kettle-family/compare/v1.1.0...HEAD
+[1.1.0]: https://github.com/kettle-dev/kettle-family/compare/v1.0.6...v1.1.0
+[1.1.0t]: https://github.com/kettle-dev/kettle-family/releases/tag/v1.1.0
 [1.0.6]: https://github.com/kettle-dev/kettle-family/compare/v1.0.5...v1.0.6
 [1.0.6t]: https://github.com/kettle-dev/kettle-family/releases/tag/v1.0.6
 [1.0.5]: https://github.com/kettle-dev/kettle-family/compare/v1.0.4...v1.0.5

data/README.md

@@ -669,7 +669,7 @@ Thanks for RTFM. ☺️
 [📌gitmoji]: https://gitmoji.dev
 [📌gitmoji-img]: https://img.shields.io/badge/gitmoji_commits-%20%F0%9F%98%9C%20%F0%9F%98%8D-34495e.svg?style=flat-square
 [🧮kloc]: https://www.youtube.com/watch?v=dQw4w9WgXcQ
-[🧮kloc-img]: https://img.shields.io/badge/KLOC-2.945-FFDD67.svg?style=for-the-badge&logo=YouTube&logoColor=blue
+[🧮kloc-img]: https://img.shields.io/badge/KLOC-3.109-FFDD67.svg?style=for-the-badge&logo=YouTube&logoColor=blue
 [🔐security]: https://github.com/kettle-dev/kettle-family/blob/main/SECURITY.md
 [🔐security-img]: https://img.shields.io/badge/security-policy-259D6C.svg?style=flat
 [📄copyright-notice-explainer]: https://opensource.stackexchange.com/questions/5778/why-do-licenses-such-as-the-mit-license-specify-a-single-year

data/exe/kettle-family

@@ -1,6 +1,18 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
+script_basename = File.basename(__FILE__)
+repo_lib = File.expand_path("../lib", __dir__)
+$LOAD_PATH.unshift(repo_lib) if File.directory?(repo_lib) && !$LOAD_PATH.include?(repo_lib)
+
+require "kettle/family/version"
+if ARGV.any? { |arg| arg == "-v" || arg == "--version" }
+  puts Kettle::Family::Version::VERSION
+  exit(0)
+end
+
 require "kettle/family"
 
+puts "== #{script_basename} v#{Kettle::Family::Version::VERSION} ==" unless ARGV.include?("--json")
+
 exit(Kettle::Family::CLI.call(ARGV))

data/lib/kettle/family/cli.rb

@@ -37,7 +37,7 @@ module Kettle
 
       module SelectionOptions
         def self.included(base)
-          base.option :only, value: {type: String, usage: "MEMBERS"}, desc: "Select comma-separated members, or release-state tokens: unreleased, prepared, pending"
+          base.option :only, value: {type: String, usage: "MEMBERS"}, desc: "Select comma-separated members, or release-state tokens: unreleased/unrel, prepared/prep, pending/pend, bump"
           base.option :exclude, value: {type: String, usage: "MEMBERS"}, desc: "Exclude comma-separated members"
           base.option :start_at, long: "--start-at", value: {type: String, usage: "MEMBER[@BRANCH]"}, desc: "Select from member through the end of order"
         end

data/lib/kettle/family/release_state_check.rb

@@ -59,6 +59,7 @@ module Kettle
         success = status.success?
         state = success ? JSON.parse(stdout) : {}
         state = branch_filtered_state(member, state, branch) if success && branch
+        state = state_with_computed_booleans(state) if success
         state = enrich_git_state(member.root, state) if success
         result(member: member, command: command, stdout: stdout, stderr: stderr, status: status.exitstatus, elapsed: elapsed, success: success, state: state, branch: branch)
       rescue JSON::ParserError => error
@@ -279,7 +280,7 @@ module Kettle
         unreleased_entries = unreleased_entries?(content)
         prepared_release_pending = !version.to_s.empty? && latest_changelog_version == version
         ahead = commits_ahead_of_release(root, latest_changelog_version)
-        enrich_git_state(root, {
+        state_with_computed_booleans(enrich_git_state(root, {
           "gem_name" => config.family_name,
           "version" => version,
           "latest_released" => nil,
@@ -288,7 +289,17 @@ module Kettle
           "unreleased_entries" => unreleased_entries,
           "prepared_release_pending" => prepared_release_pending,
           "pending_release" => unreleased_entries || prepared_release_pending
-        })
+        }))
+      end
+
+      def state_with_computed_booleans(state)
+        enriched = state.dup
+        enriched["bump_release_pending"] = bump_release_pending?(enriched)
+        enriched
+      end
+
+      def bump_release_pending?(state)
+        state["unreleased_entries"] == true && state["version"].to_s != state["latest_released"].to_s
       end
 
       def root_changelog_version(root)

data/lib/kettle/family/report.rb

@@ -367,6 +367,11 @@ module Kettle
 
       def append_release_state_results(lines)
         lines << "release state:"
+        lines << "  boolean columns:"
+        lines << "    unrel: unreleased changelog entries are present"
+        lines << "    prep: V.ch.md matches V.rb and is ready to publish"
+        lines << "    pend: unrel or prep"
+        lines << "    bump: unrel is yes and V.rb differs from V.rel"
         rows = release_state_header
         results.each do |result|
           rows << release_state_row(result)
@@ -393,7 +398,8 @@ module Kettle
           release_state_ahead_behind(state),
           yes_no(state.fetch("unreleased_entries", nil)),
           yes_no(state.fetch("prepared_release_pending", nil)),
-          yes_no(state.fetch("pending_release", nil))
+          yes_no(state.fetch("pending_release", nil)),
+          yes_no(state.fetch("bump_release_pending", nil))
         ]
         return row unless release_state_has_branches?
 
@@ -401,7 +407,7 @@ module Kettle
       end
 
       def release_state_header
-        header = [["gem", "checkout", "V.rb", "V.rel", "V.ch.md", "🔼 / 🔽", "unrel", "prep", "pend"]]
+        header = [["gem", "checkout", "V.rb", "V.rel", "V.ch.md", "🔼 / 🔽", "unrel", "prep", "pend", "bump"]]
         return header unless release_state_has_branches?
 
         [["branch", *header.first]]

data/lib/kettle/family/selection.rb

@@ -5,8 +5,12 @@ module Kettle
     class Selection
       STATUS_TOKEN_KEYS = {
         "unreleased" => "unreleased_entries",
+        "unrel" => "unreleased_entries",
         "prepared" => "prepared_release_pending",
-        "pending" => "pending_release"
+        "prep" => "prepared_release_pending",
+        "pending" => "pending_release",
+        "pend" => "pending_release",
+        "bump" => "bump_release_pending"
       }.freeze
 
       def self.status_tokens

data/lib/kettle/family/version.rb

@@ -3,7 +3,7 @@
 module Kettle
   module Family
     module Version
-      VERSION = "1.0.6"
+      VERSION = "1.1.0"
     end
     VERSION = Version::VERSION # Traditional Constant Location
   end

data/lib/kettle/family/workflow.rb

@@ -7,6 +7,8 @@ require "etc"
 require "open3"
 require "uri"
 
+require_relative "workflow_progress"
+
 module Kettle
   module Family
     class Workflow
@@ -165,17 +167,16 @@ module Kettle
         ordered_results = Array.new(workflow_members.length)
         mutex = Mutex.new
         stop = false
-        emit_template_progress_start(workflow_members)
+        template_progress = start_template_progress(workflow_members)
         Array.new(template_jobs(workflow_members)) do
           Thread.new do # rubocop:disable ThreadSafety/NewThread -- family templating intentionally runs independent members concurrently.
             loop do
               break if mutex.synchronize { stop }
               index, member = queue.pop(true)
-              member_results = template_results_for_member(member)
+              member_results = template_results_for_member(member, progress: template_progress)
               mutex.synchronize do
                 ordered_results[index] = member_results
                 stop = true unless member_results.all?(&:ok?)
-                emit_template_progress_mark(member_results)
               end
             rescue ThreadError
               break
@@ -183,19 +184,22 @@ module Kettle
           end
         end.each(&:join)
         flattened = ordered_results.compact.flatten
-        emit_template_progress_summary(flattened)
+        emit_template_progress_summary(flattened, progress: template_progress)
         flattened
       end
 
-      def template_results_for_member(member)
+      def template_results_for_member(member, progress: nil)
+        progress&.start_member(member, total: template_phase_total, status: template_initial_status)
         runner = CommandRunner.new(execute: execute, accept: accept)
         [].tap do |memo|
           if config.normalize_lockfiles?
             normalize_lockfiles(member: member, runner: runner, memo: memo, phase: "prepare_lockfiles")
+            emit_member_result_progress(member, memo.last, progress: progress)
             return memo unless memo.last.ok?
           end
 
           prepared = prepare_template_dependencies(member: member, runner: runner, memo: memo)
+          emit_member_result_progress(member, memo.last, progress: progress) if memo.last&.phase == "prepare_template_dependencies"
           return memo if prepared == false
 
           memo << runner.call(
@@ -203,11 +207,22 @@ module Kettle
             phase: command,
             command: workflow_command(member),
             env: workflow_env,
-            stdout_line_handler: template_event_line_handler(member)
+            stdout_line_handler: template_event_line_handler(member, progress: progress)
           )
+          emit_member_result_progress(member, memo.last, progress: progress)
           return memo unless memo.last.ok?
 
           normalize_lockfiles(member: member, runner: runner, memo: memo, phase: "normalize_lockfiles")
+          emit_member_result_progress(member, memo.last, progress: progress)
+        ensure
+          template_result = memo.find { |result| result.phase == "template" } || memo.last
+          if template_result
+            progress&.finish_member(
+              member,
+              success: memo.all?(&:ok?),
+              status: template_member_finish_status(template_result)
+            )
+          end
         end
       end
 
@@ -366,13 +381,20 @@ module Kettle
         return results unless results.all?(&:ok?)
         return parallel_release_member_results(release_members, results) if parallel_release_members?(release_members)
 
-        release_members.each_with_object(results) do |member, memo|
-          memo.concat(release_results_for_member(member, runner: runner))
-          break memo unless memo.last.ok?
+        release_progress = start_release_progress(release_members)
+        @release_progress = release_progress
+        begin
+          release_members.each_with_object(results) do |member, memo|
+            memo.concat(release_results_for_member(member, runner: runner))
+            break memo unless memo.last.ok?
 
-          remaining_members = release_members.drop(release_members.index(member) + 1)
-          append_dependency_floor_results(released_members: [member], dependent_members: remaining_members, runner: runner, memo: memo)
-          break memo unless memo.last&.ok?
+            remaining_members = release_members.drop(release_members.index(member) + 1)
+            append_dependency_floor_results(released_members: [member], dependent_members: remaining_members, runner: runner, memo: memo)
+            break memo unless memo.last&.ok?
+          end
+        ensure
+          emit_release_progress_summary(results, progress: release_progress)
+          @release_progress = nil
         end
       end
 
@@ -380,16 +402,23 @@ module Kettle
         results = initial_results.dup
         waves = release_waves(release_members)
         completed_members = []
-        waves.each_with_index do |wave, index|
-          results << release_wave_result(wave, index: index, total: waves.length)
-          wave_results = run_release_wave(wave)
-          results.concat(wave_results.flatten)
-          break unless wave_results.all? { |member_results| member_results.all?(&:ok?) }
-
-          completed_members.concat(wave)
-          remaining_members = release_members - completed_members
-          append_dependency_floor_results(released_members: wave, dependent_members: remaining_members, runner: release_command_runner, memo: results)
-          break unless results.last&.ok?
+        release_progress = start_release_progress(release_members)
+        @release_progress = release_progress
+        begin
+          waves.each_with_index do |wave, index|
+            results << release_wave_result(wave, index: index, total: waves.length)
+            wave_results = run_release_wave(wave)
+            results.concat(wave_results.flatten)
+            break unless wave_results.all? { |member_results| member_results.all?(&:ok?) }
+
+            completed_members.concat(wave)
+            remaining_members = release_members - completed_members
+            append_dependency_floor_results(released_members: wave, dependent_members: remaining_members, runner: release_command_runner, memo: results)
+            break unless results.last&.ok?
+          end
+        ensure
+          emit_release_progress_summary(results, progress: release_progress)
+          @release_progress = nil
         end
         results
       end
@@ -439,21 +468,27 @@ module Kettle
       end
 
       def release_results_for_member(member, runner:)
+        progress = @release_progress
+        progress&.start_member(member, total: release_phase_total, status: "check")
         [].tap do |memo|
           if skip_already_released?(member)
             memo << already_released_result(member)
+            emit_member_result_progress(member, memo.last, progress: progress)
             return memo
           end
 
           if config.release_normalize_lockfiles?
             normalize_release_lockfiles(member: member, runner: runner, memo: memo)
+            emit_member_result_progress(member, memo.last, progress: progress)
             return memo unless memo.last&.ok?
 
             commit_normalized_lockfiles(branch_members: [member], runner: runner, memo: memo, reason: "release")
+            emit_member_result_progress(member, memo.last, progress: progress)
             return memo unless memo.last&.ok?
           end
 
           append_release_internal_checks(member: member, memo: memo)
+          memo.last(2).each { |result| emit_member_result_progress(member, result, progress: progress) }
           return memo unless memo.last(2).all?(&:ok?)
 
           memo << runner.call(
@@ -463,9 +498,21 @@ module Kettle
             env: release_env,
             interactive: release_command_interactive?
           )
+          emit_member_result_progress(member, memo.last, progress: progress)
           return memo unless memo.last.ok?
 
+          before_git_phase_count = memo.length
           append_release_git_phases(member: member, runner: runner, memo: memo)
+          memo.drop(before_git_phase_count).each { |result| emit_member_result_progress(member, result, progress: progress) }
+        ensure
+          finished_result = memo.find { |result| result.phase == release_phase } || memo.last
+          if finished_result
+            progress&.finish_member(
+              member,
+              success: memo.all?(&:ok?),
+              status: release_member_finish_status(finished_result)
+            )
+          end
         end
       end
 
@@ -1096,30 +1143,103 @@ module Kettle
         append_command_args(command_text, args)
       end
 
-      def emit_template_progress_start(workflow_members)
-        return unless progress_io
+      def start_template_progress(workflow_members)
+        progress = WorkflowProgress.new(
+          io: progress_io,
+          label: "templating",
+          total: workflow_members.length,
+          jobs: template_jobs(workflow_members)
+        )
+        progress.start
+        progress
+      end
+
+      def start_release_progress(release_members)
+        progress = WorkflowProgress.new(
+          io: progress_io,
+          label: release_progress_label,
+          total: release_members.length,
+          jobs: release_jobs(release_members)
+        )
+        progress.start
+        progress
+      end
 
-        progress_io.puts("templating #{workflow_members.length} member#{"s" unless workflow_members.length == 1} with #{template_jobs(workflow_members)} job#{"s" unless template_jobs(workflow_members) == 1}:")
-        progress_io.flush if progress_io.respond_to?(:flush)
+      def template_phase_total
+        config.normalize_lockfiles? ? 4 : 2
       end
 
-      def emit_template_progress_mark(member_results)
-        return unless progress_io
+      def release_phase_total
+        total = 3
+        total += 2 if config.release_normalize_lockfiles?
+        total += 1 if tag
+        total += 1 if push
+        total
+      end
 
-        template_result = member_results.find { |result| result.phase == "template" } || member_results.last
-        progress_io.print(template_result.ok? ? "." : "F")
-        progress_io.flush if progress_io.respond_to?(:flush)
+      def release_progress_label
+        if release_phase == "release_publish"
+          "publishing"
+        else
+          "releasing"
+        end
       end
 
-      def template_event_line_handler(member)
+      def template_initial_status
+        config.normalize_lockfiles? ? "prepare_lockfiles" : "prepare_template_dependencies"
+      end
+
+      def emit_member_result_progress(member, result, progress:)
+        return unless result
+
+        progress&.advance(member, status: result.phase, success: result.ok?, mark: command_result_progress_mark(result))
+      end
+
+      def command_result_progress_mark(result)
+        return "S" if result.skipped
+
+        result.ok? ? "." : "F"
+      end
+
+      def template_member_finish_status(result)
+        changed_files = template_changed_file_count(result)
+        "#{changed_files} file#{"s" unless changed_files == 1} changed"
+      end
+
+      def release_member_finish_status(result)
+        result.skipped ? "skipped #{result.phase}" : result.phase
+      end
+
+      def emit_template_progress_summary(results, progress:)
+        return unless progress
+
+        template_results = results.select { |result| result.phase == "template" }
+        changed_files = template_results.sum { |result| template_changed_file_count(result) }
+        progress.stop
+        progress.summary("template summary: #{template_results.count(&:ok?)}/#{template_results.length} members ok, #{changed_files} file#{"s" unless changed_files == 1} changed")
+      end
+
+      def emit_release_progress_summary(results, progress:)
+        return unless progress
+
+        release_results = results.select { |result| result.phase == release_phase || result.phase == "release_skip" }
+        progress.stop
+        progress.summary("release summary: #{release_results.count(&:ok?)}/#{release_results.length} members ok")
+      end
+
+      def template_event_line_handler(member, progress: nil)
         return nil unless progress_io
-        return nil unless verbose || debug
+        return nil unless verbose || debug || progress&.tty?
 
         lambda do |line|
           event = parse_template_event(line)
           next unless event
 
-          emit_template_event_progress(member, event)
+          if verbose || debug
+            emit_template_event_progress(member, event)
+          else
+            emit_template_event_status(member, event, progress: progress)
+          end
         end
       end
 
@@ -1151,6 +1271,39 @@ module Kettle
         end
       end
 
+      def emit_template_event_status(member, event, progress:)
+        status = case event["type"]
+        when "phase_start", "phase_finish"
+          event["phase"].to_s
+        when "recipe"
+          event["path"].to_s
+        when "post_apply_step", "command_step"
+          [event["phase"], event["name"]].map(&:to_s).reject(&:empty?).join(":")
+        when "diagnostic"
+          message = event["message"].to_s
+          message.empty? ? event["kind"].to_s : message
+        when "summary"
+          "#{event["changed_count"].to_i} file#{"s" unless event["changed_count"].to_i == 1} changed"
+        end
+        mark = template_event_status_mark(event)
+        progress&.update(member, status: status, mark: mark) if status && !status.empty?
+      end
+
+      def template_event_status_mark(event)
+        case event["type"]
+        when "phase_start"
+          ">"
+        when "phase_finish"
+          phase_finish_event_mark(event)
+        when "recipe"
+          template_event_mark(event, changed_mark: "*")
+        when "post_apply_step", "command_step"
+          template_event_mark(event)
+        when "diagnostic"
+          "!"
+        end
+      end
+
       def emit_template_event_line(member, mark, label)
         return if label.to_s.empty?
 
@@ -1178,16 +1331,6 @@ module Kettle
         @template_progress_mutex.synchronize(&block)
       end
 
-      def emit_template_progress_summary(results)
-        return unless progress_io
-
-        template_results = results.select { |result| result.phase == "template" }
-        changed_files = template_results.sum { |result| template_changed_file_count(result) }
-        progress_io.puts
-        progress_io.puts("template summary: #{template_results.count(&:ok?)}/#{template_results.length} members ok, #{changed_files} file#{"s" unless changed_files == 1} changed")
-        progress_io.flush if progress_io.respond_to?(:flush)
-      end
-
       def template_changed_file_count(result)
         event_count = template_changed_file_count_from_events(result.stdout)
         return event_count if event_count

data/lib/kettle/family/workflow_progress.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require "tty-progressbar"
+
+module Kettle
+  module Family
+    class WorkflowProgress
+      FORMAT = "%<member>-24s :events :status"
+      EVENT_WIDTH = 30
+
+      def initialize(io:, label:, total:, jobs:, enabled: true)
+        @io = io
+        @label = label
+        @total = total.to_i
+        @jobs = jobs.to_i
+        @enabled = enabled && !!io
+        @bars = {}
+        @member_totals = {}
+        @member_events = Hash.new("")
+        @mutex = Mutex.new
+        @tty = @enabled && io.respond_to?(:tty?) && io.tty?
+        @multibar = @tty ? TTY::ProgressBar::Multi.new(output: io) : nil
+      end
+
+      def start
+        return unless @enabled
+
+        write_line("#{@label} #{@total} member#{plural(@total)} with #{@jobs} job#{plural(@jobs)}:")
+      end
+
+      def start_member(member, total:, status:)
+        return unless @enabled
+
+        synchronize do
+          @member_totals[member.name] = total.to_i
+          if @tty
+            render(member, status: status)
+          else
+            write_line("[#{member.name}] > #{status}")
+          end
+        end
+      end
+
+      def advance(member, status:, success: true, mark: nil)
+        return unless @enabled
+
+        synchronize do
+          event_mark = mark || (success ? "." : "F")
+          if @tty
+            append_event(member, event_mark)
+            render(member, status: status)
+          else
+            write_line("[#{member.name}] #{event_mark} #{status}")
+          end
+        end
+      end
+
+      def update(member, status:, mark: nil)
+        return unless @enabled
+        return if status.to_s.empty?
+
+        synchronize do
+          if @tty
+            append_event(member, mark) if mark
+            render(member, status: status)
+          else
+            write_line("[#{member.name}] #{mark || ">"} #{status}")
+          end
+        end
+      end
+
+      def finish_member(member, success:, status:)
+        return unless @enabled
+
+        synchronize do
+          if @tty
+            render(member, status: status)
+          else
+            write_line("[#{member.name}] #{success ? "done" : "failed"} #{status}")
+          end
+        end
+      end
+
+      def stop
+        return unless @enabled
+
+        synchronize { @multibar&.stop }
+      end
+
+      def tty?
+        @tty
+      end
+
+      def summary(message)
+        return unless @enabled
+
+        synchronize do
+          @io.puts unless @tty
+          write_line(message)
+        end
+      end
+
+      private
+
+      def render(member, status:)
+        bar_for(member).advance(0, events: event_tape(member), status: status)
+      end
+
+      def append_event(member, mark)
+        return if mark.to_s.empty?
+
+        @member_events[member.name] = (@member_events[member.name] + mark.to_s).chars.last(EVENT_WIDTH).join
+      end
+
+      def event_tape(member)
+        @member_events[member.name].rjust(EVENT_WIDTH)
+      end
+
+      def bar_for(member)
+        @bars[member.name] ||= @multibar.register(Kernel.format(FORMAT, member: member.name), total: nil)
+      end
+
+      def plural(count)
+        "s" unless count == 1
+      end
+
+      def write_line(line)
+        @io.puts(line)
+        @io.flush if @io.respond_to?(:flush)
+      end
+
+      def synchronize(&block)
+        @mutex.synchronize(&block)
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kettle-family
 version: !ruby/object:Gem::Version
-  version: 1.0.6
+  version: 1.1.0
 platform: ruby
 authors:
 - Peter H. Boling
@@ -119,6 +119,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: tty-progressbar
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.18'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.18'
 - !ruby/object:Gem::Dependency
   name: bundler-audit
   requirement: !ruby/object:Gem::Requirement
@@ -298,16 +312,17 @@ files:
 - lib/kettle/family/version_bump.rb
 - lib/kettle/family/version_gem.rb
 - lib/kettle/family/workflow.rb
+- lib/kettle/family/workflow_progress.rb
 - sig/kettle/family.rbs
 homepage: https://github.com/kettle-dev/kettle-family
 licenses:
 - AGPL-3.0-only
 metadata:
   homepage_uri: https://kettle-family.galtzo.com
-  source_code_uri: https://github.com/kettle-dev/kettle-family/tree/v1.0.6
-  changelog_uri: https://github.com/kettle-dev/kettle-family/blob/v1.0.6/CHANGELOG.md
+  source_code_uri: https://github.com/kettle-dev/kettle-family/tree/v1.1.0
+  changelog_uri: https://github.com/kettle-dev/kettle-family/blob/v1.1.0/CHANGELOG.md
   bug_tracker_uri: https://github.com/kettle-dev/kettle-family/issues
-  documentation_uri: https://www.rubydoc.info/gems/kettle-family/1.0.6
+  documentation_uri: https://www.rubydoc.info/gems/kettle-family/1.1.0
   funding_uri: https://github.com/sponsors/pboling
   wiki_uri: https://github.com/kettle-dev/kettle-family/wiki
   news_uri: https://www.railsbling.com/tags/kettle-family