puma-release 0.1.0

data/lib/puma_release/ci_checker.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require "json"
+
+module PumaRelease
+  class CiChecker
+    FAILURE_CONCLUSIONS = %w[failure cancelled timed_out action_required startup_failure stale].freeze
+    PENDING_STATUSES = %w[queued in_progress pending waiting requested].freeze
+
+    attr_reader :context
+
+    def initialize(context)
+      @context = context
+    end
+
+    def ensure_green!(sha)
+      debug("ensure_green! called with sha=#{sha}")
+      status = combined_status(sha)
+      debug("combined_status returned: #{status.inspect}")
+      return context.ui.info("CI is green.") if status == :success
+      return handle_unknown if status == :unknown
+
+      raise Error, "CI for #{sha[0, 12]} is #{status}. Stop and investigate before releasing."
+    end
+
+    private
+
+    def combined_status(sha)
+      status_url = "repos/#{context.metadata_repo}/commits/#{sha}/status"
+      runs_url = "repos/#{context.metadata_repo}/commits/#{sha}/check-runs"
+
+      debug("fetching commit status from: #{status_url}")
+      statuses = gh_json("gh", "api", status_url) || {}
+      debug("commit status response keys: #{statuses.keys.inspect}")
+      debug("commit status state: #{statuses["state"].inspect}")
+      debug("statuses array length: #{Array(statuses["statuses"]).length}")
+      Array(statuses["statuses"]).each_with_index do |item, i|
+        debug("  status[#{i}]: context=#{item["context"].inspect} state=#{item["state"].inspect}")
+      end
+
+      debug("fetching check-runs from: #{runs_url}")
+      runs = gh_json("gh", "api", runs_url) || {}
+      debug("check-runs response keys: #{runs.keys.inspect}")
+      debug("check_runs array length: #{Array(runs["check_runs"]).length}")
+      Array(runs["check_runs"]).each_with_index do |run, i|
+        debug("  check_run[#{i}]: name=#{run["name"].inspect} status=#{run["status"].inspect} conclusion=#{run["conclusion"].inspect}")
+      end
+
+      contexts = Array(statuses["statuses"]).map { |item| item.fetch("state") }
+      conclusions = Array(runs["check_runs"]).flat_map { |run| [run["status"], run["conclusion"]].compact }
+      values = contexts + conclusions
+
+      debug("contexts from statuses: #{contexts.inspect}")
+      debug("conclusions from check-runs: #{conclusions.inspect}")
+      debug("combined values: #{values.inspect}")
+
+      if values.empty?
+        debug("returning :unknown — no values found")
+        return :unknown
+      end
+
+      failure_values = values.select { |v| FAILURE_CONCLUSIONS.include?(v) || v == "error" }
+      if failure_values.any?
+        debug("returning :failure — found failure values: #{failure_values.inspect}")
+        return :failure
+      end
+
+      pending_values = values.select { |v| PENDING_STATUSES.include?(v) }
+      if pending_values.any?
+        debug("returning :pending — found pending values: #{pending_values.inspect}")
+        return :pending
+      end
+
+      unrecognized = values - ["success", "neutral", "skipped", "completed"]
+      if unrecognized.empty?
+        debug("returning :success — all values recognized as success: #{values.inspect}")
+        return :success
+      end
+
+      debug("returning :unknown — unrecognized values: #{unrecognized.inspect}")
+      :unknown
+    end
+
+    def handle_unknown
+      return context.ui.warn("Could not determine CI status; continuing because --allow-unknown-ci was set.") if context.allow_unknown_ci?
+      raise Error, "Could not determine CI status. Re-run with --allow-unknown-ci if you want to proceed anyway."
+    end
+
+    def gh_json(*command)
+      debug("gh_json running: #{command.join(" ")}")
+      result = context.shell.run(*command, allow_failure: true)
+      debug("gh_json exit status: #{result.exitstatus}, success: #{result.success?}")
+      unless result.success?
+        debug("gh_json stderr: #{result.stderr.strip.inspect}")
+        debug("gh_json stdout: #{result.stdout.strip.inspect}")
+        return nil
+      end
+
+      body = result.stdout.strip
+      debug("gh_json response body (first 500 chars): #{body[0, 500].inspect}")
+      body.empty? ? {} : JSON.parse(body)
+    end
+
+    def debug(message)
+      context.ui.debug(message) if context.debug?
+    end
+  end
+end

