kettle-dev 1.0.8 → 1.0.10

data/Rakefile

@@ -1,22 +1,8 @@
 # frozen_string_literal: true
 
-# Galtzo FLOSS Rakefile v1.0.11 - 2025-08-19
+# kettle-dev Rakefile v1.0.0 - 2025-08-23
 # Ruby 2.3 (Safe Navigation) or higher required
 #
-# CHANGELOG
-# v1.0.0 - initial release w/ support for rspec, minitest, rubocop, reek, yard, and stone_checksums
-# v1.0.1 - fix test / spec tasks running 2x
-# v1.0.2 - fix duplicate task warning from RuboCop
-# v1.0.3 - add bench tasks to run mini benchmarks (add scripts to /benchmarks)
-# v1.0.4 - add support for floss_funding:install
-# v1.0.5 - add support for halting in Rake tasks with binding.b (from debug gem)
-# v1.0.6 - add RBS files and checksums to YARD-generated docs site
-# v1.0.7 - works with vanilla ruby, non-gem, bundler-managed, projects
-# v1.0.8 - improved Dir globs, add back and document rbconfig dependency
-# v1.0.9 - add appraisal:update task to update Appraisal gemfiles and autocorrect with RuboCop Gradual
-# v1.0.10 - add ci:act to run GHA workflows locally, and get status of remote workflows
-# v1.0.11 - ci:act workflows are populated entirely dynamically, based on existing files
-#
 # MIT License (see License.txt)
 #
 # Copyright (c) 2025 Peter H. Boling (galtzo.com)
@@ -25,38 +11,51 @@
 #
 # Sets up tasks for appraisal, floss_funding, rspec, minitest, rubocop, reek, yard, and stone_checksums.
 #
