kettle-dev 2.5.4 → 2.5.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 244703eadd8dc7dd81df1ba9531ad405d19307e0d710f89abf69143e17906093
-  data.tar.gz: a7f122fee074b8dac7d8851cafa09918b72cb3576d28f8def007d300012e155a
+  metadata.gz: 55c142437ccf4e28b174ed1a58df90a31a9e92401e7d2a230d1663eed6f40e25
+  data.tar.gz: fc1a6d490c79acd5da62afc7c363dfa6de8582d31670ebefba0a02c617c90ec0
 SHA512:
-  metadata.gz: 4b534ae24e40b1ae1035cfa7325dec5ae57b6c924bee555475dc11bc5974d198b0ab33f02a2a97854b90a9693f7f3342a9d655f94cfc3714601e4694cdcd8458
-  data.tar.gz: 0a1637936708e73ba2e25be58f86c9fad482b8700ea443d66141ad43939364485a0c262fdbdc2b568ee2e4360f70d987cc1f2a9d19c11107df8b4b4351f6f69c
+  metadata.gz: 01f059c2d48868c17eb93bcb29c897896b1b851af7d26fb686598d166253358b7b83b90c2e17fc7e50d634026f1fe86e41e2330d3c2a6226f9cf51634dc37542
+  data.tar.gz: a449b3e04bbc849e8914434b462a446595d82ed9a9714252307f39619f3ae66cd57c557f39396d0b06d0ad15f860e78a699aa4a8f69991f2d6a0a3d644851a69

data/CHANGELOG.md

@@ -30,6 +30,31 @@ Please file a bug if you notice a violation of semantic versioning.
 
 ### Security
 
+## [2.5.5] - 2026-07-28
+
+- TAG: [v2.5.5][2.5.5t]
+- COVERAGE: 91.66% -- 4694/5121 lines in 44 files
+- BRANCH COVERAGE: 76.18% -- 1772/2326 branches in 44 files
+- 54.44% documented
+
+### Fixed
+
+- `kettle-release` and `kettle-reset release-lockfiles` now validate local
+  workspace gem versions with an isolated Bundler inline probe against the
+  configured gem source instead of RubyGems.org version APIs, and release task
+  lockfile resets retry transient source propagation failures.
+
+- kettle-jem-template-20260728-002 - Generated RuboCop configs now ignore the
+  same `gemfiles/vendor/bundle` tree as `.gitignore`, so vendored dependency
+  installs are not reported as project lint debt.
+- kettle-jem-template-20260728-003 - Generated dep-heads workflows now run
+  TruffleRuby jobs with current RubyGems and Bundler, avoiding setup failures
+  before the test suite starts.
+
+- `kettle-release` and `kettle-reset` now warn when unexpected `BUNDLE_*` or
+  `BUNDLER_*` environment variables are present while preparing unbundled
+  subprocesses.
+
 ## [2.5.4] - 2026-07-28
 
 - TAG: [v2.5.4][2.5.4t]
@@ -2939,7 +2964,9 @@ Please file a bug if you notice a violation of semantic versioning.
   - Selecting will run the selected workflow via `act`
   - This may move to its own gem in the future.
 
-[Unreleased]: https://github.com/kettle-dev/kettle-dev/compare/v2.5.4...HEAD
+[Unreleased]: https://github.com/kettle-dev/kettle-dev/compare/v2.5.5...HEAD
+[2.5.5]: https://github.com/kettle-dev/kettle-dev/compare/v2.5.4...v2.5.5
+[2.5.5t]: https://github.com/kettle-dev/kettle-dev/releases/tag/v2.5.5
 [2.5.4]: https://github.com/kettle-dev/kettle-dev/compare/v2.5.3...v2.5.4
 [2.5.4t]: https://github.com/kettle-dev/kettle-dev/releases/tag/v2.5.4
 [2.5.3]: https://github.com/kettle-dev/kettle-dev/compare/v2.5.2...v2.5.3

data/README.md

@@ -1005,7 +1005,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-5.037-FFDD67.svg?style=for-the-badge&logo=YouTube&logoColor=blue
+[🧮kloc-img]: https://img.shields.io/badge/KLOC-5.121-FFDD67.svg?style=for-the-badge&logo=YouTube&logoColor=blue
 [🔐security]: https://github.com/kettle-dev/kettle-dev/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/dev/bundler_env_guard.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Kettle
