kettle-dev 1.0.8 → 1.0.10

data/lib/kettle/dev/git_adapter.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Kettle
+  module Dev
+    # Minimal Git adapter used by kettle-dev to avoid invoking live shell commands
+    # directly from the library code. In tests, mock this adapter's methods to
+    # prevent any real network or repository mutations.
+    #
+    # This adapter requires the 'git' gem at runtime and does not shell out to
+    # the system git. Specs should stub the git gem API to avoid real pushes.
+    #
+    # Public API is intentionally small and only includes what we need right now.
+    class GitAdapter
+      # Create a new adapter rooted at the current working directory.
+      # @return [void]
+      def initialize
+        begin
+          require "git"
+          @git = ::Git.open(Dir.pwd)
+        rescue LoadError
+          raise Kettle::Dev::Error, "The 'git' gem is required at runtime. Please add it as a dependency."
+        rescue StandardError => e
+          raise Kettle::Dev::Error, "Failed to open git repository: #{e.message}"
+        end
+      end
+
+      # Push a branch to a remote.
+      # @param remote [String, nil] remote name (nil means default remote)
+      # @param branch [String] branch name (required)
+      # @param force [Boolean] whether to force push
+      # @return [Boolean] true when the push is reported successful
+      def push(remote, branch, force: false)
+        # git gem supports force: true option on push
+        begin
+          if remote
+            @git.push(remote, branch, force: force)
+          else
+            # Default remote according to repo config
+            @git.push(nil, branch, force: force)
+          end
+          true
+        rescue StandardError
+          false
+        end
+      end
+
+      # @return [String, nil] current branch name, or nil on error
+      def current_branch
+        @git.current_branch
+      rescue StandardError
+        nil
+      end
+
+      # @return [Array<String>] list of remote names
+      def remotes
+        @git.remotes.map(&:name)
+      rescue StandardError
+        []
+      end
+
+      # @return [Hash{String=>String}] remote name => fetch URL
+      def remotes_with_urls
+        @git.remotes.each_with_object({}) do |r, h|
+          begin
+            h[r.name] = r.url
+          rescue StandardError
+            # ignore
+          end
+        end
+      rescue StandardError
+        {}
+      end
+
+      # @param name [String]
+      # @return [String, nil]
+      def remote_url(name)
+        r = @git.remotes.find { |x| x.name == name }
+        r&.url
+      rescue StandardError
+        nil
+      end
+
+      # Checkout the given branch
+      # @param branch [String]
+      # @return [Boolean]
+      def checkout(branch)
+        @git.checkout(branch)
+        true
+      rescue StandardError
+        false
+      end
+
+      # Pull from a remote/branch
+      # @param remote [String]
+      # @param branch [String]
+      # @return [Boolean]
+      def pull(remote, branch)
+        @git.pull(remote, branch)
+        true
+      rescue StandardError
+        false
+      end
+
+      # Fetch a ref from a remote (or everything if ref is nil)
+      # @param remote [String]
+      # @param ref [String, nil]
+      # @return [Boolean]
+      def fetch(remote, ref = nil)
+        if ref
+          @git.fetch(remote, ref)
+        else
+          @git.fetch(remote)
+        end
+        true
+      rescue StandardError
+        false
+      end
+    end
+  end
+end

