kettle-jem 7.1.1 → 7.1.4

data/lib/kettle/jem/templates/gemfiles/modular/templating_local.gemfile.example

@@ -17,6 +17,7 @@ structuredmerge_local_gems = %w[
   citrus-toml-merge
   dotenv-merge
   go-merge
+  html-merge
   json-merge
   kettle-jem
   kramdown-merge
@@ -43,7 +44,7 @@ kettle_dev_local_gems = %w[
   {KJ|KETTLE_DEV_LOCAL_GEMS}
 ]
 declared_gems = instance_variable_get(:@dependencies).to_a.map(&:name)
-structuredmerge_local_gems_to_eval = structuredmerge_local_gems - %w[{KJ|PACKAGE_NAME}] - declared_gems
+structuredmerge_local_gems_to_eval = structuredmerge_local_gems - %w[{KJ|PACKAGE_NAME}]
 kettle_dev_local_gems_to_eval = kettle_dev_local_gems - %w[{KJ|PACKAGE_NAME}] - (declared_gems - %w[kettle-dev])
 
 platform :mri do

data/lib/kettle/jem/templates/gemfiles/modular/x_std_libs/r3.1/libs.gemfile.example

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 eval_gemfile "../../erb/r3.1/v4.0.gemfile"
 eval_gemfile "../../mutex_m/r3/v0.3.gemfile"
 eval_gemfile "../../stringio/r3/v3.0.gemfile"

data/lib/kettle/jem/templates/shim/gem.gemspec.example

@@ -30,7 +30,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency "{KJ|SHIMMED_GEM_NAME}"
 
   # Dev, Test, & Release Tasks
-  spec.add_development_dependency("kettle-dev", "~> 2.5", ">= 2.5.24")             # ruby >= {KJ|MIN_TEST_RUBY}
+  spec.add_development_dependency("kettle-dev", "~> 3.0", ">= 3.0.6")             # ruby >= {KJ|MIN_TEST_RUBY}
 
   # Tasks
   spec.add_development_dependency "rake", "~> 13.0"

data/lib/kettle/jem/version.rb

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

data/lib/kettle/jem.rb

@@ -20,9 +20,11 @@ require "ast/crispr/markdown/markly"
 require "kettle/ndjson"
 require "rbs"
 require "kettle/dev"
+require "kettle/changelog"
 require "kettle/rb/compat_matrix"
 require_relative "jem/version"
 require_relative "jem/license_txt_migrator"
+require_relative "jem/maintenance_changelog"
 
 begin
   require "kettle/drift"
@@ -38,7 +40,7 @@ module Kettle
     CONTENT_RECIPE_TRANSPORT_VERSION = Ast::Merge::STRUCTURED_EDIT_TRANSPORT_VERSION
     TEMPLATE_SOURCE_APPLICATION_FINGERPRINT_VERSION = 1
     APPRAISALS_TEMPLATE_POLICY_FINGERPRINT_VERSION = 2
-    GEMSPEC_TEMPLATE_POLICY_FINGERPRINT_VERSION = 1
+    GEMSPEC_TEMPLATE_POLICY_FINGERPRINT_VERSION = 2
     SPEC_HELPER_TEMPLATE_POLICY_FINGERPRINT_VERSION = 1
     VERSION_NAMESPACE_TEMPLATE_POLICY_FINGERPRINT_VERSION = 2
     KETTLE_CONFIG_PATH = ".structuredmerge/kettle-jem.yml"
@@ -50,6 +52,9 @@ module Kettle
     GEMSPEC_DEPENDENCY_MINIMUM_REQUIREMENTS = {
       "rspec-stubbed_env" => ">= 1.0.6"
     }.freeze
+    DEFAULT_GEMSPEC_METADATA_VALUES = {
+      "allowed_push_host" => "TODO: Set to your gem server 'https://example.com'"
+    }.freeze
     OBSOLETE_GITHUB_WORKFLOWS = %w[
       ancient.yml
       legacy.yml
@@ -439,6 +444,7 @@ module Kettle
       KJ|MAIN_GEMFILE_NOMONO_BOOTSTRAP
       KJ|MIN_DIVERGENCE_THRESHOLD
       KJ|MIN_RUBY
+      KJ|KETTLE_CHANGELOG_GEMFILE_DEPENDENCY
       KJ|OPENCOLLECTIVE_ORG
       KJ|README:COPYRIGHT_NOTICE
       KJ|README:CORPORATE_SPONSORS
@@ -848,6 +854,9 @@ module Kettle
             label = owner.label.to_s
             label if patterns.fetch(:ref_prefixes).any? { |pattern| pattern.match?(label) }
           end
+          ref_labels.each do |label|
+            processed = remove_markdown_inline_references(processed, label)
+          end
           processed = delete_markdown_link_definitions(processed, ref_labels)
         end
 
@@ -1399,6 +1408,7 @@ module Kettle
       "🖇osc-sponsors-bottom-img"
     ].freeze
     README_INTEGRATIONS = %w[codecov coveralls qlty codeql skywalking-eyes].freeze
+    README_STAR_HISTORY_MIN_STARS = 150
     README_DISCOVERED_INTEGRATIONS = (README_INTEGRATIONS - [SKYWALKING_EYES_INTEGRATION]).freeze
     COVERAGE_INTEGRATIONS = %w[codecov coveralls qlty].freeze
     MANAGED_INTEGRATIONS = (COVERAGE_INTEGRATIONS + [SKYWALKING_EYES_INTEGRATION]).freeze
@@ -4790,6 +4800,10 @@ module Kettle
     end
 
     def post_apply_steps(project_root, report)
+      selection = report.fetch(:template_selection, {})
+      scoped_template = Array(selection[:only]).any?
+      return [kettle_jem_state_sync_step(project_root, report)].compact if scoped_template
+
       [
         *[template_version_gem_bootstrap_step(project_root, report)].flatten,
         executable_version_entrypoint_sync_step(project_root, report),
@@ -5164,6 +5178,7 @@ module Kettle
         updated.insert(profile_index + 1, *entries_lines)
       end
       sync_kettle_config_gemspec_strategy_lines!(updated, gemspec_path)
+      sync_kettle_config_rakefile_strategy_lines!(updated)
       ensure_trailing_newline(updated.join("\n"))
     end
 
@@ -5194,6 +5209,33 @@ module Kettle
       end
     end
 
+    def sync_kettle_config_rakefile_strategy_lines!(lines)
+      files_index = lines.index("files:")
+      return unless files_index
+
+      rakefile_index = ((files_index + 1)...lines.length).find do |index|
+        line = lines.fetch(index)
+        break nil if top_level_yaml_key_line?(line)
+
+        line == "  Rakefile:"
+      end
+      unless rakefile_index
+        insertion_index = kettle_config_gemspec_override_insertion_index(lines, files_index)
+        lines.insert(insertion_index, "  Rakefile:", "    strategy: accept_template")
+        return
+      end
+
+      block_end = kettle_config_file_override_block_end(lines, rakefile_index)
+      strategy_index = ((rakefile_index + 1)...block_end).find do |index|
+        lines.fetch(index).start_with?("    strategy:")
+      end
+      if strategy_index
+        lines[strategy_index] = "    strategy: accept_template"
+      else
+        lines.insert(rakefile_index + 1, "    strategy: accept_template")
+      end
+    end
+
     def remove_stale_gemspec_file_override_blocks!(lines, files_index, gemspec)
       index = files_index + 1
       while index < lines.length
@@ -5278,15 +5320,15 @@ module Kettle
       [
         {name: "appraisal2", source: %(gem "appraisal2", "~> 3.2", ">= 3.2.2"\n)},
         {name: "bundler-audit", source: %(gem "bundler-audit", "~> 0.9.3"\n)},
-        {name: "kettle-dev", source: %(gem "kettle-dev", "~> 2.5", ">= 2.5.24"\n)},
+        {name: "kettle-dev", source: %(gem "kettle-dev", "~> 3.0", ">= 3.0.6"\n)},
         {name: "kettle-drift", source: %(gem "kettle-drift", "~> 1.0", ">= 1.0.12"\n)},
-        {name: "kettle-family", source: %(gem "kettle-family", "~> 1.2", ">= 1.2.41"\n)},
-        {name: "kettle-jem", source: %(gem "kettle-jem", "~> 7.0", ">= 7.0.0"\n)},
+        {name: "kettle-family", source: %(gem "kettle-family", "~> 1.2", ">= 1.2.51"\n)},
+        {name: "kettle-jem", source: %(gem "kettle-jem", "~> 7.1", ">= 7.1.3"\n)},
         {name: "kettle-test", source: %(gem "kettle-test", "~> 2.0", ">= 2.0.19"\n)},
         {name: "rake", source: %(gem "rake", "~> 13.0"\n)},
         {name: "rspec", source: %(gem "rspec", "~> 3.0"\n)},
         {name: "stone_checksums", source: %(gem "stone_checksums", "~> 1.0", ">= 1.0.8"\n)},
-        {name: "turbo_tests2", source: %(gem "turbo_tests2", "~> 3.2", ">= 3.2.4"\n)}
+        {name: "turbo_tests2", source: %(gem "turbo_tests2", "~> 3.2", ">= 3.2.5"\n)}
       ].freeze
     end
 
@@ -6350,37 +6392,11 @@ module Kettle
     end
 
     def apply_changelog_transfer_entries(content, entries, excluded_keys: [])
-      transfer_entries = Array(entries).select do |entry|
-        entry.is_a?(Hash) && entry[:key].to_s != "" && Array(entry[:lines]).any?
-      end
-
-      normalized = normalize_changelog(content, {})
-      normalized = remove_excluded_changelog_transfer_entries(normalized, excluded_keys)
-      existing_keys = changelog_transfer_keys(normalized)
-      missing = transfer_entries.reject { |entry| existing_keys.include?(entry.fetch(:key)) }
-      return ensure_trailing_newline(normalized) if missing.empty?
-
-      lines = markdown_source_lines(normalized)
-      unreleased = changelog_unreleased_line_index(lines)
-      return ensure_trailing_newline(normalized) unless unreleased
-
-      destination_end = changelog_unreleased_end_index(lines, unreleased)
-      destination_body = lines[(unreleased + 1)...destination_end] || []
-      items = changelog_unreleased_items(destination_body)
-      missing.group_by { |entry| entry.fetch(:section, "### Changed") }.each do |section, section_entries|
-        section = CHANGELOG_STANDARD_HEADINGS.include?(section) ? section : "### Changed"
-        items[section] ||= []
-        items[section].pop while items[section].any? && items[section].last.to_s.strip.empty?
-        items[section] << "" if items[section].any?
-        section_entries.each do |entry|
-          items[section].concat(Array(entry.fetch(:lines)).map(&:rstrip))
-        end
-      end
-
-      merged_lines = lines[0...unreleased] +
-        build_changelog_unreleased_section(lines.fetch(unreleased), items) +
-        lines[destination_end..].to_a
-      ensure_trailing_newline(merged_lines.join("\n").gsub(/\n{3,}/, "\n\n"))
+      Kettle::Changelog::TransferMerger.apply(
+        content: normalize_changelog(content, {}),
+        entries: entries,
+        excluded_keys: excluded_keys
+      )
     end
 
     def remove_excluded_changelog_transfer_entries(content, excluded_keys)
@@ -6988,7 +7004,13 @@ module Kettle
           destination_content: original
         )
         return with_readme_timing("readme.append_used_link_definitions") do
-          append_used_markdown_link_definitions(processed, resolved)
+          appended = append_used_markdown_link_definitions(processed, resolved)
+          postprocess_readme_content(
+            appended,
+            facts,
+            project_root: project_root,
+            destination_content: original
+          )
         end
       end
       if strategy.empty? || strategy == "merge"
@@ -7164,7 +7186,9 @@ module Kettle
 
     def delete_yaml_top_level_mapping_entries(content, parent_key:, child_keys:)
       document = Psych.parse(content.to_s)
-      root = document&.root
+      # Psych returns `false` for a comment-only document under some versions.
+      # Such content has no mapping to prune and must pass through unchanged.
+      root = document.root if document.respond_to?(:root)
       return content unless root.is_a?(Psych::Nodes::Mapping)
 
       parent = yaml_mapping_value(root, parent_key)
@@ -7174,7 +7198,7 @@ module Kettle
       ranges = parent.children.each_slice(2).filter_map do |key_node, value_node|
         next unless child_key_set.include?(key_node.value.to_s)
 
-        key_node.start_line..value_node.end_line
+        key_node.start_line...value_node.end_line
       end
       return content if ranges.empty?
 
@@ -7232,6 +7256,13 @@ module Kettle
           engines: facts.dig(:rubygems, :engines)
         )
       end