data/lib/puma_release/cli.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module PumaRelease
+  class CLI
+    COMMANDS = {
+      "prepare" => Commands::Prepare,
+      "build" => Commands::Build,
+      "github" => Commands::Github,
+      "run" => Commands::Run
+    }.freeze
+
+    attr_reader :argv, :env
+
+    def initialize(argv, env: ENV)
+      @argv = argv
+      @env = env
+    end
+
+    def run
+      options = Options.parse(argv)
+      context = Context.new(options, env:)
+      subscribe(context)
+      command = COMMANDS.fetch(options.fetch(:command)) { raise Error, usage }
+      command.new(context).call
+    rescue Error => e
+      UI.new.error(e.message)
+      exit 1
+    end
+
+    private
+
+    def subscribe(context)
+      context.events.subscribe(:checkpoint) do |_name, payload|
+        next unless payload[:kind] == :wait_for_merge
+
+        context.ui.info("Checkpoint: waiting for PR merge (#{payload[:pr_url]})")
+      end
+    end
+
+    def usage
+      [
+        "Usage: puma-release [options] [command]",
+        "",
+        "Commands:",
+        "  prepare   open the release PR and draft release",
+        "  build     tag the release and build both gem artifacts",
+        "  github    publish the GitHub release and upload assets",
+        "  run       detect the next step and run it (default)"
+      ].join("\n")
+    end
+  end
+end

data/lib/puma_release/commands/build.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module PumaRelease
+  module Commands
+    class Build
+      attr_reader :context, :git_repo, :repo_files, :github
+
+      def initialize(context)
+        @context = context
+        @git_repo = GitRepo.new(context)
+        @repo_files = RepoFiles.new(context)
+        @github = GitHubClient.new(context)
+      end
+
+      def call
+        context.check_dependencies!("git", "gh", "bundle")
+        context.announce_live_mode!
+        context.ensure_release_writes_allowed!
+        git_repo.ensure_clean_base!
+        version = repo_files.current_version
+        tag = git_repo.release_tag(version)
+        context.ui.info("Ensuring tag #{tag} points at HEAD and is pushed...")
+        git_repo.ensure_release_tag_pushed!(tag)
+        sync_release_target_to_tag(tag)
+        sync_release_title(tag, version)
+        context.ui.info("Building MRI gem...")
+        context.shell.run("bundle", "exec", "rake", "build")
+        context.ui.info("Built: pkg/puma-#{version}.gem")
+        jruby_built = BuildSupport.new(context).build_jruby_gem(version)
+        manual_jruby_instructions unless jruby_built
+        context.events.publish(:checkpoint, kind: :wait_for_rubygems, version:, tag:)
+        context.ui.info("STOP: push both gems to RubyGems, then rerun puma-release.")
+        :wait_for_rubygems
+      end
+
+      private
+
+      def sync_release_target_to_tag(tag)
+        release = github.release(tag)
+        return unless release
+
+        tag_sha = git_repo.local_tag_sha(tag)
+        raise Error, "Local tag #{tag} is missing." if tag_sha.empty?
+        return if release.fetch("targetCommitish", "") == tag_sha
+
+        context.ui.info("Updating release target for #{tag} to #{tag_sha[0, 12]}...")
+        github.edit_release_target(tag, tag_sha)
+      end
+
+      def sync_release_title(tag, version)
+        release = github.release(tag)
+        return unless release
+
+        title = repo_files.release_name(version)
+        return if release.fetch("name", "") == title
+
+        context.ui.info("Updating release title for #{tag} to #{title.inspect}...")
+        github.edit_release_title(tag, title)
+      end
+
+      def manual_jruby_instructions
+        context.ui.warn("JRuby gem was not built automatically.")
+        puts "To build it manually, switch to JRuby and run:"
+        puts "  bundle exec rake java gem"
+      end
+    end
+  end
+end