data/lib/kettle/dev/git_commit_footer.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+# Exposed from lib/ so that exe/kettle-commit-msg can be a minimal wrapper.
+
+module Kettle
+  module Dev
+    class GitCommitFooter
+      # Regex to extract `name = "value"` assignments from a gemspec.
+      # @return [Regexp]
+      NAME_ASSIGNMENT_REGEX = /\bname\s*=\s*(["'])([^"']+)\1/.freeze
+
+      # Whether footer appending is enabled (via GIT_HOOK_FOOTER_APPEND=true)
+      # @return [Boolean]
+      FOOTER_APPEND = ENV.fetch("GIT_HOOK_FOOTER_APPEND", "false").casecmp("true").zero?
+      # The sentinel string that must be present to avoid duplicate footers
+      # @return [String, nil]
+      SENTINEL = ENV["GIT_HOOK_FOOTER_SENTINEL"]
+
+      class << self
+        # Resolve git repository top-level dir, or nil outside a repo.
+        # @return [String, nil]
+        def git_toplevel
+          toplevel = nil
+          begin
+            out = %x(git rev-parse --show-toplevel 2>/dev/null)
+            toplevel = out.strip unless out.nil? || out.empty?
+          rescue StandardError
+          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
+
+        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?("#") }
+          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
+
+          # Evaluate configuration at runtime to respect ENV set during tests/CI
+          footer_append = ENV.fetch("GIT_HOOK_FOOTER_APPEND", "false").casecmp("true").zero?
+          sentinel = ENV["GIT_HOOK_FOOTER_SENTINEL"]
+
+          if footer_append && (sentinel.nil? || sentinel.to_s.empty?)
+            raise "Set GIT_HOOK_FOOTER_SENTINEL=<footer sentinel> in .env.local (e.g., '⚡️ A message from a fellow meat-based-AI ⚡️')"
+          end
+
+          if footer_append && goalie_allows_footer?(subject_line)
+            if commit_msg.include?(sentinel)
+              exit(0)
+            else
+              footer_binding = GitCommitFooter.new
+              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
+          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
+
+      def render
+        ERB.new(template).result(binding)
+      end
+
+      private
+
+      def parse_gemspec_name
+        begin
+          content = File.read(@gemspec_path)
+          @name_index = content =~ NAME_ASSIGNMENT_REGEX
+          if @name_index
+            return $2
+          end
+        rescue StandardError
+        end
+        nil
+      end
+
+      def derive_gem_name
+        File.basename(@gemspec_path, ".*") if @gemspec_path
+      end
+
+      def template
+        File.read(self.class.hooks_path_for("footer-template.erb.txt"))
+      end
+    end
+  end
+end

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

@@ -1,9 +1,4 @@
-begin
-  require "bundler"
-rescue LoadError
-  warn("[kettle-dev][appraisal.rake] failed to load bundler") if Kettle::Dev::DEBUGGING
-  # ok, might still work
-end
+# frozen_string_literal: true
 
 # --- Appraisals (dev-only) ---
 begin
@@ -16,15 +11,19 @@ begin
     run_in_unbundled = proc do
       env = {"BUNDLE_GEMFILE" => "Appraisal.root.gemfile"}
 
-      # 1) BUNDLE_GEMFILE=Appraisal.root.gemfile bundle
+      # 1) BUNDLE_GEMFILE=Appraisal.root.gemfile bundle update --bundler
+      ok = system(env, bundle, "update", "--bundler")
+      abort("appraisal:update failed: bundle update --bundler under Appraisal.root.gemfile") unless ok
+
+      # 2) BUNDLE_GEMFILE=Appraisal.root.gemfile bundle (install)
       ok = system(env, bundle)
       abort("appraisal:update failed: bundler install under Appraisal.root.gemfile") unless ok
 
-      # 2) BUNDLE_GEMFILE=Appraisal.root.gemfile bundle exec appraisal update
+      # 3) BUNDLE_GEMFILE=Appraisal.root.gemfile bundle exec appraisal update
       ok = system(env, bundle, "exec", "appraisal", "update")
       abort("appraisal:update failed: bundle exec appraisal update") unless ok
 
-      # 3) bundle exec rake rubocop_gradual:autocorrect
+      # 4) bundle exec rake rubocop_gradual:autocorrect
       ok = system(bundle, "exec", "rake", "rubocop_gradual:autocorrect")
       abort("appraisal:update failed: rubocop_gradual:autocorrect") unless ok
     end

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

@@ -1,11 +1,6 @@
-require "rbconfig" if !Dir[File.join(__dir__, "benchmarks")].empty? # Used by `rake bench:run`
+# frozen_string_literal: true
 
-begin
-  require "bundler"
-rescue LoadError
-  warn("[kettle-dev][bench.rake] failed to load bundler") if Kettle::Dev::DEBUGGING
-  # ok, might still work
-end
+require "rbconfig" if !Dir[File.join(__dir__, "benchmarks")].empty? # Used by `rake bench:run`
 
 # --- Benchmarks (dev-only) ---
 namespace :bench do

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Setup Bundle Audit
 begin
   require "bundler/audit/task"

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

@@ -1,348 +1,9 @@
+# frozen_string_literal: true
+
 # --- CI helpers ---
 namespace :ci do
-  # rubocop:disable ThreadSafety/NewThread
-  desc "Run 'act' with a selected workflow. Usage: rake ci:act[loc] (short code = first 3 letters of filename, e.g., 'loc' => locked_deps.yml), rake ci:act[locked_deps], rake ci:act[locked_deps.yml], or rake ci:act (then choose)"
+  desc "Run 'act' with a selected workflow. Usage: rake ci:act[loc], ci:act[locked_deps], ci:act[locked_deps.yml], or rake ci:act (interactive)"
   task :act, [:opt] do |_t, args|
-    require "io/console"
-    require "open3"
-    require "net/http"
-    require "json"
-    require "uri"
-    require "kettle/dev/ci_helpers"
-
-    # Build mapping dynamically from workflow files; short code = first three letters of filename.
-    # Collisions are resolved by first-come wins via ||= as requested.
-    mapping = {}
-
-    # Normalize provided option. Accept either short code or the exact yml/yaml filename
-    choice = args[:opt]&.strip
-    root_dir = Kettle::Dev::CIHelpers.project_root
-    workflows_dir = File.join(root_dir, ".github", "workflows")
-
-    # Determine actual workflow files present, and prepare dynamic additions excluding specified files.
-    existing_files = if Dir.exist?(workflows_dir)
-      Dir[File.join(workflows_dir, "*.yml")] + Dir[File.join(workflows_dir, "*.yaml")]
-    else
-      []
-    end
-    existing_basenames = existing_files.map { |p| File.basename(p) }
-
-    # Build short-code mapping (first 3 chars of filename stem), excluding some maintenance workflows.
-    exclusions = Kettle::Dev::CIHelpers.exclusions
-    candidate_files = existing_basenames.uniq - exclusions
-    candidate_files.sort.each do |fname|
-      stem = fname.sub(/\.(ya?ml)\z/, "")
-      code = stem[0, 3].to_s.downcase
-      next if code.empty?
-      mapping[code] ||= fname # first-come wins on collisions
-    end
-
-    # Any remaining candidates that didn't get a unique shortcode are treated as dynamic (number-only) options
-    dynamic_files = candidate_files - mapping.values
-
-    # For internal status tracking and rendering, we use a display_code_for hash.
-    # For mapped (short-code) entries, display_code is the short code.
-    # For dynamic entries, display_code is empty string, but we key statuses by a unique code = the filename.
-    display_code_for = {}
-    mapping.keys.each { |k| display_code_for[k] = k }
-    dynamic_files.each { |f| display_code_for[f] = "" }
-
-    # Helpers
-    get_branch = proc do
-      out, status = Open3.capture2("git", "rev-parse", "--abbrev-ref", "HEAD")
-      status.success? ? out.strip : nil
-    end
-
-    get_origin = proc do
-      out, status = Open3.capture2("git", "config", "--get", "remote.origin.url")
-      next nil unless status.success?
-      url = out.strip
-      # Support ssh and https URLs
-      if url =~ %r{git@github.com:(.+?)/(.+?)(\.git)?$}
-        [$1, $2.sub(/\.git\z/, "")]
-      elsif url =~ %r{https://github.com/(.+?)/(.+?)(\.git)?$}
-        [$1, $2.sub(/\.git\z/, "")]
-      end
-    end
-
-    status_emoji = proc do |status, conclusion|
-      case status
-      when "queued"
-        "⏳️"
-      when "in_progress"
-        "👟"
-      when "completed"
-        (conclusion == "success") ? "✅" : "🍅"
-      else
-        "⏳️"
-      end
-    end
-
-    fetch_and_print_status = proc do |workflow_file|
-      branch = get_branch.call
-      org_repo = get_origin.call
-      unless branch && org_repo
-        puts "GHA status: (skipped; missing git branch or remote)"
-        next
-      end
-      owner, repo = org_repo
-      uri = URI("https://api.github.com/repos/#{owner}/#{repo}/actions/workflows/#{workflow_file}/runs?branch=#{URI.encode_www_form_component(branch)}&per_page=1")
-      req = Net::HTTP::Get.new(uri)
-      req["User-Agent"] = "ci:act rake task"
-      token = ENV["GITHUB_TOKEN"] || ENV["GH_TOKEN"]
-      req["Authorization"] = "token #{token}" if token && !token.empty?
-
-      begin
-        res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
-        if res.is_a?(Net::HTTPSuccess)
-          data = JSON.parse(res.body)
-          run = data["workflow_runs"]&.first
-          if run
-            status = run["status"]
-            conclusion = run["conclusion"]
-            emoji = status_emoji.call(status, conclusion)
-            details = [status, conclusion].compact.join("/")
-            puts "Latest GHA (#{branch}) for #{workflow_file}: #{emoji} (#{details})"
-          else
-            puts "Latest GHA (#{branch}) for #{workflow_file}: none"
-          end
-        else
-          puts "GHA status: request failed (#{res.code})"
-        end
-      rescue StandardError => e
-        puts "GHA status: error #{e.class}: #{e.message}"
-      end
-    end
-
-    def run_act_for(file_path)
-      # Prefer array form to avoid shell escaping issues
-      ok = system("act", "-W", file_path)
-      abort("ci:act failed: 'act' command not found or exited with failure") unless ok
-    end
-
-    def process_success_response(res, c, f, old = nil, current = nil)
-      data = JSON.parse(res.body)
-      run = data["workflow_runs"]&.first
-      append = (old && current) ? " (update git remote: #{old} → #{current})" : ""
-      if run
-        st = run["status"]
-        con = run["conclusion"]
-        emoji = case st
-        when "queued" then "⏳️"
-        when "in_progress" then "👟"
-        when "completed" then ((con == "success") ? "✅" : "🍅")
-        else "⏳️"
-        end
-        details = [st, con].compact.join("/")
-        [c, f, "#{emoji} (#{details})#{append}"]
-      else
-        [c, f, "none#{append}"]
-      end
-    end
-
-    if choice && !choice.empty?
-      # If user passed a filename directly (with or without extension), resolve it
-      file = if mapping.key?(choice)
-        mapping.fetch(choice)
-      elsif !!(/\.(yml|yaml)\z/ =~ choice)
-        # Accept either full basename (without ext) or basename with .yml/.yaml
-        choice
-      else
-        cand_yml = File.join(workflows_dir, "#{choice}.yml")
-        cand_yaml = File.join(workflows_dir, "#{choice}.yaml")
-        if File.file?(cand_yml)
-          "#{choice}.yml"
-        elsif File.file?(cand_yaml)
-          "#{choice}.yaml"
-        else
-          # Fall back to .yml for error messaging; will fail below
-          "#{choice}.yml"
-        end
-      end
-      file_path = File.join(workflows_dir, file)
-      unless File.file?(file_path)
-        puts "Unknown option or missing workflow file: #{choice} -> #{file}"
-        puts "Available options:"
-        mapping.each { |k, v| puts "  #{k.ljust(3)} => #{v}" }
-        # Also display dynamically discovered files
-        unless dynamic_files.empty?
-          puts "  (others) =>"
-          dynamic_files.each { |v| puts "        #{v}" }
-        end
-        abort("ci:act aborted")
-      end
-      fetch_and_print_status.call(file)
-      run_act_for(file_path)
-      next
-    end
-
-    # No option provided: interactive menu with live GHA statuses via Threads (no Ractors)
-    require "thread"
-
-    tty = $stdout.tty?
-    # Build options: first the filtered short-code mapping, then dynamic files (no short codes)
-    options = mapping.to_a + dynamic_files.map { |f| [f, f] }
-
-    # Add a Quit choice
-    quit_code = "q"
-    options_with_quit = options + [[quit_code, "(quit)"]]
-
-    idx_by_code = {}
-    options_with_quit.each_with_index { |(k, _v), i| idx_by_code[k] = i }
-
-    # Determine repo context once
-    branch = get_branch.call
-    org = get_origin.call
-    owner, repo = org if org
-    token = ENV["GITHUB_TOKEN"] || ENV["GH_TOKEN"]
-
-    puts "Select a workflow to run with 'act':"
-
-    # Render initial menu with placeholder statuses
-    placeholder = "[…]"
-    options_with_quit.each_with_index do |(k, v), idx|
-      status_col = (k == quit_code) ? "" : placeholder
-      disp = (k == quit_code) ? k : display_code_for[k]
-      line = format("%2d) %-3s => %-20s %s", idx + 1, disp, v, status_col)
-      puts line
-    end
-
-    puts "(Fetching latest GHA status for branch #{branch || "n/a"} — you can type your choice and press Enter)"
-    prompt = "Enter number or code (or 'q' to quit): "
-    print prompt
-    $stdout.flush
-
-    # Thread + Queue to read user input
-    input_q = Queue.new
-    input_thread = Thread.new do
-      line = $stdin.gets&.strip
-      input_q << line
-    end
-
-    # Worker threads to fetch statuses and stream updates as they complete
-    status_q = Queue.new
-    workers = []
-
-    # Capture a monotonic start time to guard against early race with terminal rendering
-    start_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-
-    options.each do |code, file|
-      workers << Thread.new(code, file, owner, repo, branch, token, start_at) do |c, f, ow, rp, br, tk, st_at|
-        begin
-          # small initial delay if threads finish too quickly, to let the menu/prompt finish rendering
-          now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-          delay = 0.12 - (now - st_at)
-          sleep(delay) if delay && delay > 0
-
-          if ow.nil? || rp.nil? || br.nil?
-            status_q << [c, f, "n/a"]
-            Thread.exit
-          end
-          uri = URI("https://api.github.com/repos/#{ow}/#{rp}/actions/workflows/#{f}/runs?branch=#{URI.encode_www_form_component(br)}&per_page=1")
-          req = Net::HTTP::Get.new(uri)
-          req["User-Agent"] = "ci:act rake task"
-          req["Authorization"] = "token #{tk}" if tk && !tk.empty?
-          res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
-          status_q <<
-            if res.is_a?(Net::HTTPSuccess)
-              process_success_response(res, c, f)
-            else
-              [c, f, "fail #{res.code}"]
-            end
-        rescue StandardError
-          status_q << [c, f, "err"]
-        end
-      end
-    end
-
-    # Live update loop: either statuses arrive or the user submits input
-    statuses = Hash.new(placeholder)
-    selected = nil
-
-    loop do
-      # Check for user input first (non-blocking)
-      unless input_q.empty?
-        selected = begin
-          input_q.pop(true)
-        rescue
-          nil
-        end
-        break if selected
-      end
-
-      # Drain any available status updates without blocking
-      begin
-        code, file_name, display = status_q.pop(true)
-        statuses[code] = display
-
-        if tty
-          idx = idx_by_code[code]
-          if idx.nil?
-            puts "status #{code}: #{display}"
-            print(prompt)
-          else
-            move_up = options_with_quit.size - idx + 1 # 1 for instruction line + remaining options above last
-            $stdout.print("\e[#{move_up}A\r\e[2K")
-            disp = (code == quit_code) ? code : display_code_for[code]
-            $stdout.print(format("%2d) %-3s => %-20s %s\n", idx + 1, disp, file_name, display))
-            $stdout.print("\e[#{move_up - 1}B\r")
-            $stdout.print(prompt)
-          end
-          $stdout.flush
-        else
-          puts "status #{code}: #{display}"
-        end
-      rescue ThreadError
-        # Queue empty: brief sleep to avoid busy wait
-        sleep(0.05)
-      end
-    end
-
-    # Cleanup: kill any still-running threads
-    begin
-      workers.each { |t| t.kill if t&.alive? }
-    rescue StandardError
-      # ignore
-    end
-    begin
-      input_thread.kill if input_thread&.alive?
-    rescue StandardError
-      # ignore
-    end
-
-    input = selected
-    abort("ci:act aborted: no selection") if input.nil? || input.empty?
-
-    # Normalize selection
-    chosen_file = nil
-    if !!(/^\d+$/ =~ input)
-      idx = input.to_i - 1
-      if idx < 0 || idx >= options_with_quit.length
-        abort("ci:act aborted: invalid selection #{input}")
-      end
-      code, val = options_with_quit[idx]
-      if code == quit_code
-        puts "ci:act: quit"
-        next
-      else
-        chosen_file = val
-      end
-    else
-      code = input
-      if ["q", "quit", "exit"].include?(code.downcase)
-        puts "ci:act: quit"
-        next
-      end
-      chosen_file = mapping[code]
-      abort("ci:act aborted: unknown code '#{code}'") unless chosen_file
-    end
-
-    file_path = File.join(workflows_dir, chosen_file)
-    abort("ci:act aborted: workflow not found: #{file_path}") unless File.file?(file_path)
-
-    # Print status for the chosen workflow (for consistency)
-    fetch_and_print_status.call(chosen_file)
-    run_act_for(file_path)
+    Kettle::Dev::Tasks::CITask.act(args[:opt])
   end
-  # rubocop:enable ThreadSafety/NewThread
 end