+  module Dev
+    module BundlerEnvGuard
+      RESET_ENV_KEYS = %w[
+        BUNDLE_BIN_PATH
+        BUNDLE_FROZEN
+        BUNDLE_GEMFILE
+        BUNDLE_LOCKFILE
+        BUNDLER_SETUP
+        BUNDLER_VERSION
+      ].freeze
+
+      INERT_ENV_KEYS = %w[
+        BUNDLE_DEBUG
+        BUNDLE_QUIET
+        BUNDLE_SILENCE_DEPRECATIONS
+        BUNDLE_SILENCE_ROOT_WARNING
+        BUNDLE_SUPPRESS_INSTALL_USING_MESSAGES
+        BUNDLE_VERBOSE
+      ].freeze
+
+      INERT_ENV_PREFIXES = %w[
+        BUNDLER_ORIG_
+      ].freeze
+
+      module_function
+
+      def unbundled_env
+        RESET_ENV_KEYS.each_with_object({}) do |key, env|
+          env[key] = nil
+        end
+      end
+
+      def warn_unexpected_env!(stream: $stderr)
+        unexpected = unexpected_env_keys
+        return if unexpected.empty?
+
+        stream.puts(
+          "[kettle-dev] Unexpected Bundler environment variable(s) present while preparing an unbundled subprocess: #{unexpected.join(", ")}. " \
+            "If this variable is safe, add it to BundlerEnvGuard::INERT_ENV_KEYS; otherwise add it to RESET_ENV_KEYS."
+        )
+      end
+
+      def unexpected_env_keys
+        ENV.to_hash.keys.grep(/\ABUNDLE(?:R)?_/).reject { |key| expected_env_key?(key) }.sort
+      end
+
+      def expected_env_key?(key)
+        RESET_ENV_KEYS.include?(key) ||
+          INERT_ENV_KEYS.include?(key) ||
+          INERT_ENV_PREFIXES.any? { |prefix| key.start_with?(prefix) }
+      end
+    end
+  end
+end

data/lib/kettle/dev/exit_adapter.rb

@@ -2,6 +2,8 @@
 
 module Kettle
   module Dev
+    class Error < StandardError; end unless const_defined?(:Error, false)
+
     # Exit/abort indirection layer to allow controllable behavior in tests.
     #
     # Production/default behavior delegates to Kernel.abort / Kernel.exit,
@@ -13,6 +15,8 @@ module Kettle
     #
     # This adapter mirrors the "mockable adapter" approach used for GitAdapter.
     module ExitAdapter
+      class AbortError < Kettle::Dev::Error; end
+
       module_function
 
       # Abort the current execution with a message. By default this calls Kernel.abort,
@@ -31,6 +35,12 @@ module Kettle
       def exit(status = 0)
         Kernel.exit(status)
       end
+
+      def abort_as_error
+        yield
+      rescue SystemExit => error
+        raise AbortError, error.message
+      end
     end
   end
 end

data/lib/kettle/dev/gem_source_probe.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "open3"
+require "tmpdir"
+
+require_relative "bundler_env_guard"
+
+module Kettle
+  module Dev
+    class GemSourceProbe
+      UNBUNDLED_ENV_KEYS = (BundlerEnvGuard::RESET_ENV_KEYS + %w[
+        RUBYGEMS_GEMDEPS
+        RUBYLIB
+        RUBYOPT
+      ]).freeze
+
+      def initialize(source_url:, ruby: Gem.ruby)
+        @source_url = source_url
+        @ruby = ruby
+      end
+
+      def available?(name, version)
+        stderr = nil
+        BundlerEnvGuard.warn_unexpected_env!
+        with_probe_gem_home do |gem_home|
+          _stdout, stderr, status = Open3.capture3(
+            probe_env(gem_home),
+            "gem",
+            "install",
+            name,
+            "-v",
+            "= #{version}",
+            "--source",
+            source_url,
+            "--clear-sources",
+            "--ignore-dependencies",
+            "--no-document",
+            "--install-dir",
+            gem_home
+          )
+          status.success?
+        end
+      rescue SystemCallError => error
+        raise Error, "Could not verify #{name} #{version} from #{source_url}: #{error.message}"
+      ensure
+        warn(stderr) if ENV["KETTLE_DEV_DEBUG"] == "true" && stderr && !stderr.empty?
+      end
+
+      def self.bundler_inline_script(name:, version:, source_url:)
+        <<~RUBY
+          # frozen_string_literal: true
+
+          require "bundler/inline"
+
+          gem_name = #{name.dump}
+          version = #{version.dump}
+
+          gemfile(true) do
+            source #{source_url.dump}
+            gem gem_name, "= \#{version}", require: false
+          end
+
+          spec = Gem::Specification.find_all_by_name(gem_name, "= \#{version}").first
+          abort("resolved no \#{gem_name} \#{version} spec from #{source_url}") unless spec
+          puts "Validated \#{gem_name} \#{version} from #{source_url}"
+        RUBY
+      end
+
+      private
+
+      attr_reader :source_url, :ruby
+
+      def with_probe_gem_home
+        base = File.join(Dir.pwd, "tmp")
+        FileUtils.mkdir_p(base)
+        Dir.mktmpdir("kettle-gem-source-probe-", base) do |gem_home|
+          yield(gem_home)
+        end
+      end
+
+      def probe_env(gem_home)
+        unbundled_env.merge(
+          "GEM_HOME" => gem_home,
+          "GEM_PATH" => gem_home
+        )
+      end
+
+      def unbundled_env
+        UNBUNDLED_ENV_KEYS.each_with_object({}) do |key, env|
+          env[key] = nil
+        end
+      end
+    end
+  end
+end