+      processed = with_readme_timing("postprocess.compatibility_summary") do
+        normalize_readme_compatibility_summary(
+          processed,
+          facts.dig(:rubygems, :engines),
+          minimum_ruby_token(facts.dig(:rubygems, :min_ruby))
+        )
+      end
       processed = with_readme_timing("postprocess.project_heading") { normalize_readme_project_heading(processed, facts) }
       processed = with_readme_timing("postprocess.synopsis_heading") { normalize_readme_synopsis_heading(processed, facts) }
       processed = with_readme_timing("postprocess.conditional_blocks") { apply_readme_conditional_blocks(processed, facts) }
@@ -7334,7 +7365,17 @@ module Kettle
     def apply_readme_conditional_blocks(content, facts)
       open_collective_enabled = !facts.dig(:funding, :open_collective_disabled)
       processed = apply_markdown_conditional_block(content, "OPEN_COLLECTIVE", keep: open_collective_enabled)
-      apply_markdown_conditional_block(processed, "NO_OPEN_COLLECTIVE", keep: !open_collective_enabled)
+      processed = apply_markdown_conditional_block(processed, "NO_OPEN_COLLECTIVE", keep: !open_collective_enabled)
+      star_history_enabled = facts.dig(:repository, :star_history, :enabled) == true
+      return processed if star_history_enabled
+
+      delete_markdown_with_ast_crispr(
+        processed,
+        Ast::Crispr::Markdown::Markly::Selectors.html_details(
+          summary_text: "⭐️ Star History",
+          limit: {at_least: 0}
+        )
+      )
     end
 
     def apply_readme_badge_policy(content, facts)
