kettle-family 1.2.90 → 1.2.92

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fd4de333d6aa3b2bc027ec582b2bcc0b890d61b20a0a57c70bcf25196b2f9c32
-  data.tar.gz: 67754f998efad13f47f00f0e07222a17e9413c890b2cee1097ffbccd1114801d
+  metadata.gz: c1646ca3577c370624800077609c69c0decd4a50ad6924e82cfe3c050c1757df
+  data.tar.gz: 361e0ac1cd39a97b442d3296635055b5bd34c24ced7d3944cec4a0984df6babb
 SHA512:
-  metadata.gz: 7238680a28fa74944856d3ebe514193ac070df02fa25b319e28090bbb18f8f6a0f989ccf0d73e84f485d5e7d446de692440304dd0e99cf79b9834f4ba1212143
-  data.tar.gz: 75c99992e6539a9aa9e37f6ad5ea45afa0692bd9214f10df75f9c604f56af1799099e4cb1fa80b47bd9e843fa8a130103dffae010b14eb8e8f64936834447c35
+  metadata.gz: fa89492878000e8fa0b08b244b95a432ddb96e11130da0d4655087580b63260242b00f28a3f76af32c3a9dc8d9d2830f815f22f960f5c835b4b3af851196b510
+  data.tar.gz: 1a801e2a97fdb2726e8ac282f88686e87aff42b680b54e2798b09bd70aa4e6be3678e9bf45625ab057a3d2210e99cd59eeeba31fd2761880f27cabc2b53a1566

data/CHANGELOG.md

@@ -30,6 +30,30 @@ Please file a bug if you notice a violation of semantic versioning.
 
 ### Security
 
+## [1.2.92] - 2026-09-07
+
+- TAG: [v1.2.92][1.2.92t]
+- COVERAGE: 93.52% -- 6144/6570 lines in 35 files
+- BRANCH COVERAGE: 77.98% -- 2490/3193 branches in 35 files
+- 32.41% documented
+
+### Fixed
+
+- Preserve pre-existing monorepo member changes while templating in parallel worktrees, reject concurrent member edits without overwriting them, and count only fully materialized members as successful.
+
+## [1.2.91] - 2026-09-06
+
+- TAG: [v1.2.91][1.2.91t]
+- COVERAGE: 93.58% -- 6109/6528 lines in 35 files
+- BRANCH COVERAGE: 78.06% -- 2483/3181 branches in 35 files
+- 32.41% documented
+
+### Fixed
+
+- Trust Mise configurations in disposable worktrees before member commands run.
+
+- Remove retired appraisal declarations cleanly from files without a trailing newline during template bootstrap.
+
 ## [1.2.90] - 2026-09-06
 
 - TAG: [v1.2.90][1.2.90t]
@@ -2592,7 +2616,11 @@ 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.2.90...HEAD
+[Unreleased]: https://github.com/kettle-dev/kettle-family/compare/v1.2.92...HEAD
+[1.2.92]: https://github.com/kettle-dev/kettle-family/compare/v1.2.91...v1.2.92
+[1.2.92t]: https://github.com/kettle-dev/kettle-family/releases/tag/v1.2.92
+[1.2.91]: https://github.com/kettle-dev/kettle-family/compare/v1.2.90...v1.2.91
+[1.2.91t]: https://github.com/kettle-dev/kettle-family/releases/tag/v1.2.91
 [1.2.90]: https://github.com/kettle-dev/kettle-family/compare/v1.2.89...v1.2.90
 [1.2.90t]: https://github.com/kettle-dev/kettle-family/releases/tag/v1.2.90
 [1.2.89]: https://github.com/kettle-dev/kettle-family/compare/v1.2.88...v1.2.89

data/README.md

@@ -281,6 +281,22 @@ canonical development lockfile and CI checkout share that path graph. In both
 cases, release normalization rejects every path outside the configured allow
 list.
 
+### Template concurrency
+
+Executed `kettle-jem` templating for monorepo members uses detached worktrees
+when a dependency wave contains multiple ready members and the worker budget is
+greater than one. Before a worker starts, Family copies that member's current
+tracked and untracked state into its worktree. This preserves development
+lockfile changes produced by local dependency updates instead of assuming that
+the primary checkout matches `HEAD`.
+
+After the worker succeeds, Family verifies that the same member in the primary
+checkout has not changed since the snapshot. It then materializes the worker's
+final member-scoped state and serializes the normal template commit. Changes
+outside the member root are rejected, as are concurrent edits to that member;
+in either case the primary member is left untouched. Template summaries count
+a member only after worktree materialization and any required commit succeed.
+
 ### Test concurrency
 
 `kettle-family test --execute` runs independent sibling repositories in