data/lib/kettle/dev/lockfile_reset.rb

@@ -3,11 +3,10 @@
 require "set"
 require "shellwords"
 require "fileutils"
-require "json"
-require "net/http"
-require "uri"
 require "bundler"
 
+require_relative "bundler_env_guard"
+
 module Kettle
   module Dev
     class LockfileReset
@@ -22,12 +21,10 @@ module Kettle
       }.freeze
       RELEASE_LOCKFILES_TARGET = "release-lockfiles"
       SUPPORTED_TARGETS = ["Gemfile.lock", "Appraisal.root.gemfile.lock", RELEASE_LOCKFILES_TARGET].freeze
-      UNBUNDLED_ENV_KEYS = %w[
-        BUNDLE_BIN_PATH
-        BUNDLE_FROZEN
-        BUNDLER_VERSION
+      UNBUNDLED_ENV_KEYS = (BundlerEnvGuard::RESET_ENV_KEYS + %w[
+        RUBYLIB
         RUBYOPT
-      ].freeze
+      ]).freeze
 
       def initialize(root:, command_runner:)
         @root = root
@@ -35,6 +32,7 @@ module Kettle
       end
 
       def reset(target)
+        BundlerEnvGuard.warn_unexpected_env!
         paths = lockfile_paths_for(target)
         force_full_update = release_lockfiles_target?(target)
         uninstall_unreleased_local_gems(paths) if force_full_update
@@ -109,7 +107,7 @@ module Kettle
           diagnostics << "#{display_path(path)} CHECKSUMS has no sha256 for #{name} #{version} at line #{line_number}"
         end
         unreleased_workspace_registry_specs(path).each do |name, version, line_number|
-          diagnostics << "#{display_path(path)} locks local workspace gem #{name} #{version} as a registry gem, but that version is not released on RubyGems.org at line #{line_number}"
+          diagnostics << "#{display_path(path)} locks local workspace gem #{name} #{version} as a registry gem, but that version is not resolvable from the configured gem source at line #{line_number}"
         end
         diagnostics
       end
@@ -232,9 +230,10 @@ module Kettle
         local_names = local_workspace_gem_names
         return [] if local_names.empty?
 
+        source_urls = registry_source_urls(path)
         registry_specs_with_lines(path).filter_map do |name, version, line_number|
           next unless local_names.include?(name)
-          next if ruby_gems_version_available?(name, version)
+          next if gem_source_version_available?(name, version, source_urls)
 
           [name, version, line_number]
         end
@@ -341,7 +340,7 @@ module Kettle
         locked_registry_specs(paths).each do |name, version|
           next unless local_names.include?(name)
           next unless locally_installed?(name, version)
-          next if ruby_gems_version_available?(name, version)
+          next if gem_source_version_available?(name, version, source_urls_for_lockfiles(paths))
 
           uninstall_unreleased_local_gem(name, version)
           uninstalled = true
@@ -398,33 +397,43 @@ module Kettle
         false
       end
 
