git-trim 0.1.3 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4c941e5077e893642ba38fbd33d94f9c8fbef9c8590b8b9107457d7027da16ea
-  data.tar.gz: 50297be5101150a1898acef6b2a09da3d82b03878765cf09d36fa0fc6fe769ae
+  metadata.gz: e0d7321c50f209f50a7aa16e40a26ecc655cc020af8338c4902661bf66260bd7
+  data.tar.gz: 48046ed58462e3ef2553e970c24ebcefb125c16b885f1ba942c4ef87d8d31ac1
 SHA512:
-  metadata.gz: e2befed7aefe3649a8fa13b0fd7afbebf630c29f2a788370b0211f3291740ce230cf46f9bd14c42df862d73f32b5d951134c29211da85e1a6b86e57b72f078d4
-  data.tar.gz: 56e28769e4b6554df8c6058d728678600b03082415d8c2043075a4abea758a36df0bb0f02c6d4d676c6ce71c7ea4e4a0ee2c621e6dd2f4bd76db0e58e781fb94
+  metadata.gz: 07ae69e3dce7993df35a365fbe8845d0d516944213bb29ecd40f10ca660222d10c8205be3fa8c56f940bd016b26d5ac2f830433c00f5170b313767b309ff1b7d
+  data.tar.gz: ec29e5f712886391185e166bce3070d197097deb1bc9e8236a67a2d9d357ec07ece989e7db12337277a2f60fb35dbf21e63b8bf7ed0f54764103519a45ec4523

data/.github/workflows/ci.yml

@@ -0,0 +1,18 @@
+name: build
+on: pull_request
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ruby
+          bundler-cache: true
+
+      - name: Run specs
+        run: |
+          git config --global user.email "ci@example.com"
+          git config --global user.name "CI"
+          git config --global init.defaultBranch main
+          bundle exec rake spec

data/.github/workflows/release.yml

@@ -0,0 +1,65 @@
+name: Release
+
+on:
+  workflow_dispatch:
+    inputs:
+      version:
+        description: "Version to release (e.g. 0.2.0)"
+        required: true
+        type: string
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      id-token: write
+    steps:
+      - uses: actions/checkout@v6
+
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: "3.3"
+          bundler-cache: true
+
+      - name: Run specs
+        run: bundle exec rake spec
+
+      - name: Update version
+        run: |
+          VERSION="${{ inputs.version }}"
+          sed -i "s/VERSION = \".*\"/VERSION = \"$VERSION\"/" lib/git-trim/version.rb
+          echo "Updated version to $VERSION"
+          cat lib/git-trim/version.rb
+
+      # bundler-cache sets frozen/deployment mode, which rejects the now
+      # out-of-date lockfile entry for git-trim itself. Re-lock so the
+      # release commit keeps the gemspec and lockfile in sync.
+      - name: Update Gemfile.lock
+        run: |
+          bundle config unset deployment
+          bundle config unset frozen
+          BUNDLE_FROZEN=false BUNDLE_DEPLOYMENT=false bundle lock
+
+      - name: Commit version bump
+        run: |
+          VERSION="${{ inputs.version }}"
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git add lib/git-trim/version.rb Gemfile.lock
+          git commit -m "Release v$VERSION"
+
+      # Builds the gem into pkg/, tags v$VERSION, pushes the commit and
+      # tag, and publishes to RubyGems via OIDC trusted publishing.
+      - name: Release to RubyGems
+        uses: rubygems/release-gem@v1
+
+      - name: Create GitHub Release
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          VERSION="${{ inputs.version }}"
+          gh release create "v$VERSION" \
+            --title "v$VERSION" \
+            --generate-notes \
+            pkg/git-trim-*.gem

data/Gemfile.lock

@@ -1,35 +1,36 @@
 PATH
   remote: .
   specs:
-    git-trim (0.1.2)
+    git-trim (0.3.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    diff-lcs (1.3)
-    rake (13.0.1)
-    rspec (3.7.0)
-      rspec-core (~> 3.7.0)
-      rspec-expectations (~> 3.7.0)
-      rspec-mocks (~> 3.7.0)
-    rspec-core (3.7.1)
-      rspec-support (~> 3.7.0)
-    rspec-expectations (3.7.0)
+    diff-lcs (1.6.2)
+    rake (13.4.2)
+    rspec (3.13.2)
+      rspec-core (~> 3.13.0)
+      rspec-expectations (~> 3.13.0)
+      rspec-mocks (~> 3.13.0)
+    rspec-core (3.13.6)
+      rspec-support (~> 3.13.0)
+    rspec-expectations (3.13.5)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.7.0)
-    rspec-mocks (3.7.0)
+      rspec-support (~> 3.13.0)
+    rspec-mocks (3.13.8)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.7.0)
-    rspec-support (3.7.1)
+      rspec-support (~> 3.13.0)
+    rspec-support (3.13.7)
 
 PLATFORMS
+  arm64-darwin-25
   ruby
 
 DEPENDENCIES
-  bundler (~> 1.16)
+  bundler (>= 1.16)
   git-trim!
   rake (~> 13.0)
   rspec (~> 3.0)
 
 BUNDLED WITH
-   1.17.3
+   2.5.3

data/README.md