@@ -1121,7 +1137,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-6.494-FFDD67.svg?style=for-the-badge&logo=YouTube&logoColor=blue
+[🧮kloc-img]: https://img.shields.io/badge/KLOC-6.570-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/appraisal_bootstrap.rb

@@ -66,7 +66,8 @@ module Kettle
       def obsolete_appraisal_edit(path, source, node)
         return unless legacy_appraisal_call?(node)
 
-        line_start = source.rindex("\n", node.location.start_offset - 1).to_i + 1
+        preceding_newline = source.rindex("\n", node.location.start_offset - 1)
+        line_start = preceding_newline ? preceding_newline + 1 : 0
         line_end = source.index("\n", node.location.end_offset) || source.length
         line_end += 1 if line_end < source.length
         if final_standalone_call?(source, node, line_start, line_end)

data/lib/kettle/family/command_runner.rb

@@ -230,8 +230,8 @@ module Kettle
         @otp_coordinator = otp_coordinator
       end
 
-      def call(member:, phase:, command:, env: {}, interactive: false, stdout_line_handler: nil, log_path: nil, passthrough_output: true)
-        argv = command_argv(member: member, command: command, env: env)
+      def call(member:, phase:, command:, env: {}, interactive: false, raw: false, stdout_line_handler: nil, log_path: nil, passthrough_output: true)
+        argv = command_argv(member: member, command: command, env: env, raw: raw)
         process_env = process_env(member: member, env: env)
         spawn_options = process_options
         return skipped_result(member: member, phase: phase, argv: argv) unless execute
@@ -598,9 +598,9 @@ module Kettle
         nil
       end
 
-      def command_argv(member:, command:, env: {})
+      def command_argv(member:, command:, env: {}, raw: false)
         argv = normalize_command(command)
-        return argv unless mise_configured?(member)
+        return argv if raw || !mise_configured?(member)
 
         command_env = nonsensitive_env(env)
         unset_env, set_env = command_env.partition { |_key, value| value.nil? }

data/lib/kettle/family/report.rb

@@ -332,11 +332,16 @@ module Kettle
         template_results = results.select { |result| result.phase == "template" }
         return if template_results.empty?
 
+        successful_names = summary_succeeded
+        template_results.select! do |result|
+          !result.ok? || successful_names.include?(result.member_name)
+        end
+
         changed_files = template_results.sum { |result| template_changed_file_count(result) }
         outcome_counts = template_results.map { |result| template_file_outcomes(result) }
         lines << "template summary:"
-        lines << "  #{template_results.count(&:ok?)}/#{selected_members.length} members ok"
-        if outcome_counts.all?
+        lines << "  #{successful_names.length}/#{selected_members.length} members ok"
+        if outcome_counts.any? && outcome_counts.all?
           lines << "  #{outcome_counts.sum { |outcomes| outcomes.fetch(:checksum_hits) }} checksum hits"
           protected = outcome_counts.sum { |outcomes| outcomes.fetch(:checksum_protected) }
           lines << "  #{protected} checksum-protected changes" if protected.positive?

data/lib/kettle/family/version.rb

@@ -5,7 +5,7 @@ module Kettle
     # Version namespace for this gem.
     module Version
       # Current gem version.
-      VERSION = "1.2.90"
+      VERSION = "1.2.92"
     end
     # Current gem version exposed at the traditional constant location.
     VERSION = Version::VERSION # Traditional Constant Location

data/lib/kettle/family/workflow.rb

@@ -2,6 +2,7 @@
 
 require "io/console"
 require "fileutils"
+require "digest"
 require "json"
 require "etc"
 require "open3"
@@ -717,11 +718,14 @@ module Kettle
           results << result
           break unless result.ok?
 