-      def ruby_gems_version_available?(name, version)
-        version_text = version.to_s
-        platform = "ruby"
-        if version_text =~ /\A(.+)-([^-]+-[^-]+(?:-[^-]+)?)\z/
-          version_text = Regexp.last_match(1)
-          platform = Regexp.last_match(2)
-        end
-        ruby_gems_versions(name).any? do |entry|
-          entry.fetch("number", entry["version"]) == version_text &&
-            %W[ruby #{platform}].include?(entry.fetch("platform", "ruby").to_s)
-        end
+      def gem_source_version_available?(name, version, source_urls)
+        urls = Array(source_urls).compact.uniq
+        return false if urls.empty?
+
+        urls.any? { |source_url| bundler_inline_version_available?(name, version, source_url) }
+      end
+
+      def bundler_inline_version_available?(name, version, source_url)
+        @gem_source_version_available ||= {}
+        cache_key = [source_url, name, version]
+        return @gem_source_version_available[cache_key] if @gem_source_version_available.key?(cache_key)
+
+        @gem_source_version_available[cache_key] = GemSourceProbe.new(source_url: source_url).available?(name, version)
+      end
+
+      def source_urls_for_lockfiles(paths)
+        paths.flat_map { |path| registry_source_urls(path) }.uniq
       end
 
-      def ruby_gems_versions(name)
-        @ruby_gems_versions ||= {}
-        @ruby_gems_versions.fetch(name) do
-          uri = URI("https://rubygems.org/api/v1/versions/#{URI.encode_www_form_component(name)}.json")
-          response = Net::HTTP.get_response(uri)
-          unless response.is_a?(Net::HTTPSuccess)
-            raise Error, "Could not verify released versions for #{name} from RubyGems.org (HTTP #{response.code})"
+      def registry_source_urls(path)
+        urls = []
+        in_gem = false
+        File.readlines(path).each do |line|
+          stripped = line.strip
+          if stripped == "GEM"
+            in_gem = true
+            next
+          end
+          if stripped.match?(/\A[A-Z][A-Z ]*\z/)
+            in_gem = stripped == "GEM"
+            next
           end
+          next unless in_gem && stripped.start_with?("remote:")
 
-          versions = JSON.parse(response.body)
-          @ruby_gems_versions[name] = versions
+          urls << stripped.delete_prefix("remote:").strip
         end
-      rescue JSON::ParserError => error
-        raise Error, "Could not parse released versions for #{name} from RubyGems.org: #{error.message}"
+        urls
       end
 
       def uninstall_command(name, version)

data/lib/kettle/dev/rakelib/yard.rake

@@ -34,13 +34,14 @@ begin
     end
   end
 
+  desc "Generate YARD documentation and run YARD lint"
   task yard: "yard:lint"
   Kettle::Dev.register_default("yard:lint")
   Kettle::Dev.register_default("yard")
 rescue LoadError
   warn("[kettle-dev][yard.rake] failed to load yard") if Kettle::Dev::DEBUGGING
   desc("(stub) yard is unavailable")
-  task(:yard) do
+  task(:yard) do # rubocop:disable Rake/DuplicateTask -- fallback when the real YARD task cannot load
     warn("NOTE: yard isn't installed, or is disabled for #{RUBY_VERSION} in the current environment")
   end
   Kettle::Dev.register_default("yard")

data/lib/kettle/dev/release_cli.rb

@@ -18,6 +18,7 @@ require "kettle/rb/compat_matrix"
 require "ruby-progressbar"
 
 require_relative "interactive_release_command"
+require_relative "exit_adapter"
 require_relative "lockfile_reset"
 require_relative "release_secrets"
 
@@ -69,7 +70,7 @@ module Kettle
             ok = system(env_hash, cmd)
             unless ok
               exit_code = $?.respond_to?(:exitstatus) ? $?.exitstatus : 1
-              abort("Command failed: #{cmd} (exit #{exit_code})")
+              Kettle::Dev::ExitAdapter.abort("Command failed: #{cmd} (exit #{exit_code})")
             end
             return
           end
@@ -90,7 +91,7 @@ module Kettle
               tail = stderr_str.lines.last(20).join
               diag = "\n--- STDERR (last 20 lines) ---\n#{tail}".rstrip
             end
-            abort("Command failed: #{cmd} (exit #{exit_code})#{diag}")
+            Kettle::Dev::ExitAdapter.abort("Command failed: #{cmd} (exit #{exit_code})#{diag}")
           end
         end
 
@@ -586,15 +587,26 @@ module Kettle
       def reset_release_lockfiles!(stage:)
         return if @release_lockfiles_reset_for_release_tasks && stage == "before release task bundle installs"
 
-        puts "Resetting release lockfiles with local path dependencies disabled #{stage}..."
-        begin
-          lockfile_reset.reset(Kettle::Dev::LockfileReset::RELEASE_LOCKFILES_TARGET)
-        rescue Kettle::Dev::Error => error
-          raise unless error.message.start_with?("Reset #{Kettle::Dev::LockfileReset::RELEASE_LOCKFILES_TARGET} failed validation:")
+        attempts = release_lockfile_reset_attempts(stage)
+        attempts.times do |index|
+          attempt = index + 1
+          puts "Resetting release lockfiles with local path dependencies disabled #{stage} (attempt #{attempt}/#{attempts})..."
+          begin
+            lockfile_reset.reset(Kettle::Dev::LockfileReset::RELEASE_LOCKFILES_TARGET)
+            break
+          rescue Kettle::Dev::Error => error
+            raise unless error.message.start_with?("Reset #{Kettle::Dev::LockfileReset::RELEASE_LOCKFILES_TARGET} failed validation:")
+
+            # Keep release-facing failures shaped like the lockfile validation
+            # guard, even when the shared reset helper is the component that
+            # detects the unrepaired lockfile.
+            break
+          rescue => error
+            raise unless retryable_release_lockfile_reset_error?(error) && attempt < attempts
 
-          # Keep release-facing failures shaped like the lockfile validation
-          # guard, even when the shared reset helper is the component that
-          # detects the unrepaired lockfile.
+            puts "Release lockfile reset could not resolve a gem from #{RELEASE_VALIDATION_SOURCE}; waiting before retry #{attempt + 1}/#{attempts}."
+            sleep(release_availability_probe_interval)
+          end
         end
 
         diagnostics = release_lockfile_paths.flat_map { |path| release_lockfile_diagnostics(path) }
@@ -604,6 +616,17 @@ module Kettle
         @release_lockfiles_reset_for_release_tasks = true if stage == "before release task bundle installs"
       end
 
+      def release_lockfile_reset_attempts(stage)
+        (stage == "before release task bundle installs") ? release_availability_probe_attempts : 1
+      end
+
+      def retryable_release_lockfile_reset_error?(error)
+        message = error.message.to_s
+        message.include?("Bundler::GemNotFound") ||
+          message.include?("Could not find gem") ||
+          message.include?("can no longer be found in that source")
+      end
+
       def validate_release_lockfiles!(stage:)
         diagnostics = release_lockfile_paths.flat_map { |path| release_lockfile_diagnostics(path) }
         return if diagnostics.empty?
@@ -722,7 +745,13 @@ module Kettle
       end
 
       def lockfile_reset
-        @lockfile_reset ||= Kettle::Dev::LockfileReset.new(root: @root, command_runner: method(:run_cmd!))
+        @lockfile_reset ||= Kettle::Dev::LockfileReset.new(root: @root, command_runner: method(:run_lockfile_reset_command!))
+      end
+
+      def run_lockfile_reset_command!(command)
+        Kettle::Dev::ExitAdapter.abort_as_error do
+          run_cmd!(command)
+        end
       end
 
       def run_changelog!
@@ -1390,39 +1419,11 @@ module Kettle
       end
 
       def release_availability_probe_script(candidate)
-        <<~RUBY
-          # frozen_string_literal: true
-
-          gem_name = #{candidate.gem_name.dump}
-          version = #{candidate.version.dump}
-
-          require "bundler"
-          require "pathname"
-
-          Bundler.reset!
-          Bundler.unbundle_env!
-          Bundler.instance_variable_set(:@bundle_path, Pathname.new(Gem.dir))
-          Bundler::SharedHelpers.set_env("BUNDLE_GEMFILE", "Gemfile")
-          Bundler::SharedHelpers.set_env("BUNDLE_LOCKFILE", "Gemfile.lock")
-
-          builder = Bundler::Dsl.new
-          builder.source(#{RELEASE_VALIDATION_SOURCE.dump})
-          builder.gem(gem_name, "= \#{version}", require: false)
-          definition = builder.to_definition(nil, true)
-          definition.validate_runtime!
-
-          Bundler.settings.temporary(deployment: false, frozen: false, inline: true, no_install: false) do
-            installer = Bundler::Installer.install(Bundler.root, definition, system: true)
-            installer.post_install_messages.each do |name, message|
-              warn("Post-install message from \#{name}:\\n\#{message}")
-            end
-          end
-
-          spec = definition.specs.find { |candidate| candidate.name == gem_name }
-          abort("resolved no \#{gem_name} spec") unless spec
-          abort("resolved \#{gem_name} \#{spec.version}, expected \#{version}") unless spec.version.to_s == version
-          puts "Validated \#{gem_name} \#{version} from #{RELEASE_VALIDATION_SOURCE}"
-        RUBY
+        GemSourceProbe.bundler_inline_script(
+          name: candidate.gem_name,
+          version: candidate.version,
+          source_url: RELEASE_VALIDATION_SOURCE
+        )
       end
 
       def detect_version

data/lib/kettle/dev/version.rb

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

data/lib/kettle/dev.rb

@@ -29,6 +29,7 @@ module Kettle
     autoload :ChangelogCLI, "kettle/dev/changelog_cli"
     autoload :ChangelogEntryAdder, "kettle/dev/changelog_entry_adder"
     autoload :BumpCLI, "kettle/dev/bump_cli"
+    autoload :BundlerEnvGuard, "kettle/dev/bundler_env_guard"
     autoload :CIHelpers, "kettle/dev/ci_helpers"
     autoload :CIMonitor, "kettle/dev/ci_monitor"
     autoload :CommitMsg, "kettle/dev/commit_msg"
@@ -36,6 +37,7 @@ module Kettle
     autoload :ExitAdapter, "kettle/dev/exit_adapter"
     autoload :RubyGemsVersions, "kettle/dev/ruby_gems_versions"
     autoload :GemSpecReader, "kettle/dev/gem_spec_reader"
+    autoload :GemSourceProbe, "kettle/dev/gem_source_probe"
     autoload :GitAdapter, "kettle/dev/git_adapter"
     autoload :GitCommitFooter, "kettle/dev/git_commit_footer"
     autoload :GhaShaPinsCLI, "kettle/dev/gha_sha_pins_cli"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kettle-dev
 version: !ruby/object:Gem::Version
-  version: 2.5.4
+  version: 2.5.5
 platform: ruby
 authors:
 - Peter H. Boling
@@ -296,7 +296,7 @@ dependencies:
         version: '2.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.0.6
+        version: 2.0.7
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -306,7 +306,7 @@ dependencies:
         version: '2.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.0.6
+        version: 2.0.7
 description: "\U0001F372 Kettle::Dev is a meta tool from kettle-dev to streamline
   development and testing. Acts as a shim dependency, pulling in many other dependencies,
   to give you OOTB productivity with a RubyGem, or Ruby app project. Configures a
@@ -350,6 +350,7 @@ files:
 - lib/kettle-dev.rb
 - lib/kettle/dev.rb
 - lib/kettle/dev/bump_cli.rb
+- lib/kettle/dev/bundler_env_guard.rb
 - lib/kettle/dev/cache_progress.rb
 - lib/kettle/dev/changelog_cli.rb
 - lib/kettle/dev/changelog_entry_adder.rb
@@ -359,6 +360,7 @@ files:
 - lib/kettle/dev/dvcs_cli.rb
 - lib/kettle/dev/executable_version.rb
 - lib/kettle/dev/exit_adapter.rb
+- lib/kettle/dev/gem_source_probe.rb
 - lib/kettle/dev/gem_spec_reader.rb
 - lib/kettle/dev/gha_sha_pins_cli.rb
 - lib/kettle/dev/git_adapter.rb
@@ -395,10 +397,10 @@ licenses:
 - AGPL-3.0-only
 metadata:
   homepage_uri: https://kettle-dev.galtzo.com
-  source_code_uri: https://github.com/kettle-dev/kettle-dev/tree/v2.5.4
-  changelog_uri: https://github.com/kettle-dev/kettle-dev/blob/v2.5.4/CHANGELOG.md
+  source_code_uri: https://github.com/kettle-dev/kettle-dev/tree/v2.5.5
+  changelog_uri: https://github.com/kettle-dev/kettle-dev/blob/v2.5.5/CHANGELOG.md
   bug_tracker_uri: https://github.com/kettle-dev/kettle-dev/issues
-  documentation_uri: https://www.rubydoc.info/gems/kettle-dev/2.5.4
+  documentation_uri: https://www.rubydoc.info/gems/kettle-dev/2.5.5
   funding_uri: https://github.com/sponsors/pboling
   wiki_uri: https://github.com/kettle-dev/kettle-dev/wiki
   news_uri: https://www.railsbling.com/tags/kettle-dev