-# rake appraisal:update                 # Update Appraisal gemfiles and run RuboCop Gradual autocorrect
-# rake bench                            # Run all benchmarks (alias for bench:run)
-# rake bench:list                       # List available benchmark scripts
-# rake bench:run                        # Run all benchmark scripts (skips on CI)
-# rake build                            # Build gitmoji-regex-1.0.2.gem into the pkg directory
-# rake build:checksum                   # Generate SHA512 checksum of gitmoji-regex-1.0.2.gem into the checksums directory
-# rake build:generate_checksums         # Generate both SHA256 & SHA512 checksums into the checksums directory, and git...
-# rake bundle:audit:check               # Checks the Gemfile.lock for insecure dependencies
-# rake bundle:audit:update              # Updates the bundler-audit vulnerability database
-# rake ci:act[opt]                      # Run 'act' with a selected workflow
-# rake clean                            # Remove any temporary products
-# rake clobber                          # Remove any generated files
-# rake coverage                         # Run specs w/ coverage and open results in browser
-# rake floss_funding:install            # (stub) floss_funding is unavailable
-# rake install                          # Build and install gitmoji-regex-1.0.2.gem into system gems
-# rake install:local                    # Build and install gitmoji-regex-1.0.2.gem into system gems without network ac...
-# rake reek                             # Check for code smells
-# rake reek:update                      # Run reek and store the output into the REEK file
-# rake release[remote]                  # Create tag v1.0.2 and build and push gitmoji-regex-1.0.2.gem to rubygems.org
-# rake rubocop                          # alias rubocop task to rubocop_gradual
-# rake rubocop_gradual                  # Run RuboCop Gradual
-# rake rubocop_gradual:autocorrect      # Run RuboCop Gradual with autocorrect (only when it's safe)
-# rake rubocop_gradual:autocorrect_all  # Run RuboCop Gradual with autocorrect (safe and unsafe)
-# rake rubocop_gradual:check            # Run RuboCop Gradual to check the lock file
-# rake rubocop_gradual:force_update     # Run RuboCop Gradual to force update the lock file
-# rake spec                             # Run RSpec code examples
-# rake test                             # Run tests
-# rake yard                             # Generate YARD Documentation
+# rake appraisal:update                       # Update Appraisal gemfiles and run RuboCop...
+# rake bench                                  # Run all benchmarks (alias for bench:run)
+# rake bench:list                             # List available benchmark scripts
+# rake bench:run                              # Run all benchmark scripts (skips on CI)
+# rake build                                  # Build kettle-dev-1.0.0.gem into the pkg d...
+# rake build:checksum                         # Generate SHA512 checksum of kettle-dev-1....
+# rake build:generate_checksums               # Generate both SHA256 & SHA512 checksums i...
+# rake bundle:audit:check                     # Checks the Gemfile.lock for insecure depe...
+# rake bundle:audit:update                    # Updates the bundler-audit vulnerability d...
+# rake ci:act[opt]                            # Run 'act' with a selected workflow
+# rake clean                                  # Remove any temporary products
+# rake clobber                                # Remove any generated files
+# rake coverage                               # Run specs w/ coverage and open results in...
+# rake default                                # Default tasks aggregator
+# rake install                                # Build and install kettle-dev-1.0.0.gem in...
+# rake install:local                          # Build and install kettle-dev-1.0.0.gem in...
+# rake kettle:dev:install                     # Install kettle-dev GitHub automation and ...
+# rake kettle:dev:template                    # Template kettle-dev files into the curren...
+# rake reek                                   # Check for code smells
+# rake reek:update                            # Run reek and store the output into the RE...
+# rake release[remote]                        # Create tag v1.0.0 and build and push kett...
+# rake rubocop_gradual                        # Run RuboCop Gradual
+# rake rubocop_gradual:autocorrect            # Run RuboCop Gradual with autocorrect (onl...
+# rake rubocop_gradual:autocorrect_all        # Run RuboCop Gradual with autocorrect (saf...
+# rake rubocop_gradual:check                  # Run RuboCop Gradual to check the lock file
+# rake rubocop_gradual:force_update           # Run RuboCop Gradual to force update the l...
+# rake rubocop_gradual_debug                  # Run RuboCop Gradual
+# rake rubocop_gradual_debug:autocorrect      # Run RuboCop Gradual with autocorrect (onl...
+# rake rubocop_gradual_debug:autocorrect_all  # Run RuboCop Gradual with autocorrect (saf...
+# rake rubocop_gradual_debug:check            # Run RuboCop Gradual to check the lock file
+# rake rubocop_gradual_debug:force_update     # Run RuboCop Gradual to force update the l...
+# rake spec                                   # Run RSpec code examples
+# rake test                                   # Run tests
+# rake yard                                   # Generate YARD Documentation
+#
 
 # External gems
 require "bundler/gem_tasks" if !Dir[File.join(__dir__, "*.gemspec")].empty?
 
+# Define a base default task early so other files can enhance it.
+desc "Default tasks aggregator"
+task :default do
+  puts "Default task complete."
+end
+
 # Detect if the invoked task is spec/test to avoid eagerly requiring the library,
 # which would load code before SimpleCov can start (when running `rake spec`).
 invoked_tasks = Rake.application.top_level_tasks
@@ -74,22 +73,12 @@ if running_specs
     # If rspec isn't available, let it fail when the task is invoked
   end
 else
-  require "kettle/dev"
-
-  # Define a base default task early so other files can enhance it.
-  desc "Default tasks aggregator"
-  task :default do
-    puts "Default task complete."
-  end
-
-  Kettle::Dev.install_tasks
+  require "kettle-dev"
 
   ### RELEASE TASKS
   # Setup stone_checksums
   begin
     require "stone_checksums"
-
-    GemChecksums.install_tasks
   rescue LoadError
     desc("(stub) build:generate_checksums is unavailable")
     task("build:generate_checksums") do

data/exe/kettle-commit-msg

@@ -1,14 +1,18 @@
 #!/usr/bin/env ruby
-# vim: set syntax=ruby
+# frozen_string_literal: true
 
-ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __dir__)
+# vim: set syntax=ruby
 
-require "rubygems"
+# Immediate, unbuffered output
+$stdout.sync = true
+# Depending library or project must be using bundler
 require "bundler/setup"
 
 # Standard library
 require "erb"
 
+require "kettle/dev"
+
 # ENV variable control (set in .envrc, or .env.local)
 # BRANCH_RULE_TYPE = jira, or another type of branch rule validation, or false to disable
 # FOOTER_APPEND = true/false append commit message footer
