kettle-family 0.1.19 → 0.1.20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1ffac198401618fcc4e988b09d48941a187bf809f3b0baf7b6261247fa81d8e3
-  data.tar.gz: 1a139626c8c632ceca9f738678593b0103810f6bf884a9a98a29d1ab8c197edf
+  metadata.gz: 8674366c5bb5bff14156cae0e04c58805e3401510d4f6efe865902fe2facf988
+  data.tar.gz: b4a1ae4344a06bffc03b8fee3e472bc2f9cd40c7caa3276e30598da9307ba546
 SHA512:
-  metadata.gz: cd5ba9086f00e699c138787ffc5c5e8140616238e18713f79a58ae8e215ff4adb2630a356e42476c9314f2324d7027e7f489169882f0359694dc8e7379251687
-  data.tar.gz: 28ddd6e49f16293a5469dcceb271238077fcb140a85542ae6288f5d5a6072e905677e733a25d6388f3b3aff4ba2bc4ac14ae34a121fe8435972ec9ee98cb18e5
+  metadata.gz: 718d504c273ced46600feb4f196db9d13301026f74f96288eaaab960ad0765dba6067944e65f2e9855ba70b4e59e52d33609fce7b3760cc5d752303191184cd2
+  data.tar.gz: 5f1648deea0b3e04ca0edb2a453bb5d919a0e7cd1dcc19562b1ec77d15fa1c5870fd03d7b69f328fb04fec3ff70686e23d2fcaff8d1c083c941d36ece6dd28d8

data/CHANGELOG.md

@@ -30,6 +30,37 @@ Please file a bug if you notice a violation of semantic versioning.
 
 ### Security
 
+## [0.1.20] - 2026-06-26
+
+- TAG: [v0.1.20][0.1.20t]
+- COVERAGE: 94.99% -- 1802/1897 lines in 21 files
+- BRANCH COVERAGE: 74.39% -- 613/824 branches in 21 files
+- 38.60% documented
+
+### Added
+
+- `kettle-family template --execute` now runs member templating in parallel by
+  default, with `--jobs` and `template.jobs` controls plus compact live progress
+  and changed-file summaries.
+- `kettle-family release --execute` now runs dependency-safe member release
+  waves in parallel for distinct Git worktrees, coordinating concurrent
+  RubyGems MFA prompts.
+- `kettle-family install --execute` now installs independent local gems in
+  dependency-safe waves, using `--jobs` for parallelism.
+
+### Changed
+
+- Family templating now invokes `kettle-jem` in quiet JSON mode and suppresses
+  noisy Bundler/debug environment by default, overriding inherited debug
+  variables unless `--debug` is passed.
+
+### Fixed
+
+- Parallel release MFA coordination now shares an entered OTP only with prompts
+  already queued at submission time, shows the live queued prompt count as
+  `N / Y` for the current release wave capacity, and asks again for later
+  RubyGems OTP prompts.
+
 ## [0.1.19] - 2026-06-25
 
 - TAG: [v0.1.19][0.1.19t]
@@ -351,7 +382,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/v0.1.19...HEAD
+[Unreleased]: https://github.com/kettle-dev/kettle-family/compare/v0.1.20...HEAD
+[0.1.20]: https://github.com/kettle-dev/kettle-family/compare/v0.1.19...v0.1.20
+[0.1.20t]: https://github.com/kettle-dev/kettle-family/releases/tag/v0.1.20
 [0.1.19]: https://github.com/kettle-dev/kettle-family/compare/v0.1.18...v0.1.19
 [0.1.19t]: https://github.com/kettle-dev/kettle-family/releases/tag/v0.1.19
 [0.1.18]: https://github.com/kettle-dev/kettle-family/compare/v0.1.17...v0.1.18

data/CONTRIBUTING.md

@@ -131,9 +131,12 @@ toolchain, and it may be higher than the gemspec runtime floor.
 They are created and updated with the commands:
 
 ```console
-bin/rake appraisal:update
+bin/rake appraisal:generate
 ```
 