data/lib/puma_release/commands/github.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module PumaRelease
+  module Commands
+    class Github
+      attr_reader :context, :git_repo, :repo_files, :github
+
+      def initialize(context)
+        @context = context
+        @git_repo = GitRepo.new(context)
+        @repo_files = RepoFiles.new(context)
+        @github = GitHubClient.new(context)
+      end
+
+      def call
+        context.check_dependencies!("git", "gh")
+        context.announce_live_mode!
+        context.ensure_release_writes_allowed!
+        git_repo.ensure_clean_base!
+        version = repo_files.current_version
+        tag = git_repo.release_tag(version)
+        proposal_tag = git_repo.proposal_tag(version)
+        artifact_paths = artifacts(version)
+        body = repo_files.extract_history_section(version) || raise(Error, "Could not find section for #{version} in #{context.history_file}")
+        title = repo_files.release_name(version)
+        git_repo.ensure_release_tag_pushed!(tag)
+        tag_sha = git_repo.local_tag_sha(tag)
+        raise Error, "Local tag #{tag} is missing." if tag_sha.empty?
+
+        release = ensure_release_for_final_tag(tag, proposal_tag, body, title, tag_sha)
+        release = github.edit_release_target(tag, tag_sha) if release.fetch("targetCommitish", "") != tag_sha
+        release = github.edit_release_title(tag, title) if release.fetch("name", "") != title
+        release = github.edit_release_notes(tag, body) if release.fetch("body", "") != body
+        github.upload_release_assets(tag, *artifact_paths)
+        release = github.publish_release(tag) if release.fetch("isDraft", false)
+        cleanup_proposal_release!(proposal_tag)
+        context.events.publish(:release_published, tag:, url: release.fetch("url"))
+        context.ui.info("GitHub release published: #{release.fetch("url")}")
+        :complete
+      end
+
+      private
+
+      def ensure_release_for_final_tag(tag, proposal_tag, body, title, tag_sha)
+        release = github.release(tag)
+        proposal_release = github.release(proposal_tag)
+        raise Error, "Found both #{tag} and #{proposal_tag} releases. Clean up the proposal release before continuing." if release && proposal_release
+        return release if release
+        return promote_proposal_release!(proposal_tag, tag, tag_sha) if proposal_release
+
+        github.create_release(tag, body, title:, draft: true)
+      end
+
+      def promote_proposal_release!(proposal_tag, tag, tag_sha)
+        context.ui.info("Promoting draft release from #{proposal_tag} to #{tag}...")
+        github.retag_release(proposal_tag, tag, target: tag_sha)
+      end
+
+      def cleanup_proposal_release!(proposal_tag)
+        github.delete_release(proposal_tag, allow_failure: true) if github.release(proposal_tag)
+        github.delete_tag_ref(proposal_tag, allow_failure: true) unless git_repo.remote_tag_sha(proposal_tag).empty?
+      end
+
+      def artifacts(version)
+        paths = [
+          context.repo_dir.join("pkg", "puma-#{version}.gem"),
+          context.repo_dir.join("pkg", "puma-#{version}-java.gem")
+        ]
+        missing = paths.reject(&:file?)
+        raise Error, "Missing release artifact(s): #{missing.join(" ")}" unless missing.empty?
+
+        paths.map(&:to_s)
+      end
+    end
+  end
+end