@@ -7364,9 +7405,31 @@ module Kettle
           )
         end
       end
+      Array(facts.dig(:readme_style, :disabled_integrations)).each do |integration|
+        patterns = README_INTEGRATION_BADGE_PATTERNS.fetch(integration.to_s, [])
+        labels = README_INTEGRATION_LINK_LABELS.fetch(integration.to_s, [])
+        processed = patterns.reduce(processed) { |content, pattern| content.gsub(pattern, "") }
+        processed = ReadmePostProcessor.delete_markdown_link_definitions(processed, labels)
+      end
       processed
     end
 
+    def normalize_readme_compatibility_summary(content, engines, min_ruby = "")
+      enabled = Array(engines).map { |engine| engine.to_s.strip.downcase }.reject(&:empty?).uniq
+      return content if enabled.empty?
+
+      runtime_floor = min_ruby.to_s.strip
+      runtime_floor = " #{runtime_floor}+" unless runtime_floor.empty?
+      runtime_engines = ["MRI Ruby#{runtime_floor}"]
+      runtime_engines << "JRuby" if enabled.include?("jruby")
+      runtime_engines << "TruffleRuby" if enabled.include?("truffleruby") || enabled.include?("truby")
+      description = runtime_engines.one? ? runtime_engines.first : runtime_engines[0...-1].join(", ") + ", and #{runtime_engines.last}"
+      content.to_s.sub(
+        /Compatible with MRI Ruby [^\n]+\./,
+        "Compatible with #{description}."
+      )
+    end
+
     def remove_readme_badge_and_refs(content, badge_source, link_labels)
       ensure_runtime_dependencies!
       processed = content.to_s.gsub(badge_source, "").lines.map(&:rstrip).join("\n")