+Use `bin/rake appraisal:update` when you intentionally need to resolve fresh
+appraisal locks.
+
 If you need to reset all gemfiles/*.gemfile.lock files:
 
 ```console

data/README.md

@@ -571,7 +571,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-1.616-FFDD67.svg?style=for-the-badge&logo=YouTube&logoColor=blue
+[🧮kloc-img]: https://img.shields.io/badge/KLOC-1.897-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/lib/kettle/family/cli.rb

@@ -81,6 +81,8 @@ module Kettle
               --report PATH    Write JSON report to PATH
               --execute        Execute external workflow commands
               --dry-run        Plan external workflow commands without running them (default)
+              --debug          Preserve debug environment for workflow commands
+              --jobs N         Parallel jobs for executed family templating, release, or install
               --env KEY=VALUE  Override an environment variable for each member workflow command
               --section NAME   Changelog section for add-changelog
               --entry TEXT     Changelog entry for add-changelog
@@ -114,6 +116,8 @@ module Kettle
           json: false,
           report: nil,
           execute: false,
+          debug: false,
+          jobs: nil,
           workflow_env: {},
           changelog_section: nil,
           changelog_entry: nil,
@@ -139,6 +143,8 @@ module Kettle
           parser.on("--report PATH") { |value| options[:report] = value }
           parser.on("--execute") { options[:execute] = true }
           parser.on("--dry-run") { options[:execute] = false }
+          parser.on("--debug") { options[:debug] = true }
+          parser.on("--jobs N", Integer) { |value| options[:jobs] = value }
           parser.on("--env KEY=VALUE") { |value| parse_env_override(value, options[:workflow_env]) }
           parser.on("--section NAME") { |value| options[:changelog_section] = value }
           parser.on("--entry TEXT") { |value| options[:changelog_entry] = value }
@@ -228,10 +234,21 @@ module Kettle
           continue_ci_failures: options[:release_continue_ci_failures],
           gha_sha_pins_upgrade: options[:gha_sha_pins_upgrade],
           gha_sha_pins_check: options[:check],
-          env_overrides: options[:workflow_env]
+          env_overrides: options[:workflow_env],
+          debug: options[:debug],
+          jobs: options[:jobs],
+          progress_io: progress_io(command, options)
         ).results
       end
 
+      def progress_io(command, options)
+        return nil unless command == "template"
+        return nil unless options[:execute]
+        return nil if options[:json]
+
+        out
+      end
+
       def branch_target_command?(command, config)
         return false if config.release_target_branches.empty?
         return false if command == "release-state"
@@ -401,7 +418,7 @@ module Kettle
       end
 
       def install_results(config:, members:, options:)
-        LocalInstall.new(config: config, members: members, execute: options[:execute]).results
+        LocalInstall.new(config: config, members: members, execute: options[:execute], jobs: options[:jobs]).results
       end
 
       def release_state_results(config:, members:)

data/lib/kettle/family/command_runner.rb

@@ -1,14 +1,114 @@
 # frozen_string_literal: true
 
 require "open3"
+require "io/console"
 
 module Kettle
   module Family
     class CommandRunner
-      def initialize(execute: false, accept: true, gem_signing_password: nil)
+      class OtpCoordinator
+        def initialize(input: $stdin, output: $stdout, queue_total: nil)
+          @input = input
+          @output = output
+          @mutex = Mutex.new
+          @condition = ConditionVariable.new
+          @prompting = false
+          @queue_closed = false
+          @generation = 0
+          @completed_generation = nil
+          @response = nil
+          @queued_count = 0
+          @queue_total = queue_total
+        end
+
+        def queue_total=(value)
+          @mutex.synchronize do
+            @queue_total = value
+          end
+        end
+
+        def request(member_name:, chunk:)
+          generation = nil
+          @mutex.synchronize do
+            @condition.wait(@mutex) while @prompting && @queue_closed
+
+            if @prompting
+              generation = @generation
+              @queued_count += 1
+              render_queue_status_locked
+              return wait_for_response(generation)
+            end
+
+            @prompting = true
+            @queue_closed = false
+            @queued_count = 1
+            @generation += 1
+            generation = @generation
+            start_prompt_locked(member_name: member_name)
+          end
+
+          response = read_response(chunk: chunk)
+          close_queue
+          @mutex.synchronize do
+            @response = response
+            @completed_generation = generation
+            @prompting = false
+            @queue_closed = false
+            @condition.broadcast
+            response
+          end
+        end
+
+        private
+
+        def wait_for_response(generation)
+          @condition.wait(@mutex) while @prompting
+          return @response if @completed_generation == generation
+
+          ""
+        end
+
+        def close_queue
+          @mutex.synchronize do
+            @queue_closed = true
+          end
+        end
+
+        def start_prompt_locked(member_name:)
+          @output.puts
+          @output.puts("[#{member_name}] RubyGems MFA requested.")
+          render_queue_status_locked
+          @output.puts("Queued prompts at entry will share this code; later prompts will ask again.")
+        end
+
+        def render_queue_status_locked
+          suffix = @queue_total ? " / #{@queue_total}" : ""
+          @output.puts("RubyGems MFA prompts queued: #{@queued_count}#{suffix}")
+          @output.flush if @output.respond_to?(:flush)
+        end
+
+        def read_response(chunk:)
+          @output.print("#{otp_prompt_label(chunk)} ")
+          @output.flush if @output.respond_to?(:flush)
+          if @input.respond_to?(:noecho) && @input.tty?
+            @input.noecho(&:gets)&.chomp.to_s
+          else
+            @input.gets&.chomp.to_s
+          end
+        ensure
+          @output.puts if @output.respond_to?(:puts)
+        end
+
+        def otp_prompt_label(chunk)
+          chunk.to_s.lines.last&.strip.to_s.empty? ? "Code:" : chunk.to_s.lines.last.strip
+        end
+      end
+
+      def initialize(execute: false, accept: true, gem_signing_password: nil, otp_coordinator: nil)
         @execute = execute
         @accept = accept
         @gem_signing_password = gem_signing_password
+        @otp_coordinator = otp_coordinator
       end
 
       def call(member:, phase:, command:, env: {}, interactive: false)
@@ -19,7 +119,7 @@ module Kettle
         started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
         stdout, stderr, status = with_unbundled_environment do
           if interactive
-            run_interactive(env: process_env, argv: argv, chdir: member.root)
+            run_interactive(env: process_env, argv: argv, chdir: member.root, member_name: member.name)
           else
             Open3.capture3(process_env, *argv, chdir: member.root)
           end
@@ -44,29 +144,29 @@ module Kettle
 
       private
 
-      attr_reader :execute, :accept, :gem_signing_password
+      attr_reader :execute, :accept, :gem_signing_password, :otp_coordinator
 
-      def run_interactive(env:, argv:, chdir:)
-        return run_interactive_pty(env: env, argv: argv, chdir: chdir) if pty_available?
+      def run_interactive(env:, argv:, chdir:, member_name:)
+        return run_interactive_pty(env: env, argv: argv, chdir: chdir, member_name: member_name) if pty_available?
 
-        run_interactive_open3(env: env, argv: argv, chdir: chdir)
+        run_interactive_open3(env: env, argv: argv, chdir: chdir, member_name: member_name)
       end
 
-      def run_interactive_pty(env:, argv:, chdir:)
+      def run_interactive_pty(env:, argv:, chdir:, member_name:)
         stdout = +""
         status = nil
         PTY.spawn(env, *argv, chdir: chdir) do |output, input, pid|
           begin
             loop do
               readers = [output]
-              readers << $stdin if $stdin.tty?
+              readers << $stdin if $stdin.tty? && !otp_coordinator
               ready = IO.select(readers)
               ready.first.each do |reader|
                 if reader.equal?(output)
                   chunk = output.readpartial(1024)
                   stdout << chunk
                   $stdout.print(chunk)
-                  handle_interactive_prompt(input, chunk)
+                  handle_interactive_prompt(input, chunk, member_name: member_name)
                 else
                   input.write($stdin.readpartial(1024))
                 end
@@ -80,20 +180,20 @@ module Kettle
         [stdout, "", status]
       end
 
-      def run_interactive_open3(env:, argv:, chdir:)
+      def run_interactive_open3(env:, argv:, chdir:, member_name:)
         captured_stdout = +""
         captured_stderr = +""
         status = nil
         Open3.popen3(env, *argv, chdir: chdir) do |input, output, error, wait_thread|
           readers = [output, error]
-          readers << $stdin if $stdin.tty?
+          readers << $stdin if $stdin.tty? && !otp_coordinator
           until readers.empty?
             ready = IO.select(readers)
             ready.first.each do |reader|
               if reader.equal?($stdin)
                 input.write($stdin.readpartial(1024))
               else
-                read_interactive_stream(reader, output, input, captured_stdout, captured_stderr, readers)
+                read_interactive_stream(reader, output, input, captured_stdout, captured_stderr, readers, member_name: member_name)
               end
             end
           end
@@ -102,7 +202,7 @@ module Kettle
         [captured_stdout, captured_stderr, status]
       end
 
-      def read_interactive_stream(reader, output, input, captured_stdout, captured_stderr, readers)
+      def read_interactive_stream(reader, output, input, captured_stdout, captured_stderr, readers, member_name:)
         chunk = reader.readpartial(1024)
         if reader.equal?(output)
           captured_stdout << chunk
@@ -111,7 +211,7 @@ module Kettle
           captured_stderr << chunk
           $stderr.print(chunk)
         end
-        handle_interactive_prompt(input, chunk)
+        handle_interactive_prompt(input, chunk, member_name: member_name)
       rescue EOFError
         readers.delete(reader)
       end
@@ -132,8 +232,11 @@ module Kettle
         input.flush
       end
 
-      def handle_interactive_prompt(input, chunk)
-        return if otp_prompt?(chunk)
+      def handle_interactive_prompt(input, chunk, member_name: nil)
+        if otp_prompt?(chunk)
+          write_otp_response(input, chunk, member_name: member_name) if otp_coordinator && otp_response_prompt?(chunk)
+          return
+        end
 
         if accept_confirmation_prompt?(chunk)
           write_accept_response(input) if accept
@@ -148,6 +251,14 @@ module Kettle
         input.flush
       end
 
+      def write_otp_response(input, chunk, member_name:)
+        response = otp_coordinator.request(member_name: member_name || "release", chunk: chunk)
+        return if response.to_s.empty?
+
+        input.write("#{response}\n")
+        input.flush
+      end
+
       def accept_confirmation_prompt?(chunk)
         chunk.match?(/\[[Yy]\/[Nn]\]\s*:?/)
       end
@@ -156,6 +267,10 @@ module Kettle
         chunk.match?(/(?:multi-factor authentication|OTP code|one-time password|\bCode:\s*)/i)
       end
 
+      def otp_response_prompt?(chunk)
+        chunk.match?(/(?:OTP code|one-time password|\bCode:\s*)/i)
+      end
+
       def signing_password_prompt?(chunk)
         chunk.match?(/(?:enter\s+)?(?:PEM\s+)?pass(?:\s|-)?phrase\s*(?:for\s+[^:]+)?[:?]\s*\z/i) ||
           chunk.match?(/(?:PEM|private key) password\s*[:?]\s*\z/i)

data/lib/kettle/family/config.rb

@@ -160,6 +160,10 @@ module Kettle
         fetch_path("template", "repository_topology")
       end
 
+      def template_jobs
+        fetch_path("template", "jobs")
+      end
+
       def normalize_lockfiles?
         fetch_path("template", "normalize_lockfiles") == true
       end
@@ -204,6 +208,10 @@ module Kettle
         stringify_env(fetch_path("release", "env") || {})
       end
 
+      def release_jobs
+        fetch_path("release", "jobs")
+      end
+
       def release_family_changelog?
         fetch_path("release", "family_changelog", "enabled") == true
       end

data/lib/kettle/family/local_install.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "etc"
 require "fileutils"
 require "json"
 require "open3"
@@ -8,16 +9,18 @@ require "time"
 module Kettle
   module Family
     class LocalInstall
-      def initialize(config:, members:, execute: false)
+      def initialize(config:, members:, execute: false, jobs: nil)
         @config = config
         @members = members
         @execute = execute
+        @jobs = jobs
       end
 
       def results
-        results = install_members.each_with_object([]) do |member, memo|
-          memo << install_member(member)
-          break memo unless memo.last.ok?
+        results = if execute && install_jobs(install_members) > 1
+          parallel_install_results
+        else
+          sequential_install_results(install_members)
         end
         write_local_install_marker if execute && results.all?(&:ok?)
         results
@@ -25,11 +28,26 @@ module Kettle
 
       private
 
-      attr_reader :config, :members, :execute
+      attr_reader :config, :members, :execute, :jobs
 
       def install_members
+        @install_members ||= unique_members(local_dependency_members + members)
+      end
+
+      def local_dependency_members
+        @local_dependency_members ||= unique_members(
+          config.install_local_dependencies.map { |path| member_from_path(path) }
+        )
+      end
+
+      def selected_install_members
+        local_dependency_names = local_dependency_members.map(&:name)
+        unique_members(members).reject { |member| local_dependency_names.include?(member.name) }
+      end
+
+      def unique_members(candidate_members)
         seen = {}
-        (local_dependency_members + members).each_with_object([]) do |member, memo|
+        candidate_members.each_with_object([]) do |member, memo|
           next if seen.key?(member.name)
 
           seen[member.name] = true
@@ -37,8 +55,66 @@ module Kettle
         end
       end
 
-      def local_dependency_members
-        config.install_local_dependencies.map { |path| member_from_path(path) }
+      def sequential_install_results(candidate_members)
+        candidate_members.each_with_object([]) do |member, memo|
+          memo << install_member(member)
+          break memo unless memo.last.ok?
+        end
+      end
+
+      def parallel_install_results
+        [local_dependency_members, selected_install_members].each_with_object([]) do |group, memo|
+          dependency_waves(group).each do |wave|
+            wave_results = run_install_wave(wave)
+            memo.concat(wave_results)
+            break unless wave_results.all?(&:ok?)
+          end
+          break memo unless memo.all?(&:ok?)
+        end
+      end
+
+      def run_install_wave(wave)
+        queue = Queue.new
+        wave.each_with_index { |member, index| queue << [index, member] }
+        ordered_results = Array.new(wave.length)
+        Array.new(install_jobs(wave)) do
+          Thread.new do
+            loop do
+              index, member = queue.pop(true)
+              ordered_results[index] = install_member(member)
+            rescue ThreadError
+              break
+            end
+          end
+        end.each(&:join)
+        ordered_results.compact
+      end
+
+      def dependency_waves(candidate_members)
+        by_name = candidate_members.to_h { |member| [member.name, member] }
+        pending = by_name.keys
+        completed = []
+        waves = []
+        until pending.empty?
+          wave_names = pending.select do |name|
+            selected_dependencies_for(by_name.fetch(name), by_name).all? { |dependency| completed.include?(dependency) }
+          end
+          raise Error, "cyclic install dependency order: #{pending.join(", ")}" if wave_names.empty?
+
+          waves << wave_names.map { |name| by_name.fetch(name) }
+          completed.concat(wave_names)
+          pending -= wave_names
+        end
+        waves
+      end
+
+      def selected_dependencies_for(member, by_name)
+        Array(member.dependencies).map(&:to_s).select { |dependency| by_name.key?(dependency) }
+      end
+
+      def install_jobs(candidate_members)
+        count = jobs ? jobs.to_i : [Etc.nprocessors, 4].min
+        [[count, 1].max, candidate_members.length].min
       end
 
       def member_from_path(path)

data/lib/kettle/family/report.rb

@@ -77,16 +77,41 @@ module Kettle
         lines << "results:"
         results.each do |result|
           lines << "  #{result_state(result)} #{result.member_name} #{result.phase} #{result.reason || ""}".rstrip
-          append_indented_output(lines, result.stdout) unless result.stdout.to_s.empty?
+          append_indented_output(lines, result.stdout) unless suppress_success_output?(result)
           append_indented_output(lines, result.stderr) if !result.ok? && !result.stderr.to_s.empty?
           lines << "    resume: #{resume_hint_for(result)}" unless result.ok?
         end
+        append_template_summary(lines) if command == "template"
       end
 
       def append_indented_output(lines, output)
         output.to_s.each_line(chomp: true) { |line| lines << "    #{line}" }
       end
 
+      def suppress_success_output?(result)
+        result.stdout.to_s.empty? || (command == "template" && result.ok?)
+      end
+
+      def append_template_summary(lines)
+        template_results = results.select { |result| result.phase == "template" }
+        return if template_results.empty?
+
+        changed_files = template_results.sum { |result| template_changed_file_count(result) }
+        lines << "template summary:"
+        lines << "  #{template_results.count(&:ok?)}/#{template_results.length} members ok"
+        lines << "  #{changed_files} file#{"s" unless changed_files == 1} changed"
+      end
+
+      def template_changed_file_count(result)
+        payload = JSON.parse(result.stdout.to_s)
+        Array(payload["changed_files"] || payload[:changed_files]).length if payload.is_a?(Hash)
+      rescue JSON::ParserError
+        match = result.stdout.to_s.match(/(?:install|apply|prepare|template):\s+(\d+)\s+changed file/)
+        return match[1].to_i if match
+
+        0
+      end
+
       def append_member_release_targets(lines)
         return if member_release_target_branches.empty?
 

data/lib/kettle/family/version.rb

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

data/lib/kettle/family/workflow.rb

@@ -3,6 +3,8 @@
 require "io/console"
 require "json"
 require "net/http"
+require "etc"
+require "open3"
 require "uri"
 
 module Kettle
@@ -20,8 +22,23 @@ module Kettle
         "pull" => [["pull", %w[git pull --rebase]]],
         "up" => [["pull", %w[git pull --rebase]], ["push", %w[git push]]]
       }.freeze
+      TEMPLATE_QUIET_ENV = {
+        "KETTLE_JEM_QUIET" => "true",
+        "KETTLE_JEM_DEBUG" => "false",
+        "KETTLE_DEV_DEBUG" => "false",
+        "SMORG_RB_DEBUG" => "false",
+        "DEBUG" => "false",
+        "BUNDLE_QUIET" => "true",
+        "BUNDLE_DEBUG" => "false",
+        "BUNDLER_DEBUG" => "false",
+        "BUNDLE_VERBOSE" => "false",
+        "DEBUG_RESOLVER" => "false",
+        "BUNDLE_SILENCE_DEPRECATIONS" => "true",
+        "BUNDLE_SILENCE_ROOT_WARNING" => "true",
+        "BUNDLE_SUPPRESS_INSTALL_USING_MESSAGES" => "true"
+      }.freeze
 
-      def initialize(command:, config:, members:, execute: false, accept: true, commit: true, allow_dirty: false, publish: false, push: false, tag: false, start_step: nil, local_ci: false, continue_ci_failures: false, gha_sha_pins_upgrade: "patch", gha_sha_pins_check: false, env_overrides: {}, gem_signing_password: nil)
+      def initialize(command:, config:, members:, execute: false, accept: true, commit: true, allow_dirty: false, publish: false, push: false, tag: false, start_step: nil, local_ci: false, continue_ci_failures: false, gha_sha_pins_upgrade: "patch", gha_sha_pins_check: false, env_overrides: {}, debug: false, gem_signing_password: nil, jobs: nil, progress_io: nil)
         @command = command
         @config = config
         @members = members
@@ -38,7 +55,10 @@ module Kettle
         @gha_sha_pins_upgrade = gha_sha_pins_upgrade
         @gha_sha_pins_check = gha_sha_pins_check
         @env_overrides = env_overrides
+        @debug = debug
         @gem_signing_password = gem_signing_password
+        @jobs = jobs
+        @progress_io = progress_io
       end
 
       def results
@@ -51,7 +71,7 @@ module Kettle
 
       private
 
-      attr_reader :command, :config, :members, :execute, :accept, :commit, :allow_dirty, :publish, :push, :tag, :start_step, :local_ci, :continue_ci_failures, :gha_sha_pins_upgrade, :gha_sha_pins_check, :env_overrides
+      attr_reader :command, :config, :members, :execute, :accept, :commit, :allow_dirty, :publish, :push, :tag, :start_step, :local_ci, :continue_ci_failures, :gha_sha_pins_upgrade, :gha_sha_pins_check, :env_overrides, :debug, :jobs, :progress_io
 
       def current_branch_results(workflow_members)
         return check_results(workflow_members) if command == "check"
@@ -62,6 +82,8 @@ module Kettle
       end
 
       def member_workflow_results(workflow_members)
+        return template_member_workflow_results(workflow_members) if command == "template" && execute && template_jobs(workflow_members) > 1
+
         runner = CommandRunner.new(execute: execute, accept: accept)
         workflow_members.each_with_object([]) do |member, memo|
           if command == "template" && config.normalize_lockfiles?
@@ -79,6 +101,55 @@ module Kettle
         end
       end
 
+      def template_member_workflow_results(workflow_members)
+        queue = Queue.new
+        workflow_members.each_with_index { |member, index| queue << [index, member] }
+        ordered_results = Array.new(workflow_members.length)
+        mutex = Mutex.new
+        stop = false
+        emit_template_progress_start(workflow_members)
+        Array.new(template_jobs(workflow_members)) do
+          Thread.new do
+            loop do
+              break if mutex.synchronize { stop }
+              index, member = queue.pop(true)
+              member_results = template_results_for_member(member)
+              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
+            end
+          end
+        end.each(&:join)
+        flattened = ordered_results.compact.flatten
+        emit_template_progress_summary(flattened)
+        flattened
+      end
+
+      def template_results_for_member(member)
+        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")
+            return memo unless memo.last.ok?
+          end
+
+          memo << runner.call(member: member, phase: command, command: workflow_command(member), env: workflow_env)
+          return memo unless memo.last.ok?
+
+          normalize_lockfiles(member: member, runner: runner, memo: memo, phase: "normalize_lockfiles")
+        end
+      end
+
+      def template_jobs(workflow_members)
+        requested = jobs || config.template_jobs
+        count = requested ? requested.to_i : [Etc.nprocessors, 4].min
+        [[count, 1].max, workflow_members.length].min
+      end
+
       def check_results(workflow_members)
         results = []
         results.concat(BranchLaneAudit.new(config: config, members: workflow_members).results) unless config.branch_lanes.empty?
@@ -152,32 +223,72 @@ module Kettle
           gha_sha_pins_upgrade: gha_sha_pins_upgrade,
           gha_sha_pins_check: gha_sha_pins_check,
           env_overrides: env_overrides,
-          gem_signing_password: @gem_signing_password
+          gem_signing_password: @gem_signing_password,
+          jobs: jobs,
+          progress_io: progress_io
         )
       end
 
       def release_member_results(release_members, include_family_changelog: false)
-        runner = command_runner
+        runner = release_command_runner
         results = []
         append_family_changelog_result(runner: runner, memo: results) if include_family_changelog
         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?
+        end
+      end
+
+      def parallel_release_member_results(release_members, initial_results)
+        results = initial_results.dup
+        release_waves(release_members).each do |wave|
+          wave_results = run_release_wave(wave)
+          results.concat(wave_results.flatten)
+          break unless wave_results.all? { |member_results| member_results.all?(&:ok?) }
+        end
+        results
+      end
+
+      def run_release_wave(wave)
+        queue = Queue.new
+        wave.each_with_index { |member, index| queue << [index, member] }
+        ordered_results = Array.new(wave.length)
+        wave_jobs = release_jobs(wave)
+        release_otp_coordinator&.queue_total = wave_jobs
+        Array.new(wave_jobs) do
+          Thread.new do
+            runner = release_command_runner
+            loop do
+              index, member = queue.pop(true)
+              ordered_results[index] = release_results_for_member(member, runner: runner)
+            rescue ThreadError
+              break
+            end
+          end
+        end.each(&:join)
+        ordered_results.compact
+      end
+
+      def release_results_for_member(member, runner:)
+        [].tap do |memo|
           if skip_already_released?(member)
             memo << already_released_result(member)
-            next
+            return memo
           end
 
           if config.release_normalize_lockfiles?
             normalize_release_lockfiles(member: member, runner: runner, memo: memo)
-            break memo unless memo.last&.ok?
+            return memo unless memo.last&.ok?
 
             commit_normalized_lockfiles(branch_members: [member], runner: runner, memo: memo, reason: "release")
-            break memo unless memo.last&.ok?
+            return memo unless memo.last&.ok?
           end
 
           append_release_internal_checks(member: member, memo: memo)
-          break memo unless memo.last(2).all?(&:ok?)
+          return memo unless memo.last(2).all?(&:ok?)
 
           memo << runner.call(
             member: member,
@@ -186,10 +297,9 @@ module Kettle
             env: release_env,
             interactive: release_command_interactive?
           )
-          break memo unless memo.last.ok?
+          return memo unless memo.last.ok?
 
           append_release_git_phases(member: member, runner: runner, memo: memo)
-          break memo unless memo.last.ok?
         end
       end
 
@@ -208,6 +318,66 @@ module Kettle
         CommandRunner.new(execute: execute, accept: accept, gem_signing_password: @gem_signing_password)
       end
 
+      def release_command_runner
+        CommandRunner.new(
+          execute: execute,
+          accept: accept,
+          gem_signing_password: @gem_signing_password,
+          otp_coordinator: release_otp_coordinator
+        )
+      end
+
+      def release_otp_coordinator
+        return nil unless execute && release_command_interactive?
+
+        @release_otp_coordinator ||= CommandRunner::OtpCoordinator.new
+      end
+
+      def parallel_release_members?(release_members)
+        execute &&
+          release_jobs(release_members) > 1 &&
+          release_members.length > 1 &&
+          distinct_git_roots?(release_members)
+      end
+
+      def release_jobs(release_members)
+        requested = jobs || config.release_jobs
+        count = requested ? requested.to_i : [Etc.nprocessors, 4].min
+        [[count, 1].max, release_members.length].min
+      end
+
+      def release_waves(release_members)
+        by_name = release_members.to_h { |member| [member.name, member] }
+        pending = by_name.keys
+        completed = []
+        waves = []
+        until pending.empty?
+          wave_names = pending.select do |name|
+            selected_dependencies_for(by_name.fetch(name), by_name).all? { |dependency| completed.include?(dependency) }
+          end
+          raise Error, "cyclic release dependency order: #{pending.join(", ")}" if wave_names.empty?
+
+          waves << wave_names.map { |name| by_name.fetch(name) }
+          completed.concat(wave_names)
+          pending -= wave_names
+        end
+        waves
+      end
+
+      def selected_dependencies_for(member, by_name)
+        Array(member.dependencies).map(&:to_s).select { |dependency| by_name.key?(dependency) }
+      end
+
+      def distinct_git_roots?(release_members)
+        roots = release_members.map { |member| git_root_for(member) }
+        roots.uniq.length == roots.length
+      end
+
+      def git_root_for(member)
+        stdout, _stderr, status = Open3.capture3("git", "rev-parse", "--show-toplevel", chdir: member.root)
+        status.success? ? stdout.strip : File.expand_path(member.root)
+      end
+
       def rediscovered_selected_members(selected_names)
         discovered = Discovery.new(config: config).members
         ordered = Orderer.new(members: discovered, mode: config.order_mode, hints: config.order_hints).ordered
@@ -394,6 +564,7 @@ module Kettle
 
       def template_command(member)
         command_text = config.template_command || default_template_command(member)
+        command_text = append_template_family_args(command_text) if kettle_jem_template_command?(command_text)
         return command_text if commit
         return command_text if command_text.is_a?(Array) && command_text.include?("--skip-commit")
         return [*command_text, "--skip-commit"] if command_text.is_a?(Array)
@@ -423,9 +594,56 @@ module Kettle
             env["KJ_REPOSITORY_TOPOLOGY"] = config.template_repository_topology if config.template_repository_topology
           end
           env.merge!(env_overrides)
+          env.merge!(TEMPLATE_QUIET_ENV) if command == "template" && !debug
         end
       end
 
+      def kettle_jem_template_command?(command_text)
+        command_text.is_a?(Array) ? command_text.map(&:to_s).include?("kettle-jem") : command_text.to_s.include?("kettle-jem")
+      end
+
+      def append_template_family_args(command_text)
+        args = []
+        args << "--quiet" unless command_includes_arg?(command_text, "--quiet")
+        args << "--json" unless command_includes_arg?(command_text, "--json")
+        append_command_args(command_text, args)
+      end
+
+      def emit_template_progress_start(workflow_members)
+        return unless progress_io
+
+        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)
+      end
+
+      def emit_template_progress_mark(member_results)
+        return unless progress_io
+
+        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)
+      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)
+        payload = JSON.parse(result.stdout.to_s)
+        Array(payload["changed_files"] || payload[:changed_files]).length if payload.is_a?(Hash)
+      rescue JSON::ParserError
+        match = result.stdout.to_s.match(/(?:install|apply|prepare|template):\s+(\d+)\s+changed file/)
+        return match[1].to_i if match
+
+        0
+      end
+
       def normalize_lockfiles(member:, runner:, memo:, phase:)
         return unless config.normalize_lockfiles?
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kettle-family
 version: !ruby/object:Gem::Version
-  version: 0.1.19
+  version: 0.1.20
 platform: ruby
 authors:
 - Peter H. Boling
@@ -310,10 +310,10 @@ licenses:
 - AGPL-3.0-only
 metadata:
   homepage_uri: https://kettle-family.galtzo.com
-  source_code_uri: https://github.com/kettle-dev/kettle-family/tree/v0.1.19
-  changelog_uri: https://github.com/kettle-dev/kettle-family/blob/v0.1.19/CHANGELOG.md
+  source_code_uri: https://github.com/kettle-dev/kettle-family/tree/v0.1.20
+  changelog_uri: https://github.com/kettle-dev/kettle-family/blob/v0.1.20/CHANGELOG.md
   bug_tracker_uri: https://github.com/kettle-dev/kettle-family/issues
-  documentation_uri: https://www.rubydoc.info/gems/kettle-family/0.1.19
+  documentation_uri: https://www.rubydoc.info/gems/kettle-family/0.1.20
   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