@@ -1,8 +1,6 @@
 # git trim
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/git/trim`. To experiment with that code, run `bin/console` for an interactive prompt.
-
-TODO: Delete this and the text above, and describe your gem
+Deletes local branches — and the [linked worktrees](https://git-scm.com/docs/git-worktree) that hold them — once they are merged into `main`, including squash merges. Run it after a round of PRs merge and it cleans up everything that's done, while refusing to touch anything that still has work in it.
 
 ## Installation
 
@@ -22,9 +20,77 @@ Or install it yourself as:
 
 ## Usage
 
-You can call `git trim` and it will remove any branch that isn't currently merged into the current branch that isn't also in the `.git-protected-branches` file. It will not remove the main branch.
+Run `git trim` from anywhere inside a repository. It fetches (with prune), then removes every local branch that is merged into `main`, unless the branch is:
+
+- `main` itself,
+- the branch you currently have checked out (or the one checked out in the main worktree), or
+- listed in a `.git-protected-branches` file.
+
+If no local `main` exists (common in bare-repo + worktrees layouts), it compares against `origin/main` instead.
+
+### Options
+
+| Flag | Effect |
+| --- | --- |
+| `-n`, `--dry-run` | Print exactly what would be removed and which signal proved it merged, without deleting anything. It still runs `git fetch -ap`, so the report reflects the current remote. |
+| `--no-gh` | Skip the GitHub check entirely and use git-only detection. |
+| `-h`, `--help` | Show usage. |
+
+### How merges are detected
+
+A branch is trimmed when **any** of these proves it is merged:
+
+1. **Regular merge.** The branch is in `git branch --merged main`. It is deleted with `git branch -d`.
+2. **Squash merge, offline.** git-trim builds a throwaway commit holding the branch's whole diff on top of its merge base (`git commit-tree <branch>^{tree} -p $(git merge-base main <branch>)`) and asks `git cherry main <tmp>` whether `main` already has an equivalent patch. No network needed.
+3. **Merged GitHub PR.** A merged PR whose head branch has the same name **and** whose head commit is exactly the local tip. All merged PRs are fetched in one `gh pr list --state merged` call (up to 1000, most recent first).
+
+Branches proven by (2) or (3) are deleted with `git branch -D`, since `-d` refuses squash-merged branches. `-D` is never used for anything else.
+
+Some cases are reported and left alone:
+
+- **Extra local commits.** If a merged PR exists for the branch but the local branch has commits the PR never had, the branch is kept:
+  `Skipping branch 'feature-x': it has commits that merged PR #42 never had`
+- **Gone upstream, no proof.** A branch whose upstream was deleted (`[gone]`) is **not** trimmed for that reason alone, because a PR closed without merging looks the same. It is reported as possibly stale:
+  `Keeping branch 'spike': its upstream is gone but nothing proves it was merged (possibly stale)`
+
+### The GitHub CLI is optional
+
+Signal (3) uses [`gh`](https://cli.github.com/) when it is available and is skipped otherwise. git-trim prints one warning naming the reason, carries on with git-only detection, and exits 0 as usual:
+
+```
+git-trim: gh not installed; skipping GitHub PR check, using git-only detection
+```
+
+The reasons are: `gh` is not installed, no remote points at GitHub, `gh` is not logged in, `gh` can't verify its login (GitHub unreachable or token rejected), GitHub is unreachable, the API rate limit was hit, `gh` timed out, or it returned output that couldn't be parsed. An error, empty output or malformed JSON never counts as evidence that a branch is merged.
+
+`gh` is consulted only when git alone can't prove some branch or detached worktree merged. It runs with `GH_PROMPT_DISABLED=1`, with no terminal on stdin, and under a 15-second timeout, so a hung auth prompt or network call can't stall the run.
+
+### Worktrees
+
+If a merged branch is checked out in a linked worktree, `git trim` removes the worktree first and then deletes the branch. Worktrees with uncommitted changes or untracked files are left alone, along with their branch:
+
+```
+$ git trim
+Removed worktree /Users/you/src/project/feature-a
+Deleted branch feature-a (was fa68cf94). [merged into main]
+Deleted branch feature-c (was 1b2c3d4e). [squash-merged into main (patch already in main)]
+Skipping branch 'feature-b': worktree at /Users/you/src/project/feature-b has local changes
+```
+
+Commit or stash the local changes and run `git trim` again to clean up the rest.
 
-The `.git-protected-branches` file can reside in the current directory or any parent directory. Branch names are each listed on a line in the file. For example:
+**Detached worktrees** (detached HEAD, such as the ones agents create for read-only review) are removed when they are clean and their HEAD is contained in `main`, or equals the head commit of a merged PR:
+
+```
+Removed detached worktree /Users/you/src/project/review-42 [HEAD is the head of merged PR #42]
+Skipping detached worktree at /Users/you/src/project/review-43: it has local changes
+```
+
+The main worktree and the worktree you run `git trim` from are never removed.
+
+### Protected branches
+
+The `.git-protected-branches` file can reside in the current directory or any parent directory; the nearest one wins. Branch names are each listed on a line in the file. For example:
 
 ```
 main
@@ -32,9 +98,13 @@ staging
 production
 ```
 
+## Releasing
+
+Releases are cut from the GitHub Actions **Release** workflow (Actions → Release → Run workflow → enter a version like `0.2.0`). The workflow runs the specs, bumps `lib/git-trim/version.rb`, tags `v<version>`, publishes to RubyGems via [trusted publishing](https://guides.rubygems.org/trusted-publishing/) (no API key), and creates a GitHub release.
+
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/git-trim. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+Bug reports and pull requests are welcome on GitHub at https://github.com/cpetersen/git-trim. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
 
 ## License
 
@@ -42,4 +112,4 @@ The gem is available as open source under the terms of the [MIT License](https:/
 
 ## Code of Conduct
 
-Everyone interacting in the Git::Trim project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/git-trim/blob/main/CODE_OF_CONDUCT.md).
+Everyone interacting in the Git::Trim project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/cpetersen/git-trim/blob/main/CODE_OF_CONDUCT.md).

data/bin/git-trim

@@ -2,4 +2,4 @@
 
 require 'git-trim'
 
-GitTrim.new.run(ARGV)
+exit GitTrim.new.run(ARGV)

data/git-trim.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |spec|
 
   spec.summary       = %q{A script to remove all merged branches that aren't protected.}
   spec.description   = %q{A script to remove all merged branches that aren't specified in the .git-protected-branches file.}
-  spec.homepage      = "https://github.com/assaydepot/git-trim"
+  spec.homepage      = "https://github.com/cpetersen/git-trim"
   spec.license       = "MIT"
 
   # Specify which files should be added to the gem when it is released.
@@ -23,7 +23,7 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.require_paths = ["lib", "bin"]
 
-  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "bundler", ">= 1.16"
   spec.add_development_dependency "rake", "~> 13.0"
   spec.add_development_dependency "rspec", "~> 3.0"
 end

data/lib/git-trim/version.rb

@@ -1,3 +1,3 @@
 class GitTrim
-  VERSION = "0.1.3"
+  VERSION = "0.3.0"
 end

data/lib/git-trim.rb

@@ -1,23 +1,119 @@
 require "git-trim/version"
+require "json"
+require "open3"
+require "optparse"
+require "shellwords"
 
 class GitTrim
+  GH_TIMEOUT = 15
+  GH_PR_LIMIT = 1000
+
+  # gh must never stop to ask a question: no prompts, no update notices,
+  # no spinner, no colour codes in the JSON.
+  GH_ENV = {
+    "GH_PROMPT_DISABLED" => "1",
+    "GH_NO_UPDATE_NOTIFIER" => "1",
+    "GH_SPINNER_DISABLED" => "1",
+    "NO_COLOR" => "1",
+  }.freeze
+
+  # Identity for the throwaway commit built by the offline squash check, so it
+  # works even when user.name/user.email aren't configured.
+  TMP_COMMIT_ENV = {
+    "GIT_AUTHOR_NAME" => "git-trim",
+    "GIT_AUTHOR_EMAIL" => "git-trim@localhost",
+    "GIT_COMMITTER_NAME" => "git-trim",
+    "GIT_COMMITTER_EMAIL" => "git-trim@localhost",
+  }.freeze
+
+  # Why a branch counts as merged. Only a regular merge can use `git branch
+  # -d`; git refuses -d for squash-merged branches, so the other proofs force.
+  Proof = Struct.new(:reason, :force)
+
+  def initialize(gh_timeout: GH_TIMEOUT)
+    @gh_timeout = gh_timeout
+  end
+
   def run(argv=nil)
+    @dry_run = false
+    @use_gh = true
+    help = false
+    parser = OptionParser.new do |opts|
+      opts.banner = "Usage: git trim [--dry-run] [--no-gh]"
+      opts.on("-n", "--dry-run", "Show what would be removed, and why, without changing anything") { @dry_run = true }
+      opts.on("--[no-]gh", "Use the GitHub CLI to detect merged PRs (default: on when available)") { |value| @use_gh = value }
+      opts.on("-h", "--help", "Show this help") { help = true }
+    end
+    begin
+      parser.parse(argv || [])
+    rescue OptionParser::ParseError => e
+      warn "git-trim: #{e.message}"
+      warn parser.banner
+      return 1
+    end
+    if help
+      puts parser
+      return 0
+    end
+    remove_instance_variable(:@merged_prs) if defined?(@merged_prs)
+
     %x{git fetch -ap}
 
-    if File.exist?(".git-protected-branches")
-      protected_branches = File.read(".git-protected-branches").split("\n")
-    end
-    protected_branches ||= []
+    protected_branches = read_protected_branches
     protected_branches << "main"
 
-    branches = %x{git branch --merged main}.split("\n").collect {|b| b.gsub('*', '').strip}
-    branches -= protected_branches
+    base = base_ref
+    unless base
+      warn "git-trim: neither 'main' nor 'origin/main' exists; nothing to trim against"
+      return 1
+    end
+
+    worktrees = linked_worktrees
+    branch_worktrees = worktrees.select { |wt| wt[:branch] }.to_h { |wt| [wt[:branch], wt[:path]] }
+
+    merged = %x{git branch --merged #{Shellwords.escape(base)} --format='%(refname:short)'}.split("\n").collect(&:strip)
+    excluded = protected_branches + [current_branch, main_worktree_branch].compact
+
+    local_branches.each do |branch|
+      next if excluded.include?(branch[:name])
+
+      proof = merge_proof(branch, base, merged)
+      if proof.is_a?(Proof)
+        trim_branch(branch[:name], proof, branch_worktrees[branch[:name]])
+      elsif proof.nil? && branch[:gone]
+        puts "Keeping branch '#{branch[:name]}': its upstream is gone but nothing proves it was merged (possibly stale)"
+      end
+    end
+
+    here = current_worktree
+    worktrees.select { |wt| wt[:detached] }.each do |wt|
+      next if same_path?(wt[:path], here)
+      reason = detached_merge_reason(wt[:head], base)
+      trim_detached_worktree(wt[:path], reason) if reason
+    end
+
+    0
+  end
 
-    branches.each do |branch|
-      puts %x{git branch -d #{branch}}
+  def current_branch
+    %x{git branch --show-current}.strip
+  end
+
+  # Local main when it exists; otherwise origin/main (e.g. bare-repo +
+  # worktrees layouts where no local main is checked out). Nil if neither.
+  def base_ref
+    ["main", "origin/main"].find do |ref|
+      %x{git rev-parse --verify --quiet #{Shellwords.escape(ref)}}
+      $?.success?
     end
   end
 
+  # Linked worktrees as {path:, branch:, head:, detached:}. The first entry
+  # in `git worktree list` is the main worktree, which is never removable.
+  def linked_worktrees
+    worktree_entries.drop(1)
+  end
+
   def find_file(filename, directory=Dir.pwd)
     local_filename = File.expand_path(filename, directory)
     if File.exist?(local_filename)
@@ -28,4 +124,268 @@ class GitTrim
       return find_file(filename, File.expand_path("..", directory))
     end
   end
+
+  private
+
+  def read_protected_branches
+    path = find_file(".git-protected-branches")
+    return [] unless path
+    File.read(path).split("\n").collect(&:strip).reject(&:empty?)
+  end
+
+  def worktree_entries
+    %x{git worktree list --porcelain}.split("\n\n").collect do |entry|
+      {
+        path: entry[/^worktree (.+)$/, 1],
+        branch: entry[/^branch refs\/heads\/(.+)$/, 1],
+        head: entry[/^HEAD (\h+)$/, 1],
+        detached: entry.match?(/^detached$/),
+      }
+    end.select { |wt| wt[:path] }
+  end
+
+  def main_worktree_branch
+    worktree_entries.first&.fetch(:branch)
+  end
+
+  def current_worktree
+    git("rev-parse", "--show-toplevel")
+  end
+
+  def same_path?(a, b)
+    return false unless a && b
+    File.realpath(a) == File.realpath(b)
+  rescue SystemCallError
+    a == b
+  end
+
+  def local_branches
+    format = "%(refname:short)%09%(objectname)%09%(upstream:track)"
+    %x{git for-each-ref refs/heads --format=#{Shellwords.escape(format)}}.split("\n").collect do |line|
+      name, tip, track = line.split("\t")
+      { name: name, tip: tip, gone: track.to_s.include?("gone") }
+    end
+  end
+
+  # A Proof when some signal shows the branch is merged into base; :mismatch
+  # when a merged PR exists but the local branch has moved on (already
+  # reported); nil when there's no evidence either way.
+  def merge_proof(branch, base, merged)
+    return Proof.new("merged into #{base}", false) if merged.include?(branch[:name])
+    return Proof.new("squash-merged into #{base} (patch already in #{base})", true) if squash_merged?(base, branch[:tip])
+    github_merge_proof(branch)
+  end
+
+  # Offline squash detection: collapse the branch into one commit on top of
+  # its merge base, then ask `git cherry` whether base already has an
+  # equivalent patch. A leading "-" means it does.
+  def squash_merged?(base, tip)
+    merge_base = git("merge-base", base, tip) or return false
+    tree = git("rev-parse", "#{tip}^{tree}") or return false
+    # Nothing to compare when the branch makes no net change.
+    return false if tree == git("rev-parse", "#{merge_base}^{tree}")
+    tmp = git("commit-tree", tree, "-p", merge_base, "-m", "_", env: TMP_COMMIT_ENV) or return false
+    cherry = git("cherry", base, tmp) or return false
+    cherry.start_with?("-")
+  end
+
+  # Proof from GitHub: a merged PR for this branch name whose head is exactly
+  # the local tip. A merged PR at a different commit is not proof.
+  def github_merge_proof(branch)
+    prs = merged_prs or return nil
+    matching = prs.select { |pr| pr["headRefName"] == branch[:name] }
+    return nil if matching.empty?
+
+    if (pr = matching.find { |candidate| candidate["headRefOid"] == branch[:tip] })
+      return Proof.new("merged PR ##{pr["number"]}", true)
+    end
+
+    pr = matching.first
+    if ancestor?(pr["headRefOid"], branch[:tip])
+      puts "Skipping branch '#{branch[:name]}': it has commits that merged PR ##{pr["number"]} never had"
+    else
+      puts "Skipping branch '#{branch[:name]}': its tip doesn't match the head of merged PR ##{pr["number"]}"
+    end
+    :mismatch
+  end
+
+  def detached_merge_reason(head, base)
+    return nil unless head
+    return "HEAD is in #{base}" if ancestor?(head, base)
+    pr = merged_prs&.find { |candidate| candidate["headRefOid"] == head }
+    "HEAD is the head of merged PR ##{pr["number"]}" if pr
+  end
+
+  def trim_branch(name, proof, worktree_path)
+    if @dry_run
+      if worktree_path && dirty?(worktree_path)
+        puts "Would skip branch '#{name}': worktree at #{worktree_path} has local changes"
+        return
+      end
+      puts "Would remove worktree #{worktree_path} (#{proof.reason})" if worktree_path
+      puts "Would delete branch #{name} (#{proof.reason})"
+      return
+    end
+
+    if worktree_path
+      output = %x{git worktree remove #{Shellwords.escape(worktree_path)} 2>&1}
+      unless $?.success?
+        if output.include?("contains modified or untracked files")
+          puts "Skipping branch '#{name}': worktree at #{worktree_path} has local changes"
+        else
+          puts "Skipping branch '#{name}': could not remove worktree at #{worktree_path}"
+          puts output
+        end
+        return
+      end
+      puts "Removed worktree #{worktree_path}"
+    end
+
+    flag = proof.force ? "-D" : "-d"
+    output = %x{git branch #{flag} #{Shellwords.escape(name)} 2>&1}
+    if $?.success?
+      puts "#{output.strip} [#{proof.reason}]"
+    else
+      puts "Skipping branch '#{name}': could not delete it"
+      puts output
+    end
+  end
+
+  def trim_detached_worktree(path, reason)
+    if @dry_run
+      if dirty?(path)
+        puts "Would skip detached worktree at #{path}: it has local changes"
+      else
+        puts "Would remove detached worktree #{path} (#{reason})"
+      end
+      return
+    end
+
+    output = %x{git worktree remove #{Shellwords.escape(path)} 2>&1}
+    if $?.success?
+      puts "Removed detached worktree #{path} [#{reason}]"
+    elsif output.include?("contains modified or untracked files")
+      puts "Skipping detached worktree at #{path}: it has local changes"
+    else
+      puts "Skipping detached worktree at #{path}: could not remove it"
+      puts output
+    end
+  end
+
+  def dirty?(path)
+    status = git("-C", path, "status", "--porcelain")
+    status.nil? || !status.empty?
+  end
+
+  def ancestor?(commit, descendant)
+    _, _, status = Open3.capture3("git", "merge-base", "--is-ancestor", commit, descendant)
+    status.success?
+  end
+
+  # Stripped stdout of a git command, or nil if it failed.
+  def git(*args, env: {})
+    out, _, status = Open3.capture3(env, "git", *args)
+    out.strip if status.success?
+  end
+
+  # Merged PRs from GitHub as [{"number", "headRefName", "headRefOid"}], or
+  # nil when gh can't give a trustworthy answer. Fetched at most once, and
+  # only if some branch or worktree actually needs it.
+  def merged_prs
+    return @merged_prs if defined?(@merged_prs)
+    @merged_prs = fetch_merged_prs
+  end
+
+  def fetch_merged_prs
+    return nil unless @use_gh
+    return gh_unavailable("gh not installed") unless system("command -v gh >/dev/null 2>&1")
+    return gh_unavailable("no GitHub remote") unless github_remote?
+
+    status, = gh("auth", "status")
+    return gh_unavailable("gh timed out after #{@gh_timeout}s") if status == :timeout
+    unless status&.success?
+      # `auth status` checks the token online and reports a network failure
+      # as an invalid token. `auth token` is offline, so it tells "never
+      # logged in" apart from "logged in but couldn't verify".
+      token_status, = gh("auth", "token")
+      return gh_unavailable("gh not logged in") unless token_status.is_a?(Process::Status) && token_status.success?
+      return gh_unavailable("gh couldn't verify its login (GitHub unreachable or token rejected)")
+    end
+
+    status, out, err = gh("pr", "list", "--state", "merged", "--limit", GH_PR_LIMIT.to_s,
+                          "--json", "number,headRefName,headRefOid")
+    return gh_unavailable("gh timed out after #{@gh_timeout}s") if status == :timeout
+    return gh_unavailable(gh_failure(err)) unless status&.success?
+
+    parse_prs(out) || gh_unavailable("gh returned unparseable output")
+  end
+
+  def gh_unavailable(reason)
+    warn "git-trim: #{reason}; skipping GitHub PR check, using git-only detection"
+    nil
+  end
+
+  def gh_failure(stderr)
+    case stderr
+    when /rate limit/i then "GitHub API rate limit hit"
+    when /could not resolve|no such host|dial tcp|connection refused|network is unreachable|i\/o timeout|tls/i
+      "can't reach GitHub"
+    else "gh pr list failed"
+    end
+  end
+
+  # Raw remote URLs (not insteadOf-rewritten), since gh resolves the repo
+  # from those too.
+  def github_remote?
+    hosts = ["github.com", ENV["GH_HOST"]].compact.reject(&:empty?)
+    urls = git("config", "--get-regexp", '^remote\..*\.url$').to_s.split("\n")
+    urls.any? { |line| hosts.any? { |host| line.include?(host) } }
+  end
+
+  # An error, empty output or a malformed payload is never evidence.
+  def parse_prs(json)
+    prs = JSON.parse(json)
+    return nil unless prs.is_a?(Array)
+    valid = prs.all? do |pr|
+      pr.is_a?(Hash) && pr["headRefName"].is_a?(String) && !pr["headRefName"].empty? &&
+        pr["headRefOid"].is_a?(String) && pr["headRefOid"].match?(/\A(\h{40}|\h{64})\z/)
+    end
+    prs if valid
+  rescue JSON::ParserError
+    nil
+  end
+
+  # Runs gh with no TTY and a hard deadline. Returns [status, stdout, stderr],
+  # with status :timeout if gh was killed, or nil if it couldn't start.
+  def gh(*args)
+    out_r, out_w = IO.pipe
+    err_r, err_w = IO.pipe
+    begin
+      pid = Process.spawn(GH_ENV, "gh", *args, in: File::NULL, out: out_w, err: err_w, pgroup: true)
+    rescue SystemCallError
+      return [nil, "", ""]
+    ensure
+      out_w.close
+      err_w.close
+    end
+
+    readers = [out_r, err_r].collect { |io| Thread.new { io.read } }
+    waiter = Thread.new { Process.wait2(pid).last }
+    status = if waiter.join(@gh_timeout)
+      waiter.value
+    else
+      # Kill the whole process group so children holding the pipes die too.
+      begin
+        Process.kill("KILL", -pid)
+      rescue SystemCallError
+        nil
+      end
+      waiter.join
+      :timeout
+    end
+    [status, *readers.collect(&:value)]
+  ensure
+    out_r&.close
+    err_r&.close
+  end
 end

metadata

@@ -1,27 +1,27 @@
 --- !ruby/object:Gem::Specification
 name: git-trim
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.3.0
 platform: ruby
 authors:
 - Christopher Petersen
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-10-03 00:00:00.000000000 Z
+date: 2026-11-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.16'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.16'
 - !ruby/object:Gem::Dependency
@@ -61,6 +61,8 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ci.yml"
+- ".github/workflows/release.yml"
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"
@@ -74,7 +76,7 @@ files:
 - git-trim.gemspec
 - lib/git-trim.rb
 - lib/git-trim/version.rb
-homepage: https://github.com/assaydepot/git-trim
+homepage: https://github.com/cpetersen/git-trim
 licenses:
 - MIT
 metadata: {}
@@ -94,7 +96,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
 summary: A script to remove all merged branches that aren't protected.