@@ -9646,7 +9709,7 @@ module Kettle
         replacement = if record.fetch(:source).lines.one?
           "%w[#{kept.join(" ")}]"
         else
-          ruby_multiline_word_array_source(kept, indent: record.fetch(:start_column))
+          ruby_multiline_word_array_source(kept, indent: record.fetch(:line_indent))
         end
         {start_offset: record.fetch(:start_offset), end_offset: record.fetch(:end_offset), replacement: replacement}
       end
@@ -9657,13 +9720,15 @@ module Kettle
     end
 
     def ruby_word_array_records(content)
+      lines = content.to_s.lines
       ruby_word_array_nodes(content).map do |node|
+        source_line = lines.fetch(node.location.start_line - 1)
         {
           names: ruby_word_array_names(node),
           source: node.location.slice,
           start_line: node.location.start_line,
           end_line: node.location.end_line,
-          start_column: node.location.start_column,
+          line_indent: source_line.length - source_line.lstrip.length,
           start_offset: node.location.start_offset,
           end_offset: node.location.end_offset
         }
@@ -9690,9 +9755,9 @@ module Kettle
     end
 
     def ruby_multiline_word_array_source(names, indent:)
-      prefix = " " * indent.to_i
-      element_prefix = "#{prefix}  "
-      (["#{prefix}%w["] + names.map { |name| "#{element_prefix}#{name}" } + ["#{prefix}]"]).join("\n")
+      element_prefix = " " * (indent.to_i + 2)
+      closing_prefix = " " * indent.to_i
+      (["%w["] + names.map { |name| "#{element_prefix}#{name}" } + ["#{closing_prefix}]"]).join("\n")
     end
 
     def replace_source_offsets(content, replacements)