data/lib/puma_release/commands/prepare.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+module PumaRelease
+  module Commands
+    class Prepare
+      attr_reader :context, :git_repo, :repo_files, :github, :contributors
+
+      def initialize(context)
+        @context = context
+        @git_repo = GitRepo.new(context)
+        @repo_files = RepoFiles.new(context)
+        @github = GitHubClient.new(context)
+        @contributors = ContributorResolver.new(context, git_repo:, github:)
+      end
+
+      def call
+        context.check_dependencies!("git", "gh", context.agent_binary)
+        context.announce_live_mode!
+        context.ensure_release_writes_allowed!
+        git_repo.ensure_clean_base!
+        ensure_green_ci!
+
+        last_tag = git_repo.last_tag
+        context.ui.info("Last release tag: #{last_tag}")
+        release_range = ReleaseRange.new(context, last_tag)
+        recommendation = VersionRecommender.new(context, release_range).call
+        bump_type = recommendation.fetch("bump_type")
+        current_version = repo_files.current_version
+        new_version = git_repo.bump_version(current_version, bump_type)
+        context.ui.info("Version bump: #{current_version} -> #{new_version}")
+        show_version_recommendation(recommendation)
+
+        earner = show_codename_earner(last_tag, bump_type)
+        changelog = prepare_changelog(release_range, new_version, last_tag)
+        context.ui.info("Generating link references...")
+        refs = LinkReferenceBuilder.new(context).build(changelog)
+        repo_files.prepend_history_section!(new_version, changelog, refs)
+        repo_files.update_version!(new_version, bump_type, codename: context.codename)
+        upgrade_guide_path = write_upgrade_guide(release_range, new_version, recommendation, bump_type)
+        security_file = update_security_policy(new_version, bump_type)
+
+        branch = "release-v#{new_version}"
+        git_repo.checkout_release_branch!(branch)
+        git_repo.commit_release!(new_version, extra_files: [*Array(upgrade_guide_path), *Array(security_file)])
+        git_repo.push_branch!(branch)
+
+        compare_url = "https://github.com/#{context.metadata_repo}/compare/#{last_tag}...#{git_repo.head_sha}"
+        pr_url = github.create_release_pr("Release v#{new_version}", branch, body: compare_url)
+        github.comment_on_pr(pr_url, pr_comment(recommendation, earner))
+        release = ensure_draft_release(new_version, branch)
+        release_url = release.fetch("url")
+        github.update_pr_body(pr_url, "#{compare_url}\n\n#{release_url}")
+        context.events.publish(:checkpoint, kind: :wait_for_merge, pr_url:, release_url:, branch:)
+
+        context.ui.info("Release PR created: #{pr_url}")
+        context.ui.info("Draft GitHub release ready: #{release.fetch("url")}")
+        context.ui.warn(waiting_on_codename_message(earner)) if earner
+        context.ui.info("STOP: review and merge the PR, then rerun puma-release.")
+        :wait_for_merge
+      end
+
+      private
+
+      def ensure_green_ci!
+        return context.ui.warn("Skipping CI check because --skip-ci-check was set.") if context.skip_ci_check?
+
+        context.ui.info("Checking CI status for HEAD...")
+        ci_checker.ensure_green!(git_repo.head_sha)
+      end
+
+      def ci_checker = CiChecker.new(context)
+
+      def show_codename_earner(last_tag, bump_type)
+        return nil if bump_type == "patch"
+        return nil if context.codename
+
+        context.ui.info("Top contributors since #{last_tag}:")
+        git_repo.top_contributors_since(last_tag).first(5).each { |line| puts line }
+        earner = contributors.codename_earner(last_tag)
+        return nil unless earner
+
+        label = earner.fetch(:name)
+        label += " (@#{earner[:login]})" if earner[:login]
+        context.ui.info("Codename earner: #{label}")
+        earner
+      end
+
+      def show_version_recommendation(recommendation)
+        context.ui.info("Version bump recommendation:")
+        puts recommendation.fetch("reasoning_markdown")
+
+        breaking_changes = recommendation.fetch("breaking_changes", [])
+        return if breaking_changes.empty?
+
+        context.ui.warn("Potential breaking changes:")
+        breaking_changes.each { |item| puts "- #{item}" }
+      end
+
+      def update_security_policy(new_version, bump_type)
+        return nil unless bump_type == "major"
+
+        repo_files.update_security!(new_version)
+        context.security_file
+      end
+
+      def write_upgrade_guide(release_range, new_version, recommendation, bump_type)
+        return nil unless bump_type == "major"
+
+        UpgradeGuideWriter.new(
+          context,
+          release_range,
+          new_version:,
+          breaking_changes: recommendation.fetch("breaking_changes", []),
+          codename: context.codename
+        ).call
+      end
+
+      def prepare_changelog(release_range, new_version, last_tag)
+        tag = git_repo.proposal_tag(new_version)
+        git_repo.create_signed_tag!(tag, message: "Temporary changelog tag for #{tag}")
+        ChangelogGenerator.new(context, release_range, new_tag: tag, last_tag:).call
+      ensure
+        git_repo.delete_local_tag!(tag, allow_failure: true) if tag
+      end
+
+      def ensure_draft_release(version, branch)
+        tag = git_repo.proposal_tag(version)
+        body = release_body(version)
+        title = repo_files.release_name(version)
+        release = github.release(tag)
+        release ||= github.create_release(tag, body, title:, draft: true, target: branch)
+        release = github.edit_release_target(tag, branch) if release.fetch("targetCommitish", "") != branch
+        release = github.edit_release_title(tag, title) if release.fetch("name", "") != title
+        (release.fetch("body", "") == body) ? release : github.edit_release_notes(tag, body)
+      end
+
+      def pr_comment(recommendation, earner)
+        lines = [
+          context.comment_attribution(recommendation.fetch("model_name", context.comment_author_model_name)),
+          "",
+          "## Version bump recommendation",
+          "",
+          "Recommended bump: **#{recommendation.fetch("bump_type")}**",
+          "",
+          recommendation.fetch("reasoning_markdown")
+        ]
+
+        breaking_changes = recommendation.fetch("breaking_changes", [])
+        if breaking_changes.any?
+          lines += ["", "## Potential breaking changes", ""]
+          lines += breaking_changes.map { |item| "- #{item}" }
+        else
+          lines += ["", "## Potential breaking changes", "", "_None identified._"]
+        end
+
+        return lines.join("\n") unless earner
+
+        [*lines, "", "## Codename", "", codename_message(earner)].join("\n")
+      end
+
+      def codename_message(earner)
+        return "@#{earner.fetch(:login)} earned the codename for this release. Please propose a codename!" if earner[:login]
+
+        "#{earner.fetch(:name)} earned the codename for this release. Please propose a codename!"
+      end
+
+      def waiting_on_codename_message(earner)
+        return "Waiting on @#{earner.fetch(:login)} for a codename before merging." if earner[:login]
+
+        "Waiting on #{earner.fetch(:name)} for a codename before merging."
+      end
+
+      def release_body(version)
+        repo_files.extract_history_section(version) || raise(Error, "Could not find section for #{version} in #{context.history_file}")
+      end
+    end
+  end
+end

data/lib/puma_release/commands/run.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module PumaRelease
+  module Commands
+    class Run
+      attr_reader :context
+
+      def initialize(context)
+        @context = context
+      end
+
+      def call
+        step = stage_detector.next_step
+        return wait_for_merge if step == :wait_for_merge
+        return complete if step == :complete
+        return run_step(step) if confirm_step(step)
+
+        :aborted
+      end
+
+      private
+
+      def stage_detector = StageDetector.new(context)
+
+      def confirm_step(step)
+        return true if context.yes?
+
+        context.ui.confirm("Detected next step: #{step}. Continue?")
+      end
+
+      def run_step(step)
+        case step
+        when :prepare then Prepare.new(context).call
+        when :build then Build.new(context).call
+        when :github then Github.new(context).call
+        else raise Error, "Unknown step: #{step}"
+        end
+      end
+
+      def complete
+        context.ui.info("The current release is already complete. No action needed.")
+        :complete
+      end
+
+      def wait_for_merge
+        context.ui.info("A release PR is already in flight. Merge it, update local #{context.base_branch}, and rerun puma-release.")
+        :wait_for_merge
+      end
+    end
+  end
+end