-          entries << {
+          entry = {
             member: relocate_member_to_worktree(member, worktree_root, source_root: config.root),
             original_member: member,
             worktree_root: worktree_root
           }
+          entries << entry
+          results.concat(worktree_mise_trust_results(entry, runner: runner, phase: "test_member_worktree_mise_trust"))
+          break unless results.last.ok?
         end
         [entries, results]
       end
@@ -1038,11 +1042,18 @@ module Kettle
           results << result
           break unless result.ok?
 
-          entries << {
+          entry = {
             member: relocate_member_to_worktree(member, worktree_root, source_root: config.root),
             original_member: member,
             worktree_root: worktree_root
           }
+          entries << entry
+          prepare_monorepo_template_worktree(entry)
+          results.concat(worktree_mise_trust_results(entry, runner: runner, phase: "template_member_worktree_mise_trust"))
+          break unless results.last.ok?
+        rescue => error
+          results << template_worktree_failure_result(member, error, phase: "template_member_worktree_seed")
+          break
         end
         [entries, results]
       end
@@ -1096,39 +1107,64 @@ module Kettle
       def materialize_monorepo_template_changes(entry)
         original_member = entry.fetch(:original_member)
         worktree_root = entry.fetch(:worktree_root)
-        relative_root = Pathname.new(original_member.root).relative_path_from(Pathname.new(config.root)).to_s
+        relative_root = monorepo_template_relative_root(original_member)
         paths = monorepo_template_worktree_changed_paths(worktree_root)
-        return template_worktree_failure_result(original_member, paths) if paths.is_a?(String)
+        return template_worktree_failure_result(original_member, paths, phase: "template_worktree_materialize") if paths.is_a?(String)
 
         invalid_paths = paths.reject { |path| path == relative_root || path.start_with?("#{relative_root}/") }
         unless invalid_paths.empty?
           return template_worktree_failure_result(
             original_member,
-            "isolated template worker modified shared path(s): #{invalid_paths.sort.join(", ")}; only #{relative_root}/ may be materialized"
+            "isolated template worker modified shared path(s): #{invalid_paths.sort.join(", ")}; only #{relative_root}/ may be materialized",
+            phase: "template_worktree_materialize"
           )
         end
 
-        tracked_paths = monorepo_template_worktree_tracked_paths(worktree_root)
-        return template_worktree_failure_result(original_member, tracked_paths) if tracked_paths.is_a?(String)
-
-        runner = command_runner
-        control_member = monorepo_template_control_member.dup
-        control_member.name = original_member.name
-        command = if tracked_paths.empty?
-          ["true"]
-        else
-          source = Shellwords.escape(worktree_root)
-          scope = Shellwords.escape(relative_root)
-          ["sh", "-lc", "git -C #{source} diff --binary HEAD -- #{scope} | git apply --whitespace=nowarn"]
+        initial_state = entry.fetch(:primary_member_state)
+        current_state = monorepo_template_member_state(config.root, relative_root)
+        changed_primary_paths = changed_monorepo_template_state_paths(initial_state, current_state)
+        unless changed_primary_paths.empty?
+          return template_worktree_failure_result(
+            original_member,
+            "primary member changed while isolated template worker ran: #{changed_primary_paths.join(", ")}",
+            phase: "template_worktree_materialize"
+          )
         end
-        result = runner.call(member: control_member, phase: "template_worktree_materialize", command: command)
-        return result unless result.ok?
 
-        copy_monorepo_template_untracked_paths(worktree_root, config.root, relative_root)
-        result.stdout = "#{paths.length} path(s) materialized from isolated worktree"
-        result
+        materialized_paths = (entry.fetch(:primary_changed_paths) + paths).uniq.sort
+        sync_monorepo_template_paths(worktree_root, config.root, materialized_paths)
+        template_worktree_success_result(
+          original_member,
+          phase: "template_worktree_materialize",
+          stdout: "#{materialized_paths.length} path(s) materialized from isolated worktree"
+        )
       rescue => error
-        template_worktree_failure_result(original_member, error)
+        template_worktree_failure_result(original_member, error, phase: "template_worktree_materialize")
+      end
+
+      def prepare_monorepo_template_worktree(entry)
+        original_member = entry.fetch(:original_member)
+        relative_root = monorepo_template_relative_root(original_member)
+        changed_paths = monorepo_template_worktree_changed_paths(config.root)
+        raise Error, changed_paths if changed_paths.is_a?(String)
+
+        member_changed_paths = changed_paths.select do |path|
+          path == relative_root || path.start_with?("#{relative_root}/")
+        end
+        sync_monorepo_template_paths(config.root, entry.fetch(:worktree_root), member_changed_paths)
+        primary_state = monorepo_template_member_state(config.root, relative_root)
+        worktree_state = monorepo_template_member_state(entry.fetch(:worktree_root), relative_root)
+        unless primary_state == worktree_state
+          changed = changed_monorepo_template_state_paths(primary_state, worktree_state)
+          raise Error, "isolated template worker seed differs from primary member: #{changed.join(", ")}"
+        end
+
+        entry[:primary_changed_paths] = member_changed_paths
+        entry[:primary_member_state] = primary_state
+      end
+
+      def monorepo_template_relative_root(member)
+        Pathname.new(member.root).relative_path_from(Pathname.new(config.root)).to_s
       end
 
       def monorepo_template_worktree_changed_paths(worktree_root)
@@ -1149,6 +1185,28 @@ module Kettle
         git_worktree_paths(worktree_root, %w[ls-files --others --exclude-standard -z])
       end
 
+      def monorepo_template_member_state(root, relative_root)
+        paths = git_worktree_paths(root, ["ls-files", "--cached", "--others", "--exclude-standard", "-z", "--", relative_root])
+        raise Error, paths if paths.is_a?(String)
+
+        paths.to_h { |path| [path, monorepo_template_path_signature(root, path)] }
+      end
+
+      def monorepo_template_path_signature(root, path)
+        full_path = File.join(root, path)
+        stat = File.lstat(full_path)
+        return ["symlink", File.readlink(full_path)] if stat.symlink?
+        return ["file", stat.mode & 0o777, Digest::SHA256.file(full_path).hexdigest] if stat.file?
+
+        [stat.ftype, stat.mode & 0o777]
+      rescue Errno::ENOENT
+        ["missing"]
+      end
+
+      def changed_monorepo_template_state_paths(before, after)
+        (before.keys | after.keys).select { |path| before[path] != after[path] }.sort
+      end
+
       def git_worktree_paths(worktree_root, arguments)
         stdout, stderr, status = Open3.capture3("git", *arguments, chdir: worktree_root)
         return stdout.split("\0").reject(&:empty?) if status.success?
@@ -1156,14 +1214,19 @@ module Kettle
         "git #{arguments.join(" ")} failed in #{worktree_root}: #{stderr.strip}"
       end
 
-      def copy_monorepo_template_untracked_paths(worktree_root, primary_root, relative_root)
-        monorepo_template_worktree_untracked_paths(worktree_root).each do |path|
-          next unless path == relative_root || path.start_with?("#{relative_root}/")
+      def sync_monorepo_template_paths(source_root, destination_root, paths)
+        paths.each do |path|
+          source = File.join(source_root, path)
+          destination = File.join(destination_root, path)
+          FileUtils.rm_rf(destination)
+          next unless File.exist?(source) || File.symlink?(source)
 
-          source = File.join(worktree_root, path)
-          destination = File.join(primary_root, path)
           FileUtils.mkdir_p(File.dirname(destination))
-          FileUtils.cp_r(source, destination, preserve: true)
+          if File.symlink?(source)
+            File.symlink(File.readlink(source), destination)
+          else
+            FileUtils.cp_r(source, destination, preserve: true)
+          end
         end
       end
 
@@ -1178,12 +1241,28 @@ module Kettle
         end
       end
 
-      def template_worktree_failure_result(member, error)
+      def template_worktree_success_result(member, phase:, stdout:)
+        CommandResult.new(
+          member_name: member.name,
+          phase: phase,
+          command: ["internal", phase.tr("_", "-")],
+          workdir: member.root,
+          status: 0,
+          success: true,
+          stdout: stdout,
+          stderr: "",
+          elapsed_seconds: 0.0,
+          skipped: false,
+          reason: nil
+        )
+      end
+
+      def template_worktree_failure_result(member, error, phase: "template_member_worktree")
         message = error.is_a?(Exception) ? "#{error.class}: #{error.message}" : error.to_s
         CommandResult.new(
           member_name: member.name,
-          phase: "template_member_worktree",
-          command: ["internal", "template-member-worktree"],
+          phase: phase,
+          command: ["internal", phase.tr("_", "-")],
           workdir: member.root,
           status: 1,
           success: false,
@@ -1435,7 +1514,11 @@ module Kettle
               outcomes << add
               break unless add.ok?
 
-              entries << {branch: branch, member: relocate_member_to_worktree(member, worktree_root), worktree_root: worktree_root}
+              entry = {branch: branch, member: relocate_member_to_worktree(member, worktree_root), worktree_root: worktree_root}
+              entries << entry
+              trust_results = worktree_mise_trust_results(entry.merge(original_member: member), runner: runner, phase: "template_worktree_mise_trust")
+              outcomes.concat(trust_results)
+              break unless trust_results.all?(&:ok?)
             end
 
             if outcomes.all?(&:ok?)
@@ -1491,6 +1574,45 @@ module Kettle
         end
       end
 
+      # A git worktree has a distinct absolute path, and Mise deliberately
+      # tracks trust by config path. Trust every active config between the
+      # worktree root and the member command directory before invoking a
+      # command there. This bootstrap must run raw: wrapping it in `mise exec`
+      # would require the trust it is establishing.
+      def worktree_mise_trust_results(entry, runner:, phase:)
+        member = entry.fetch(:member)
+        original_member = entry.fetch(:original_member, member)
+        worktree_root = entry.fetch(:worktree_root)
+        mise_config_roots_in_worktree(worktree_root, member.root).map do |root|
+          result = runner.call(
+            member: member,
+            phase: phase,
+            command: ["mise", "trust", "-C", root],
+            raw: true
+          )
+          result.member_name = original_member.name
+          result
+        end
+      end
+
+      def mise_config_roots_in_worktree(worktree_root, member_root)
+        root_path = Pathname.new(worktree_root).realpath
+        member_path = Pathname.new(member_root).realpath
+        return [] unless member_path.to_s.start_with?("#{root_path}#{File::SEPARATOR}") || member_path == root_path
+
+        current = member_path
+        roots = []
+        loop do
+          roots << current.to_s if %w[mise.toml .mise.toml].any? { |name| File.file?(current.join(name)) }
+          break if current == root_path
+
+          current = current.parent
+        end
+        roots.reverse
+      rescue Errno::ENOENT
+        []
+      end
+
       def template_branch_worktree_entries_results(entries)
         wave_jobs = template_jobs(entries)
         queue = Queue.new
@@ -2038,7 +2160,10 @@ module Kettle
           results << result
           break unless result.ok?
 
-          entries << {member: relocate_member_to_worktree(member, root, source_root: config.root), original_member: member, worktree_root: root}
+          entry = {member: relocate_member_to_worktree(member, root, source_root: config.root), original_member: member, worktree_root: root}
+          entries << entry
+          results.concat(worktree_mise_trust_results(entry, runner: runner, phase: "release_worktree_mise_trust"))
+          break unless results.last.ok?
         end
         [entries, results]
       end
@@ -4296,13 +4421,25 @@ module Kettle
       def emit_template_progress_summary(results, progress:)
         return unless progress
 
-        template_results = results.select { |result| result.phase == "template" }
+        successful_names = successful_template_member_names(results)
+        template_results = results.select do |result|
+          result.phase == "template" && (!result.ok? || successful_names.include?(result.member_name))
+        end
         changed_files = template_results.sum { |result| template_changed_file_count(result) }
         outcome_counts = template_results.map { |result| template_file_outcomes(result) }
         progress.stop
         progress.summary(template_progress_summary_label(template_results, changed_files, outcome_counts))
       end
 
+      def successful_template_member_names(results)
+        results.group_by(&:member_name).filter_map do |member_name, member_results|
+          next unless member_results.any? { |result| result.phase == "template" }
+          next unless member_results.all?(&:ok?)
+
+          member_name
+        end
+      end
+
       def emit_release_progress_summary(results, progress:)
         return unless progress
 
@@ -4763,7 +4900,7 @@ module Kettle
 
       def template_progress_summary_label(template_results, changed_files, outcome_counts)
         label = "template summary: #{template_results.count(&:ok?)}/#{members.length} members ok"
-        return "#{label}, #{template_summary_label(changed_files)}" unless outcome_counts.all?
+        return "#{label}, #{template_summary_label(changed_files)}" if outcome_counts.empty? || !outcome_counts.all?
 
         totals = outcome_counts.each_with_object({checksum_hits: 0, checksum_protected: 0, unchanged: 0}) do |outcomes, memo|
           memo[:checksum_hits] += outcomes.fetch(:checksum_hits)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kettle-family
 version: !ruby/object:Gem::Version
-  version: 1.2.90
+  version: 1.2.92
 platform: ruby
 authors:
 - Peter H. Boling
@@ -443,10 +443,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/v1.2.90
-  changelog_uri: https://github.com/kettle-dev/kettle-family/blob/v1.2.90/CHANGELOG.md
+  source_code_uri: https://github.com/kettle-dev/kettle-family/tree/v1.2.92
+  changelog_uri: https://github.com/kettle-dev/kettle-family/blob/v1.2.92/CHANGELOG.md
   bug_tracker_uri: https://github.com/kettle-dev/kettle-family/issues
-  documentation_uri: https://www.rubydoc.info/gems/kettle-family/1.2.90
+  documentation_uri: https://www.rubydoc.info/gems/kettle-family/1.2.92
   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