@@ -10259,6 +10324,13 @@ module Kettle
       merged = apply_configured_gemspec_licenses(merged, facts, receiver: template_receiver)
       merged = apply_configured_gemspec_required_ruby_version(merged, facts, receiver: template_receiver)
       merged = apply_configured_gemspec_metadata(merged, facts, receiver: template_receiver)
+      merged = preserve_destination_only_gemspec_metadata(
+        merged,
+        template_content: template_content,
+        destination_content: destination_content,
+        template_receiver: template_receiver,
+        destination_receiver: destination_receiver
+      )
       merged = remove_duplicate_gemspec_assignments(merged, receiver: template_receiver, fields: %w[homepage])
       merged = remove_gemspec_self_dependency_lines(merged, package_name, receiver: template_receiver)
       merged = remove_gemspec_version_gem_dependency_when_disabled(
@@ -10527,6 +10599,36 @@ module Kettle
       content
     end
 
+    def preserve_destination_only_gemspec_metadata(
+      content,
+      template_content:,
+      destination_content:,
+      template_receiver:,
+      destination_receiver:
+    )
+      template_keys = gemspec_metadata_assignment_records(template_content, receiver: template_receiver).map do |record|
+        record.fetch(:key)
+      end
+      merged_keys = gemspec_metadata_assignment_records(content, receiver: template_receiver).map do |record|
+        record.fetch(:key)
+      end
+      destination_records = gemspec_metadata_assignment_records(destination_content, receiver: destination_receiver).select do |record|
+        !template_keys.include?(record.fetch(:key)) &&
+          !merged_keys.include?(record.fetch(:key)) &&
+          !default_gemspec_metadata_assignment?(record)
+      end
+      return content if destination_records.empty?
+
+      insertion = destination_records.map do |record|
+        normalize_gemspec_receiver(record.fetch(:source).rstrip, from: destination_receiver, to: template_receiver)
+      end.join("\n") + "\n"
+      anchor = gemspec_metadata_assignment_records(content, receiver: template_receiver).last
+      anchor ||= gemspec_assignment_records(content, receiver: template_receiver).find { |record| record.fetch(:field) == "homepage" }
+      return content unless anchor
+
+      insert_lines_after(content, anchor.fetch(:end_line), insertion)
+    end
+
     def gemspec_metadata_assignment_records(content, receiver:)
       lines = content.to_s.lines
       ruby_call_records(content, :[]=).filter_map do |call|
@@ -10540,6 +10642,7 @@ module Kettle
         end_line = ruby_node_source_end_line(call)
         {
           key: key,
+          value: ruby_static_string_value(args[1]),
           start_line: start_line,
           end_line: end_line,
           source: lines[(start_line - 1)..(end_line - 1)].to_a.join
@@ -10549,6 +10652,10 @@ module Kettle
       []
     end
 
+    def default_gemspec_metadata_assignment?(record)
+      DEFAULT_GEMSPEC_METADATA_VALUES[record.fetch(:key)] == record[:value]
+    end
+
     def remove_gemspec_version_gem_dependency_when_disabled(content, facts, receiver:, template_declares_version_gem: false)
       return content if version_gem_enabled?(facts)
       return content if template_declares_version_gem && !version_gem_explicitly_disabled?(facts) && version_gem_runtime_compatible?(facts)
@@ -12576,7 +12683,9 @@ module Kettle
     def add_monorepo_subgem_file_overrides(content, gemspec_path, profile = MONOREPO_SUBGEM_TEMPLATE_PROFILE)
       override_lines = [
         "  README.md:",
-        "    strategy: merge"
+        "    strategy: merge",
+        "  Rakefile:",
+        "    strategy: accept_template"
       ]
       gemspec = gemspec_path.to_s.strip
       unless gemspec.empty?
@@ -13768,6 +13877,9 @@ module Kettle
         "KJ|MIN_RUBY" => minimum_ruby_token(rubygems[:min_ruby]),
         "KJ|MIN_DEV_RUBY" => facts.dig(:project_runtime, :test_min_ruby).to_s,
         "KJ|MIN_TEST_RUBY" => facts.dig(:project_runtime, :test_min_ruby).to_s,
+        "KJ|KETTLE_CHANGELOG_GEMFILE_DEPENDENCY" => kettle_changelog_gemfile_dependency_token(
+          package.fetch(:name).to_s
+        ),
         "KJ|CI:EXEC_CMD" => facts.dig(:ci, :exec_cmd).to_s,
         "KJ|GITHUB_ACTIONS:COVERAGE_UPLOAD_STEPS" => github_actions_coverage_steps(disabled_integrations: facts.dig(:integrations, :disabled))
       }.merge(
@@ -13806,6 +13918,30 @@ module Kettle
       tokens.reject { |key, value| value.empty? && !EMPTY_TEMPLATE_TOKENS.include?(key) }
     end
 
+    def kettle_changelog_gemfile_dependency_token(package_name)
+      return "" if package_name == "kettle-changelog"
+
+      <<~RUBY.chomp
+        kettle_changelog_skip = ENV.fetch("KETTLE_DEV_SKIP_CHANGELOG", "false").downcase
+        kettle_changelog_skip = %w[true 1 yes on].include?(kettle_changelog_skip)
+        kettle_changelog_local = ENV.fetch("KETTLE_DEV_DEV", "false").downcase
+        kettle_changelog_local = !%w[false 0 no off].include?(kettle_changelog_local)
+        unless kettle_changelog_skip
+          if kettle_changelog_local
+            require "nomono/bundler"
+            eval_nomono_gems(
+              gems: ["kettle-changelog"],
+              prefix: "KETTLE_DEV",
+              path_env: "KETTLE_DEV_DEV",
+              root: ["src", "my", "kettle-dev"]
+            )
+          elsif Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("4.0.0")
+            gem "kettle-changelog", "~> 1.0", ">= 1.0.2"
+          end
+        end
+      RUBY
+    end
+
     def readme_title_token(package, rubygems)
       package_name = package.fetch(:name).to_s.strip
       default_entrypoint = package_name.tr("-", "/")
@@ -14751,7 +14887,7 @@ module Kettle
     end
 
     def kettle_dev_local_gems(config)
-      gems = %w[kettle-dev kettle-family kettle-test kettle-soup-cover]
+      gems = %w[kettle-dev kettle-family kettle-test kettle-soup-cover kettle-changelog]
       plugin_names = PluginLoader.normalize_plugin_names(plugin_names_from_config(config))
       gems.concat(plugin_names.select { |plugin_name| plugin_name.start_with?("kettle-") })
       gems.uniq.join(" ")
@@ -14760,7 +14896,7 @@ module Kettle
     def main_gemfile_kettle_family_gem(package_name)
       return "" if package_name.to_s == "kettle-family"
 
-      %(gem "kettle-family", "~> 1.2", ">= 1.2.41"\n)
+      %(gem "kettle-family", "~> 1.2", ">= 1.2.51"\n)
     end
 
     def main_gemfile_nomono_bootstrap(package_name)
@@ -15870,8 +16006,10 @@ module Kettle
       topology = normalize_repository_topology(repository_topology)
       monorepo_subproject = topology == REPOSITORY_TOPOLOGY_MONOREPO_SUBPROJECT
       local_root = monorepo_subproject ? git_worktree_root(project_root) : nil
+      repository_root = local_root || project_root
+      git_source_url = git_remote_source_url(repository_root)
       repo_url = if monorepo_subproject
-        repository_root_url(git_remote_source_url(local_root || project_root) || source_url)
+        repository_root_url(git_source_url || source_url)
       else
         repository_root_url(source_url)
       end
@@ -15883,7 +16021,8 @@ module Kettle
         topology: topology,
         url: repo_url,
         name: repo_name,
-        slug: slug
+        slug: slug,
+        star_history: readme_star_history_facts(repository_root, git_source_url)
       )
       return facts unless monorepo_subproject
 
@@ -16030,6 +16169,54 @@ module Kettle
       nil
     end
 
+    def readme_star_history_facts(project_root, git_source_url)
+      repository_slug = github_repository_slug(git_source_url)
+      return {enabled: false, reason: "no_github_remote"} if repository_slug.to_s.empty?
+
+      stars = github_repository_star_count(project_root, repository_slug)
+      unless stars
+        return {
+          enabled: false,
+          repository: repository_slug,
+          reason: "star_count_unavailable"
+        }
+      end
+
+      {
+        enabled: stars >= README_STAR_HISTORY_MIN_STARS,
+        repository: repository_slug,
+        stars: stars,
+        minimum_stars: README_STAR_HISTORY_MIN_STARS
+      }
+    end
+
+    def github_repository_slug(url)
+      normalized = normalize_git_source_url(url)
+      match = normalized.to_s.match(%r{\Ahttps?://github\.com/([^/]+)/([^/?#]+)})
+      return unless match
+
+      repository = match[2].delete_suffix(".git")
+      return if match[1].empty? || repository.empty?
+
+      "#{match[1]}/#{repository}"
+    end
+
+    def github_repository_star_count(project_root, repository_slug)
+      stdout, _stderr, status = Open3.capture3(
+        "gh",
+        "api",
+        "repos/#{repository_slug}",
+        "--jq",
+        ".stargazers_count",
+        chdir: project_root.to_s
+      )
+      return unless status.success?
+
+      Integer(stdout.to_s.strip)
+    rescue ArgumentError, IOError, SystemCallError
+      nil
+    end
+
     def normalize_git_source_url(url)
       value = url.to_s.strip
       return if value.empty?
@@ -16040,6 +16227,11 @@ module Kettle
       end
 
       uri = URI.parse(value)
+      if uri.scheme == "ssh" && uri.host == "github.com"
+        slug = uri.path.to_s.delete_prefix("/").delete_suffix(".git")
+        return "https://github.com/#{slug}" if slug.split("/").length >= 2
+      end
+
       if %w[http https].include?(uri.scheme) && uri.host == "github.com"
         slug = uri.path.to_s.delete_prefix("/").delete_suffix(".git")
         return "https://github.com/#{slug}" if slug.split("/").length >= 2
@@ -17614,7 +17806,7 @@ module Kettle
         relative_path = path.delete_prefix("#{project_root}/")
         next unless preferred_template_source(PACKAGED_TEMPLATE_ROOT, relative_path)
 
-        {target_path: relative_path} if skip_packaged_gemfile_template?(relative_path, config)
+        {target_path: relative_path} if skip_packaged_gemfile_template?(relative_path, config, project_root: project_root)
       end
       (gemfile_cleanups + disabled_integration_config_cleanups(project_root, config)).sort_by { |cleanup| cleanup.fetch(:target_path) }
     end
@@ -17697,7 +17889,7 @@ module Kettle
       return if source_path.to_s.empty? || target_path.to_s.empty?
       return if skip_packaged_workflow_template?(target_path, config, include_patterns: include_patterns)
       return if skip_disabled_integration_template?(target_path, config)
-      return if skip_packaged_gemfile_template?(target_path, config)
+      return if skip_packaged_gemfile_template?(target_path, config, project_root: project_root, template_root_path: template_root.fetch(:path))
       return if skip_packaged_license_template?(target_path, config)
       return if skip_packaged_version_gem_entrypoint_template?(project_root, source_path, target_path, config)
       return if template_root.fetch(:kind) == "packaged" && opencollective_disabled && opencollective_disabled_file?(target_path)
@@ -17933,9 +18125,11 @@ module Kettle
       Gem::Version.new(version) < min_ruby
     end
 
-    def skip_packaged_gemfile_template?(target_path, config)
+    def skip_packaged_gemfile_template?(target_path, config, project_root: nil, template_root_path: PACKAGED_TEMPLATE_ROOT)
       return true if target_path.to_s.include?("gemfiles/modular/recording/") && !appraisal_recording_enabled?(config)
 
+      return false if packaged_gemfile_referenced_by_x_std_libs?(target_path, project_root: project_root, template_root_path: template_root_path)
+
       version = packaged_gemfile_template_ruby_floor(target_path)
       return false unless version
 
@@ -17945,6 +18139,21 @@ module Kettle
       Gem::Version.new(version) < min_ruby
     end
 
+    def packaged_gemfile_referenced_by_x_std_libs?(target_path, project_root:, template_root_path:)
+      relative_path = target_path.to_s.delete_prefix("gemfiles/modular/")
+      return false unless relative_path.start_with?("x_std_libs/")
+
+      aggregate_paths = [
+        File.join(template_root_path.to_s, "gemfiles/modular/x_std_libs.gemfile.example"),
+        File.join(project_root.to_s, "gemfiles/modular/x_std_libs.gemfile")
+      ].select { |path| File.file?(path) }
+      aggregate_paths.any? do |path|
+        gemfile_eval_paths(File.read(path)).include?(relative_path)
+      end
+    rescue
+      false
+    end
+
     def skip_disabled_integration_template?(target_path, config)
       disabled_integration_template_path?(target_path, config)
     end
@@ -19198,9 +19407,9 @@ module Kettle
         "actions/upload-artifact" => "actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1",
         "amancevice/setup-code-climate" => "amancevice/setup-code-climate@0daf2985a225e8ac15975b4d233010e94d65b76a # v2",
         "actions/dependency-review-action" => "actions/dependency-review-action@a1d282b36b6f3519aa1f3fc636f609c47dddb294 # v5.0.0",
-        "github/codeql-action/init" => "github/codeql-action/init@f205ea1c3313d32999d8d6a48b4f6530d4437b38 # v4.37.4",
-        "github/codeql-action/autobuild" => "github/codeql-action/autobuild@f205ea1c3313d32999d8d6a48b4f6530d4437b38 # v4.37.4",
-        "github/codeql-action/analyze" => "github/codeql-action/analyze@f205ea1c3313d32999d8d6a48b4f6530d4437b38 # v4.37.4",
+        "github/codeql-action/init" => "github/codeql-action/init@5595ccaf912efad79be6eef63a5619ff05969be3 # v4.37.6",
+        "github/codeql-action/autobuild" => "github/codeql-action/autobuild@5595ccaf912efad79be6eef63a5619ff05969be3 # v4.37.6",
+        "github/codeql-action/analyze" => "github/codeql-action/analyze@5595ccaf912efad79be6eef63a5619ff05969be3 # v4.37.6",
         "pozil/auto-assign-issue" => "pozil/auto-assign-issue@af6beea6bdf1e8eb373f061c5bc168681fc6d011 # v4.0.1",
         "apache/skywalking-eyes/dependency" => "apache/skywalking-eyes/dependency@61275cc80d0798a405cb070f7d3a8aaf7cf2c2c1 # v0.8.0",
         "sarisia/actions-status-discord" => "sarisia/actions-status-discord@eb045afee445dc055c18d3d90bd0f244fd062708 # v1.16.0"