@@ -46,140 +50,4 @@ else
   # puts "No branch rule configured (set GIT_HOOK_BRANCH_VALIDATE=jira to enforce rules for jira style branch names)"
 end
 
-class GitCommitFooter
-  # Prefer project-local .git-hooks (repo root), then fallback to global ~/.git-hooks
-  NAME_ASSIGNMENT_REGEX = /\bname\s*=\s*(["'])([^"']+)\1/.freeze
-  FOOTER_APPEND = ENV.fetch("GIT_HOOK_FOOTER_APPEND", "false").casecmp("true").zero?
-  SENTINEL = ENV["GIT_HOOK_FOOTER_SENTINEL"] # No default to avoid accidental duplicate commit of a footer via ammended commits
-  raise "Set GIT_HOOK_FOOTER_SENTINEL=<footer sentinel> in .env.local (e.g., '⚡️ A message from a fellow meat-based-AI ⚡️')" if FOOTER_APPEND && SENTINEL.nil? || SENTINEL.empty?
-
-  class << self
-    def git_toplevel
-      toplevel = nil
-      begin
-        # 'git rev-parse --show-toplevel' returns the repo root when run anywhere inside the repo
-        out = %x(git rev-parse --show-toplevel 2>/dev/null)
-        toplevel = out.strip unless out.nil? || out.empty?
-      rescue StandardError
-        # ignore
-      end
-      toplevel
-    end
-
-    def local_hooks_dir
-      top = git_toplevel
-      return unless top && !top.empty?
-      File.join(top, ".git-hooks")
-    end
-
-    def global_hooks_dir
-      File.join(ENV["HOME"], ".git-hooks")
-    end
-
-    def hooks_path_for(filename)
-      local_dir = local_hooks_dir
-      if local_dir
-        local_path = File.join(local_dir, filename)
-        return local_path if File.file?(local_path)
-      end
-      File.join(global_hooks_dir, filename)
-    end
-
-    def commit_goalie_path
-      hooks_path_for("commit-subjects-goalie.txt")
-    end
-
-    # Determine whether the commit subject allows footer append, based on optional goalie file
-    # ~/.git-hooks/commit-subjects-goalie.txt
-    # - If present, only allow appending when the first line of the commit message starts with one of the non-commented prefixes
-    # - If absent, disallow footer
-    def goalie_allows_footer?(subject_line)
-      goalie_path = commit_goalie_path
-      return false unless File.file?(goalie_path)
-
-      prefixes = File.read(goalie_path).lines.map { |l| l.strip }.reject { |l| l.empty? || l.start_with?("#") }
-      # If the file exists but has no usable lines, treat as deny-all per goalie intent
-      return false if prefixes.empty?
-
-      subj = subject_line.to_s.strip
-      prefixes.any? { |prefix| subj.start_with?(prefix) }
-    end
-
-    def render(*argv)
-      commit_msg = File.read(argv[0])
-      subject_line = commit_msg.lines.first.to_s
-      if GitCommitFooter::FOOTER_APPEND && goalie_allows_footer?(subject_line)
-        if commit_msg.include?(GitCommitFooter::SENTINEL)
-          # This is a commit message that has already been appended
-          # This will happen if the commit message is edited and re-committed
-          # puts "FOOTER_APPEND is true, skipping footer append"
-          exit(0)
-        else
-          footer_binding = GitCommitFooter.new
-          # Append footer to the commit message
-          File.open(argv[0], "w") do |file|
-            file.print(commit_msg)
-            file.print("\n")
-            file.print(footer_binding.render)
-          end
-        end
-      else
-        # Skipping footer append (either FOOTER_APPEND is false, or goalie did not allow it)
-      end
-    end
-  end
-
-  def initialize
-    @pwd = Dir.pwd
-    @gemspecs = Dir["*.gemspec"]
-    @spec = @gemspecs.first
-    @gemspec_path = File.expand_path(@spec, @pwd)
-    @gem_name = parse_gemspec_name || derive_gem_name
-  end
-
-  # Render ERB with binding variables
-  def render
-    ERB.new(template).result(binding)
-  end
-
-  private
-
-  # Lightweight parse for gem name to avoid full Gem::Specification load
-  def parse_gemspec_name
-    begin
-      content = File.read(@gemspec_path)
-      # Look for name assignment patterns like:
-      #   spec.name = "my_gem" OR Gem::Specification.new do |spec|; spec.name = 'my_gem'
-      @name_index = content =~ NAME_ASSIGNMENT_REGEX
-      if @name_index
-        return $2
-      end
-    rescue StandardError
-      # fall through
-    end
-    nil
-  end
-
-  # No-parse derivation of gem name, when parsing gemspec fails
-  def derive_gem_name
-    File.basename(@gemspec_path, ".*") if @gemspec_path
-  end
-
-  # Example
-  #
-  #     ⚡️ A message from a fellow meat-based-AI ⚡️
-  #     I ❤️ working on <%= @gem_name %>.
-  #
-  # The first line is the footer sentinel (which does appear in the commit).
-  # The second line, and any additional, is the main body of the footer.
-  #
-  # The sentinel must be set in an ENV variable (e.g., in your .env.local file):
-  #
-  #   export GIT_HOOK_FOOTER_SENTINEL="⚡️ A message from a fellow meat-based-AI ⚡️"
-  #
-  def template
-    File.read(self.class.hooks_path_for("footer-template.erb.txt"))
-  end
-end
-
-GitCommitFooter.render(*ARGV)
+Kettle::Dev::GitCommitFooter.render(*ARGV)

data/exe/kettle-readme-backers

@@ -1,355 +1,13 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-# Updates README.md backers and sponsors sections using data from Open Collective
-# backers.json and sponsors.json for the configured handle.
-#
-# Backers (individuals) section markers supported (first match wins):
-#   <!-- OPENCOLLECTIVE:START --> ... <!-- OPENCOLLECTIVE:END -->
-#   <!-- OPENCOLLECTIVE-INDIVIDUALS:START --> ... <!-- OPENCOLLECTIVE-INDIVIDUALS:END -->
-# Sponsors (organizations) section markers:
-#   <!-- OPENCOLLECTIVE-ORGANIZATIONS:START --> ... <!-- OPENCOLLECTIVE-ORGANIZATIONS:END -->
-#
-# Handle resolution order:
-#   1. ENV["OPENCOLLECTIVE_HANDLE"] if present
-#   2. .opencollective.yml's `collective:` key in project root if present
-#   3. Abort with error
-#
-# Usage:
-#   OPENCOLLECTIVE_HANDLE=kettle-rb exe/kettle-readme-backers
-#   # or ensure .opencollective.yml exists with collective: "kettle-rb"
+# vim: set syntax=ruby
 
-require "rubygems"
+# Immediate, unbuffered output
+$stdout.sync = true
+# Ensure bundler is set up by the host project
 require "bundler/setup"
 
-require "yaml"
-require "json"
-require "uri"
-require "net/http"
-require "set"
+require "kettle/dev"
 
-module Kettle
-  module Dev
-    class ReadmeBackers
-      DEFAULT_AVATAR = "https://opencollective.com/static/images/default-avatar.png"
-      README_PATH = File.expand_path("../README.md", __dir__)
-      OC_YML_PATH = File.expand_path("../.opencollective.yml", __dir__)
-      README_OSC_TAG_DEFAULT = "OPENCOLLECTIVE"
-      COMMIT_SUBJECT_DEFAULT = "💸 Thanks 🙏 to our new backers 🎒 and subscribers 📜"
-
-      Backer = Struct.new(:name, :image, :website, :profile, keyword_init: true)
-
-      def initialize(handle: nil, readme_path: README_PATH)
-        @handle = handle || resolve_handle
-        @readme_path = readme_path
-      end
-
-      def run!
-        readme = File.read(@readme_path)
-
-        # Identify previous entries for diffing/mentions
-        b_start, b_end = detect_backer_tags(readme)
-        prev_backer_identities = extract_section_identities(readme, b_start, b_end)
-        s_start_prev, s_end_prev = detect_sponsor_tags(readme)
-        prev_sponsor_identities = extract_section_identities(readme, s_start_prev, s_end_prev)
-
-        # Backers (individuals)
-        backers = fetch_members("backers.json")
-        backers_md = generate_markdown(backers, empty_message: "No backers yet. Be the first!", default_name: "Backer")
-        updated = replace_between_tags(readme, b_start, b_end, backers_md)
-        case updated
-        when :not_found
-          # Do not exit yet; we may still update sponsors.
-          updated_readme = readme
-          backers_changed = false
-          new_backers = []
-        when :no_change
-          updated_readme = readme
-          backers_changed = false
-          new_backers = []
-        else
-          updated_readme = updated
-          backers_changed = true
-          new_backers = compute_new_members(prev_backer_identities, backers)
-        end
-
-        # Sponsors (organizations)
-        sponsors = fetch_members("sponsors.json")
-        sponsors_md = generate_markdown(sponsors, empty_message: "No sponsors yet. Be the first!", default_name: "Sponsor")
-        s_start, s_end = detect_sponsor_tags(updated_readme)
-        updated2 = replace_between_tags(updated_readme, s_start, s_end, sponsors_md)
-        case updated2
-        when :not_found
-          sponsors_changed = false
-          final = updated_readme
-          new_sponsors = []
-        when :no_change
-          sponsors_changed = false
-          final = updated_readme
-          new_sponsors = []
-        else
-          sponsors_changed = true
-          final = updated2
-          new_sponsors = compute_new_members(prev_sponsor_identities, sponsors)
-        end
-
-        if !backers_changed && !sponsors_changed
-          if b_start == :not_found && s_start == :not_found
-            ts = tag_strings
-            warn("No recognized Open Collective tags found in #{@readme_path}. Expected one or more of: " \
-              "#{ts[:generic_start]}/#{ts[:generic_end]}, #{ts[:individuals_start]}/#{ts[:individuals_end]}, #{ts[:orgs_start]}/#{ts[:orgs_end]}.")
-            exit(2)
-          end
-          puts "No changes to backers or sponsors sections in #{@readme_path}."
-          return
-        end
-
-        File.write(@readme_path, final)
-        msgs = []
-        msgs << "backers" if backers_changed
-        msgs << "sponsors" if sponsors_changed
-        puts "Updated #{msgs.join(" and ")} section#{{true => "s", false => ""}[msgs.size > 1]} in #{@readme_path}."
-
-        # Compose and perform commit with mentions if in a git repo
-        perform_git_commit(new_backers, new_sponsors) if git_repo? && (backers_changed || sponsors_changed)
-      end
-
-      private
-
-      def readme_osc_tag
-        env = ENV["KETTLE_DEV_BACKER_README_OSC_TAG"].to_s
-        return env unless env.strip.empty?
-        if File.file?(OC_YML_PATH)
-          begin
-            yml = YAML.safe_load(File.read(OC_YML_PATH))
-            if yml.is_a?(Hash)
-              from_yml = yml["readme-osc-tag"] || yml[:"readme-osc-tag"]
-              from_yml = from_yml.to_s if from_yml
-              return from_yml unless from_yml.nil? || from_yml.strip.empty?
-            end
-          rescue StandardError
-            # ignore yaml errors and fall back
-          end
-        end
-        README_OSC_TAG_DEFAULT
-      end
-
-      def tag_strings
-        base = readme_osc_tag
-        {
-          generic_start: "<!-- #{base}:START -->",
-          generic_end: "<!-- #{base}:END -->",
-          individuals_start: "<!-- #{base}-INDIVIDUALS:START -->",
-          individuals_end: "<!-- #{base}-INDIVIDUALS:END -->",
-          orgs_start: "<!-- #{base}-ORGANIZATIONS:START -->",
-          orgs_end: "<!-- #{base}-ORGANIZATIONS:END -->",
-        }
-      end
-
-      def resolve_handle
-        env = ENV["OPENCOLLECTIVE_HANDLE"]
-        return env unless env.nil? || env.strip.empty?
-        if File.file?(OC_YML_PATH)
-          yml = YAML.safe_load(File.read(OC_YML_PATH))
-          handle = yml.is_a?(Hash) ? yml["collective"] || yml[:collective] : nil
-          return handle.to_s unless handle.nil? || handle.to_s.strip.empty?
-        end
-        abort("ERROR: Open Collective handle not provided. Set OPENCOLLECTIVE_HANDLE or add 'collective: <handle>' to .opencollective.yml.")
-      end
-
-      def fetch_members(path)
-        url = URI("https://opencollective.com/#{@handle}/#{path}")
-        response = Net::HTTP.start(url.host, url.port, use_ssl: url.scheme == "https") do |conn|
-          conn.read_timeout = 10
-          conn.open_timeout = 5
-          req = Net::HTTP::Get.new(url)
-          req["User-Agent"] = "kettle-dev/README-backers"
-          conn.request(req)
-        end
-        return [] unless response.is_a?(Net::HTTPSuccess)
-        parsed = JSON.parse(response.body)
-        Array(parsed).map do |h|
-          Backer.new(
-            name: h["name"],
-            image: (h["image"].to_s.strip.empty? ? nil : h["image"]),
-            website: (h["website"].to_s.strip.empty? ? nil : h["website"]),
-            profile: (h["profile"].to_s.strip.empty? ? nil : h["profile"]),
-          )
-        end
-      rescue JSON::ParserError => e
-        warn("Error parsing #{path} JSON: #{e.message}")
-        []
-      rescue StandardError => e
-        warn("Error fetching #{path}: #{e.class}: #{e.message}")
-        []
-      end
-
-      def generate_markdown(members, empty_message:, default_name:)
-        return empty_message if members.nil? || members.empty?
-        members.map do |m|
-          image_url = m.image || DEFAULT_AVATAR
-          link = m.website || m.profile || "#"
-          name = (m.name && !m.name.strip.empty?) ? m.name : default_name
-          "[![#{escape_text(name)}](#{image_url})](#{link})"
-        end.join(" ")
-      end
-
-      def replace_between_tags(content, start_tag, end_tag, new_content)
-        return :not_found if start_tag == :not_found || end_tag == :not_found
-        start_index = content.index(start_tag)
-        end_index = content.index(end_tag)
-        return :not_found if start_index.nil? || end_index.nil? || end_index < start_index
-        before = content[0..start_index + start_tag.length - 1]
-        after = content[end_index..-1]
-        replacement = "#{start_tag}\n#{new_content}\n#{end_tag}"
-        current_block = content[start_index..end_index + end_tag.length - 1]
-        return :no_change if current_block == replacement
-        trailing = after[end_tag.length..-1] || ""
-        "#{before}\n#{new_content}\n#{end_tag}#{trailing}"
-      end
-
-      def detect_backer_tags(content)
-        ts = tag_strings
-        if content.include?(ts[:generic_start]) && content.include?(ts[:generic_end])
-          [ts[:generic_start], ts[:generic_end]]
-        elsif content.include?(ts[:individuals_start]) && content.include?(ts[:individuals_end])
-          [ts[:individuals_start], ts[:individuals_end]]
-        else
-          [:not_found, :not_found]
-        end
-      end
-
-      def detect_sponsor_tags(content)
-        ts = tag_strings
-        if content.include?(ts[:orgs_start]) && content.include?(ts[:orgs_end])
-          [ts[:orgs_start], ts[:orgs_end]]
-        else
-          [:not_found, :not_found]
-        end
-      end
-
-      # Extract identity tokens from the current README section between start/end tags
-      # Identity priority used for comparison:
-      #   href (profile/website URL) downcased, else alt text (name) downcased
-      def extract_section_identities(content, start_tag, end_tag)
-        return Set.new unless start_tag && end_tag && start_tag != :not_found && end_tag != :not_found
-        start_index = content.index(start_tag)
-        end_index = content.index(end_tag)
-        return Set.new if start_index.nil? || end_index.nil? || end_index < start_index
-        block = content[(start_index + start_tag.length)...end_index]
-        identities = Set.new
-        # Match patterns like: [![Alt](image_url)](link_url)
-        block.to_s.scan(/\[!\[[^\]]*\]\([^\)]*\)\]\(([^\)]+)\)/) do |m|
-          href = (m[0] || "").strip
-          identities << href.downcase unless href.empty?
-        end
-        # Also capture alt texts in case links are missing
-        block.to_s.scan(/\[!\[([^\]]*)\]\([^\)]*\)\]\([^\)]*\)/) do |m|
-          alt = (m[0] || "").strip
-          identities << alt.downcase unless alt.empty?
-        end
-        identities
-      end
-
-      def compute_new_members(previous_identities, members)
-        prev = previous_identities || Set.new
-        members.select do |m|
-          id = identity_for_member(m)
-          !prev.include?(id)
-        end
-      end
-
-      def identity_for_member(m)
-        if m.profile && !m.profile.strip.empty?
-          m.profile.strip.downcase
-        elsif m.website && !m.website.strip.empty?
-          m.website.strip.downcase
-        elsif m.name && !m.name.strip.empty?
-          m.name.strip.downcase
-        else
-          ""
-        end
-      end
-
-      def mention_for_member(m, default_name: "Member")
-        handle = github_handle_from_urls(m.profile, m.website)
-        return "@#{handle}" if handle
-        name = (m.name && !m.name.strip.empty?) ? m.name.strip : default_name
-        name
-      end
-
-      def github_handle_from_urls(*urls)
-        urls.compact.each do |u|
-          begin
-            uri = URI.parse(u)
-          rescue URI::InvalidURIError
-            next
-          end
-          next unless uri&.host&.downcase&.end_with?("github.com")
-          path = (uri.path || "").sub(%r{^/}, "").sub(%r{/$}, "")
-          next if path.empty?
-          parts = path.split("/")
-          # github.com/sponsors/<handle> or github.com/<handle>/...
-          candidate = if parts[0].downcase == "sponsors" && parts[1]
-            parts[1]
-          else
-            parts[0]
-          end
-          candidate = candidate.gsub(%r{[^a-zA-Z0-9-]}, "")
-          return candidate unless candidate.empty?
-        end
-        nil
-      end
-
-      def perform_git_commit(new_backers, new_sponsors)
-        backer_mentions = new_backers.map { |m| mention_for_member(m, default_name: "Backer") }.uniq
-        sponsor_mentions = new_sponsors.map { |m| mention_for_member(m, default_name: "Subscriber") }.uniq
-        title = commit_subject
-        lines = [title]
-        lines << ""
-        lines << "Backers: #{backer_mentions.join(", ")}" unless backer_mentions.empty?
-        lines << "Subscribers: #{sponsor_mentions.join(", ")}" unless sponsor_mentions.empty?
-        message = lines.join("\n")
-        # Stage and commit README.md
-        system("git", "add", @readme_path)
-        # Only commit if README is staged/changed
-        if system("git", "diff", "--cached", "--quiet")
-          # nothing staged; skip commit
-          return
-        end
-        system("git", "commit", "-m", message)
-      end
-
-      def commit_subject
-        env = ENV["KETTLE_README_BACKERS_COMMIT_SUBJECT"].to_s
-        return env unless env.strip.empty?
-        # Fallback to .opencollective.yml key: readme-backers-commit-subject
-        if File.file?(OC_YML_PATH)
-          begin
-            yml = YAML.safe_load(File.read(OC_YML_PATH))
-            if yml.is_a?(Hash)
-              from_yml = yml["readme-backers-commit-subject"] || yml[:"readme-backers-commit-subject"]
-              from_yml = from_yml.to_s if from_yml
-              return from_yml unless from_yml.nil? || from_yml.strip.empty?
-            end
-          rescue StandardError
-            # ignore yaml read errors and fall back to default
-          end
-        end
-        COMMIT_SUBJECT_DEFAULT
-      end
-
-      def git_repo?
-        system("git", "rev-parse", "--is-inside-work-tree", out: File::NULL, err: File::NULL)
-      end
-
-      def escape_text(text)
-        text.gsub("[", "\\[").gsub("]", "\\]")
-      end
-    end
-  end
-end
-
-if __FILE__ == $PROGRAM_NAME
-  Kettle::Dev::ReadmeBackers.new.run!
-end
+Kettle::Dev::ReadmeBackers.new.run!