codepulse 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dfc914ce32e60fc464e2563c3da95b72889ac156e927f70ff7c0082254e5aaf2
-  data.tar.gz: c872a7873251365f85bce4713134c60b514d1854ebe56ea888cab1031bd923b8
+  metadata.gz: abda4d25af0e7f676c6d343518ebdb358a8fe6452858bfabdfa618ff7822d25f
+  data.tar.gz: dbd76b1a6eb56bf62590547efd31a8acfaba98ad1544f8b58bffee66f0e8e2b1
 SHA512:
-  metadata.gz: 531c38b79a0b09e73f427cf3d860ca16822df1b7797435375618d19feea280a8318791b3cf943dd3342b0675e5cf67cbc7c847bb35beddafb0e8faedfd9509df
-  data.tar.gz: 0be7777e2c2640f7a2ed9f3b5939cad157af98de7f825bc64e39cf27ffde1aa0324cd1e6cc8b7b1a7234eb0dadbfeb6330037f4df4b03db978a941f9662bb6bd
+  metadata.gz: ebeb4512532343b4aba2ec8128ce39d9fa4a6732b4b6b3a815c31f4cbc2c56cb372b8b9da8a2cf4cb2861521c270c6ccbde63c9b885f6eef870106e0f9e9d254
+  data.tar.gz: 9c2a4071d6fa1280f08e24b7aa38f05c9932df4e278d30c4c9dd0122155b062174b628b1b271e168059a7d67b7e59c6d554414d8750c62353ddc388670e0fe8c

data/README.md

@@ -1,6 +1,10 @@
 # Codepulse
 
-Terminal tool to analyze GitHub pull request pickup times, merge times, and sizes using the `gh` CLI.
+[![Gem Version](https://badge.fury.io/rb/codepulse.svg)](https://badge.fury.io/rb/codepulse)
+![Build](https://github.com/WorkBright/codepulse/actions/workflows/ci.yml/badge.svg)
+
+
+Measure how fast your team picks up and merges pull requests. Powered by the GitHub CLI.
 
 ## Installation
 
@@ -23,8 +27,8 @@ gem install codepulse
 ```sh
 git clone https://github.com/WorkBright/codepulse.git
 cd codepulse
-bundle install
-rake install
+gem build codepulse.gemspec
+gem install codepulse-*.gem
 ```
 
 ## Usage
@@ -35,6 +39,7 @@ codepulse
 
 # Or specify explicitly
 codepulse owner/repo
+
 ```
 
 ### Options
@@ -42,8 +47,9 @@ codepulse owner/repo
 | Option | Description | Default |
 |--------|-------------|---------|
 | `-s`, `--state STATE` | `open`, `closed`, or `all` | `all` |
-| `-l`, `--limit COUNT` | Max PRs to fetch | auto (5 × business-days) |
+| `-l`, `--limit COUNT` | Max PRs to fetch | auto |
 | `--business-days DAYS` | PRs from last N business days | `7` |
+| `--date-range RANGE` | Date range (`YYYY-MM-DD..YYYY-MM-DD`) | — |
 | `--details` | Show individual PR table (sorted by slowest pickup) | off |
 | `--gh-command PATH` | Custom `gh` executable path | `gh` |
 
@@ -61,6 +67,9 @@ codepulse rails/rails --details
 
 # Last 30 business days, limit 50 PRs
 codepulse rails/rails --business-days 30 --limit 50
+
+# Metrics for a specific date range
+codepulse rails/rails --date-range 2025-10-01..2025-12-31
 ```
 
 ## Output
@@ -105,11 +114,14 @@ codepulse rails/rails --business-days 30 --limit 50
 ## Development
 
 ```sh
+# Run local version without installing (picks up your changes immediately)
+bin/codepulse owner/repo
+
 # Run tests
 rake test
 
 # Lint
-bundle exec rubocop
+rubocop
 
 # Build and install locally
 rake install

data/lib/codepulse/base_client.rb

@@ -1,72 +1,12 @@
 # frozen_string_literal: true
 
 require "json"
-require "uri"
 
 module Codepulse
-  # Shared GitHub API client logic for fetching PRs, reviews, and comments.
+  # Shared GitHub API client utilities.
   module BaseClient
-    REPO_FORMAT = %r{\A[^/]+/[^/]+\z}
-
-    # Fetches pull requests with pagination, then fetches full details for each.
-    def pull_requests(repository, state:, limit:)
-      ensure_repository_format(repository)
-      per_page = [limit, 100].min
-      page = 1
-      collected = []
-
-      while collected.length < limit
-        response = api_get(
-          "/repos/#{repository}/pulls",
-          state: state,
-          per_page: per_page,
-          page: page
-        )
-        break if response.empty?
-
-        collected.concat(response)
-        break if response.length < per_page
-
-        page += 1
-      end
-
-      limited = collected.first(limit)
-      fetch_pull_request_details(repository, limited)
-    end
-
-    def pull_request_reviews(repository, number)
-      ensure_repository_format(repository)
-      api_get("/repos/#{repository}/pulls/#{number}/reviews", per_page: 100)
-    end
-
-    def pull_request_comments(repository, number)
-      ensure_repository_format(repository)
-      api_get("/repos/#{repository}/pulls/#{number}/comments", per_page: 100)
-    end
-
-    def issue_comments(repository, number)
-      ensure_repository_format(repository)
-      api_get("/repos/#{repository}/issues/#{number}/comments", per_page: 100)
-    end
-
     private
 
-    def api_get(_path, _query_params = {})
-      raise NotImplementedError, "Subclasses must implement api_get"
-    end
-
-    def ensure_repository_format(repository)
-      return if repository.to_s.match?(REPO_FORMAT)
-
-      raise ConfigurationError, "Repository must be in the format owner/name"
-    end
-
-    def fetch_pull_request_details(repository, pull_requests)
-      pull_requests.map do |pull_request|
-        api_get("/repos/#{repository}/pulls/#{pull_request["number"]}")
-      end
-    end
-
     def parse_json(body)
       return {} if body.to_s.strip.empty?
 
@@ -74,11 +14,5 @@ module Codepulse
     rescue JSON::ParserError => error
       raise ApiError, "Failed to parse response: #{error.message}"
     end
-
-    def encode_query(query_params)
-      return "" if query_params.empty?
-
-      "?#{URI.encode_www_form(query_params)}"
-    end
   end
 end

data/lib/codepulse/cli.rb

@@ -3,6 +3,7 @@
 require "optparse"
 require "open3"
 require "json"
+require "date"
 
 module Codepulse
   class CLI
@@ -11,7 +12,8 @@ module Codepulse
     DEFAULT_STATE = "all"
     DEFAULT_BUSINESS_DAYS = 7
     PRS_PER_BUSINESS_DAY = 5
-    MAX_AUTO_LIMIT = 200
+    MAX_BUSINESS_DAYS_LIMIT = 500
+    MAX_DATE_RANGE_LIMIT = 1000
 
     def self.start(argument_list = ARGV)
       new(argument_list).run
@@ -24,7 +26,8 @@ module Codepulse
         limit: nil,
         gh_command: GhCliClient::DEFAULT_COMMAND,
         business_days_back: DEFAULT_BUSINESS_DAYS,
-        details: false
+        details: false,
+        date_range: nil
       }
     end
 
@@ -35,17 +38,11 @@ module Codepulse
       repo = @options.fetch(:repo)
       client = GhCliClient.new(command: @options.fetch(:gh_command))
 
-      pull_requests = fetch_pull_requests(client, repo)
-      pull_requests = apply_filters(pull_requests)
-      metrics = calculate_metrics(client, repo, pull_requests)
-
-      clear_status
-      Formatter.new.output(
-        metrics,
-        repo: repo,
-        detailed: @options.fetch(:details),
-        business_days: @options.fetch(:business_days_back)
-      )
+      if @options[:date_range]
+        run_date_range_mode(client, repo)
+      else
+        run_business_days_mode(client, repo)
+      end
     rescue OptionParser::ParseError => error
       $stderr.puts "Error: #{error.message}"
       $stderr.puts
@@ -61,6 +58,59 @@ module Codepulse
 
     private
 
+    def run_business_days_mode(client, repo)
+      pull_requests, limit = fetch_pull_requests(client, repo)
+      warn_if_limit_reached(pull_requests.length, limit)
+      cutoff = business_days_cutoff(@options[:business_days_back])
+      pull_requests = apply_filters(pull_requests, start_time: cutoff)
+      metrics = calculate_metrics(client, repo, pull_requests)
+
+      clear_status
+      Formatter.new.output(
+        metrics,
+        repo: repo,
+        detailed: @options.fetch(:details),
+        business_days: @options.fetch(:business_days_back)
+      )
+    end
+
+    def run_date_range_mode(client, repo)
+      from_date, to_date = @options[:date_range]
+      start_time = date_to_time(from_date)
+      end_time = end_of_day(date_to_time(to_date))
+      pull_requests, limit = fetch_pull_requests_for_range(client, repo, [start_time, end_time])
+      warn_if_limit_reached(pull_requests.length, limit)
+      pull_requests = apply_filters(pull_requests, start_time: start_time, end_time: end_time)
+      metrics = calculate_metrics(client, repo, pull_requests)
+
+      clear_status
+      Formatter.new.output(
+        metrics,
+        repo: repo,
+        detailed: @options.fetch(:details),
+        date_range: [start_time, end_time]
+      )
+    end
+
+    def date_to_time(date)
+      Time.new(date.year, date.month, date.day)
+    end
+
+    def fetch_pull_requests_for_range(client, repo, date_range)
+      start_time, end_time = date_range
+      status "Fetching pull requests from #{repo} for #{start_time.strftime('%b %Y')} - #{end_time.strftime('%b %Y')}..."
+      limit = @options[:limit] || MAX_DATE_RANGE_LIMIT
+      prs = client.pull_requests_with_activity(repo, state: @options.fetch(:state), limit: limit)
+      [prs, limit]
+    end
+
+    def warn_if_limit_reached(count, limit)
+      return unless count >= limit
+
+      $stderr.puts "Warning: Fetched #{count} PRs (limit reached). Results may be incomplete. Use --limit to fetch more."
+    end
+
+
     def parse_options
       option_parser.parse!(@argument_list)
       @options[:repo] = @argument_list.shift if @argument_list.any?
@@ -91,6 +141,10 @@ module Codepulse
           @options[:details] = true
         end
 
+        parser.on("--date-range RANGE", "Date range (YYYY-MM-DD..YYYY-MM-DD)") do |range|
+          @options[:date_range] = parse_date_range(range)
+        end
+
         parser.on("-h", "--help", "Show help") do
           puts parser
           exit
@@ -106,6 +160,17 @@ module Codepulse
       validate_positive_integer(:business_days_back, "business-days")
     end
 
+    def parse_date_range(range)
+      match = range.match(/\A(\d{4}-\d{2}-\d{2})\.\.(\d{4}-\d{2}-\d{2})\z/)
+      raise OptionParser::InvalidArgument, "invalid date range format, use YYYY-MM-DD..YYYY-MM-DD" unless match
+
+      from_date = Date.parse(match[1])
+      to_date = Date.parse(match[2])
+      raise OptionParser::InvalidArgument, "start date must be before end date" if from_date > to_date
+
+      [from_date, to_date]
+    end
+
     def validate_state
       return if %w[open closed all].include?(@options[:state])
 
@@ -122,8 +187,10 @@ module Codepulse
 
     def fetch_pull_requests(client, repo)
       limit = effective_limit
-      status "Fetching pull requests from #{repo}..."
-      client.pull_requests(repo, state: @options.fetch(:state), limit: limit)
+      business_days = @options.fetch(:business_days_back)
+      status "Fetching pull requests from #{repo} for the last #{business_days} business days..."
+      prs = client.pull_requests_with_activity(repo, state: @options.fetch(:state), limit: limit)
+      [prs, limit]
     end
 
     def effective_limit
@@ -131,25 +198,30 @@ module Codepulse
 
       business_days = @options.fetch(:business_days_back)
       calculated = business_days * PRS_PER_BUSINESS_DAY
-      [calculated, MAX_AUTO_LIMIT].min
+      [calculated, MAX_BUSINESS_DAYS_LIMIT].min
     end
 
-    def apply_filters(pull_requests)
+    def apply_filters(pull_requests, start_time:, end_time: nil)
       status "Filtering #{pull_requests.length} pull requests..."
       pull_requests = exclude_closed_unmerged(pull_requests)
+      filter_by_time_range(pull_requests, start_time, end_time)
+    end
+
+    def filter_by_time_range(pull_requests, start_time, end_time)
+      pull_requests.select do |pr|
+        created_at = parse_time(pr["created_at"])
+        next false unless created_at && created_at >= start_time
 
-      cutoff_time = business_days_cutoff(@options[:business_days_back])
-      pull_requests = filter_by_business_days(pull_requests, cutoff_time) if cutoff_time
-      pull_requests
+        end_time.nil? || created_at <= end_time
+      end
     end
 
-    def calculate_metrics(client, repo, pull_requests)
+    def calculate_metrics(_client, _repo, pull_requests)
       status "Calculating metrics for #{pull_requests.length} pull requests..."
-      calculator = MetricsCalculator.new(client: client)
+      calculator = MetricsCalculator.new
 
-      pull_requests.each_with_index.map do |pull_request, index|
-        status "  Analyzing PR ##{pull_request["number"]} (#{index + 1}/#{pull_requests.length})..."
-        calculator.metrics_for_pull_request(repo, pull_request)
+      pull_requests.map do |pull_request|
+        calculator.metrics_for_pull_request(pull_request)
       end
     end
 
@@ -159,13 +231,6 @@ module Codepulse
       end
     end
 
-    def filter_by_business_days(pull_requests, cutoff_time)
-      pull_requests.select do |pull_request|
-        created_at = parse_time(pull_request["created_at"])
-        created_at && created_at >= cutoff_time
-      end
-    end
-
     def detect_repo_from_git
       stdout, _stderr, status = Open3.capture3(@options[:gh_command], "repo", "view", "--json", "nameWithOwner")
       return nil unless status.success?

data/lib/codepulse/formatter.rb

@@ -8,9 +8,9 @@ module Codepulse
     MIN_FOR_P95 = 50 # Minimum data points to show p95
 
     # Main entry point: outputs metrics as a formatted report.
-    def output(metrics, repo:, detailed: true, business_days: nil)
+    def output(metrics, repo:, detailed: true, business_days: nil, date_range: nil)
       if metrics.empty?
-        print_no_pull_requests_message(repo, business_days)
+        print_no_pull_requests_message(repo, business_days, date_range)
         return
       end
 
@@ -22,14 +22,18 @@ module Codepulse
         excluded: without_pickup,
         repo: repo,
         business_days: business_days,
+        date_range: date_range,
         detailed: detailed
       )
     end
 
     private
 
-    def print_no_pull_requests_message(repo, business_days)
-      if business_days
+    def print_no_pull_requests_message(repo, business_days, date_range = nil)
+      if date_range
+        start_time, end_time = date_range
+        puts "No pull requests found for #{repo} from #{format_date(start_time)} to #{format_date(end_time)}."
+      elsif business_days
         puts "No pull requests found for #{repo} in the last #{business_days} business days."
         puts "To look further back, use: codepulse --business-days N #{repo}"
       else
@@ -37,8 +41,8 @@ module Codepulse
       end
     end
 
-    def output_report(metrics, excluded:, repo:, business_days:, detailed:)
-      print_report_header(repo, business_days)
+    def output_report(metrics, excluded:, repo:, business_days:, date_range:, detailed:)
+      print_report_header(repo, business_days, date_range)
       puts
       print_definitions
       puts
@@ -90,20 +94,25 @@ module Codepulse
       output_excluded_prs(excluded)
     end
 
-    def print_report_header(repo, business_days)
-      time_period = build_time_period(business_days)
+    def print_report_header(repo, business_days, date_range = nil)
+      time_period = build_time_period(business_days, date_range)
       puts "=" * REPORT_WIDTH
       puts "  Codepulse PR Metrics Report | #{time_period}"
       puts "  #{repo}"
       puts "=" * REPORT_WIDTH
     end
 
-    def build_time_period(business_days)
-      return "all time" unless business_days
-
-      end_date = Time.now
-      start_date = calculate_start_date(business_days)
-      "Last #{business_days} business days (#{format_date(start_date)} - #{format_date(end_date)})"
+    def build_time_period(business_days, date_range = nil)
+      if date_range
+        start_time, end_time = date_range
+        "#{format_date(start_time)} - #{format_date(end_time)}"
+      elsif business_days
+        end_date = Time.now
+        start_date = calculate_start_date(business_days)
+        "Last #{business_days} business days (#{format_date(start_date)} - #{format_date(end_date)})"
+      else
+        "all time"
+      end
     end
 
     def calculate_start_date(business_days)

data/lib/codepulse/gh_cli_client.rb

@@ -1,27 +1,135 @@
 # frozen_string_literal: true
 
 require "open3"
+require "json"
 
 module Codepulse
   class GhCliClient
     include BaseClient
 
     DEFAULT_COMMAND = "gh"
+    GRAPHQL_PAGE_SIZE = 50
+    ACTIVITY_PAGE_SIZE = 50
 
     def initialize(command: DEFAULT_COMMAND)
       @command = command
       verify_cli_available
     end
 
+    # Fetches PRs with reviews and comments in a single GraphQL query.
+    # Returns array of PR hashes with embedded :reviews, :review_comments, :issue_comments.
+    def pull_requests_with_activity(repository, state:, limit:)
+      owner, name = repository.split("/", 2)
+      raise ConfigurationError, "Repository must be in the format owner/name" unless owner && name
+
+      fetch_all_pull_requests(owner, name, graphql_states(state), limit)
+    end
+
     private
 
-    def api_get(path, query_params = {})
-      full_path = "#{path}#{encode_query(query_params)}"
-      stdout, stderr, status = Open3.capture3(@command, "api", full_path)
+    def fetch_all_pull_requests(owner, name, states, limit)
+      pull_requests = []
+      cursor = nil
+
+      loop do
+        batch_size = [GRAPHQL_PAGE_SIZE, limit - pull_requests.length].min
+        response = graphql_query(build_query(owner, name, states, batch_size, cursor))
+        nodes, page_info = extract_pr_data(response)
+        break if nodes.empty?
+
+        pull_requests.concat(nodes.map { |node| transform_graphql_pr(node) })
+        break if pull_requests.length >= limit || !page_info["hasNextPage"]
+
+        cursor = page_info["endCursor"]
+      end
+
+      pull_requests.first(limit)
+    end
+
+    def extract_pr_data(response)
+      pr_data = response.dig("data", "repository", "pullRequests") || {}
+      nodes = pr_data["nodes"] || []
+      page_info = pr_data["pageInfo"] || {}
+      [nodes, page_info]
+    end
+
+    def graphql_states(state)
+      case state
+      when "open" then %w[OPEN]
+      when "closed" then %w[CLOSED MERGED]
+      else %w[OPEN CLOSED MERGED]
+      end
+    end
+
+    def build_query(owner, name, states, batch_size, cursor)
+      after_clause = cursor ? ", after: \"#{escape_graphql(cursor)}\"" : ""
+      states_clause = states.join(", ")
+
+      <<~GRAPHQL
+        {
+          repository(owner: "#{escape_graphql(owner)}", name: "#{escape_graphql(name)}") {
+            pullRequests(first: #{batch_size}, states: [#{states_clause}], orderBy: {field: CREATED_AT, direction: DESC}#{after_clause}) {
+              pageInfo { hasNextPage endCursor }
+              nodes {
+                number title state createdAt mergedAt additions deletions changedFiles
+                author { login }
+                reviews(first: #{ACTIVITY_PAGE_SIZE}) { nodes { submittedAt author { login } } }
+                reviewThreads(first: #{ACTIVITY_PAGE_SIZE}) { nodes { comments(first: #{ACTIVITY_PAGE_SIZE}) { nodes { createdAt author { login } } } } }
+                comments(first: #{ACTIVITY_PAGE_SIZE}) { nodes { createdAt author { login } } }
+              }
+            }
+          }
+        }
+      GRAPHQL
+    end
+
+    def transform_graphql_pr(node)
+      {
+        "number" => node["number"],
+        "title" => node["title"],
+        "state" => node["state"]&.downcase,
+        "created_at" => node["createdAt"],
+        "merged_at" => node["mergedAt"],
+        "additions" => node["additions"],
+        "deletions" => node["deletions"],
+        "changed_files" => node["changedFiles"],
+        "user" => { "login" => node.dig("author", "login") },
+        "reviews" => transform_reviews(node),
+        "review_comments" => transform_review_comments(node),
+        "issue_comments" => transform_issue_comments(node)
+      }
+    end
+
+    def transform_reviews(node)
+      (node.dig("reviews", "nodes") || []).map do |review|
+        { "submitted_at" => review["submittedAt"], "user" => { "login" => review.dig("author", "login") } }
+      end
+    end
+
+    def transform_review_comments(node)
+      (node.dig("reviewThreads", "nodes") || []).flat_map do |thread|
+        (thread.dig("comments", "nodes") || []).map do |comment|
+          { "created_at" => comment["createdAt"], "user" => { "login" => comment.dig("author", "login") } }
+        end
+      end
+    end
+
+    def transform_issue_comments(node)
+      (node.dig("comments", "nodes") || []).map do |comment|
+        { "created_at" => comment["createdAt"], "user" => { "login" => comment.dig("author", "login") } }
+      end
+    end
+
+    def escape_graphql(value)
+      value.to_s.gsub("\\", "\\\\").gsub('"', '\\"')
+    end
+
+    def graphql_query(query)
+      stdout, stderr, status = Open3.capture3(@command, "api", "graphql", "-f", "query=#{query}")
 
       unless status.success?
         message = stderr.to_s.strip.empty? ? stdout.to_s.strip : stderr.to_s.strip
-        raise ApiError, "gh api #{full_path} failed: #{message}"
+        raise ApiError, "GraphQL query failed: #{message}"
       end
 
       parse_json(stdout)

data/lib/codepulse/metrics_calculator.rb

@@ -69,15 +69,16 @@ module Codepulse
       "allstar[bot]"
     ].freeze
 
-    def initialize(client:)
-      @client = client
+    def initialize
+      # No client needed - data is pre-fetched via GraphQL
     end
 
     # Returns a hash of metrics for a single PR.
-    def metrics_for_pull_request(repository, pull_request)
+    # Expects pull_request to include :reviews, :review_comments, :issue_comments from GraphQL.
+    def metrics_for_pull_request(pull_request)
       created_at = parse_time(pull_request["created_at"])
       merged_at = parse_time(pull_request["merged_at"])
-      pickup_event = find_pickup_event(repository, pull_request, created_at)
+      pickup_event = find_pickup_event(pull_request, created_at)
       pickup_seconds = pickup_event ? business_seconds_between(created_at, pickup_event.fetch(:timestamp)) : nil
       merge_seconds = merged_at && created_at ? business_seconds_between(created_at, merged_at) : nil
 
@@ -101,12 +102,12 @@ module Codepulse
     private
 
     # Finds the first non-author, non-bot response (review, comment, or issue comment).
-    def find_pickup_event(repository, pull_request, created_at)
-      pull_number = pull_request["number"]
+    # Uses pre-fetched data from GraphQL query.
+    def find_pickup_event(pull_request, created_at)
       author_login = pull_request.dig("user", "login")
 
       review_event = earliest_event(
-        @client.pull_request_reviews(repository, pull_number),
+        pull_request["reviews"] || [],
         author_login: author_login,
         time_key: "submitted_at",
         actor_path: %w[user login],
@@ -114,7 +115,7 @@ module Codepulse
       )
 
       review_comment_event = earliest_event(
-        @client.pull_request_comments(repository, pull_number),
+        pull_request["review_comments"] || [],
         author_login: author_login,
         time_key: "created_at",
         actor_path: %w[user login],
@@ -122,7 +123,7 @@ module Codepulse
       )
 
       issue_comment_event = earliest_event(
-        @client.issue_comments(repository, pull_number),
+        pull_request["issue_comments"] || [],
         author_login: author_login,
         time_key: "created_at",
         actor_path: %w[user login],

data/lib/codepulse.rb

@@ -9,5 +9,5 @@ require_relative "codepulse/formatter"
 require_relative "codepulse/cli"
 
 module Codepulse
-  VERSION = "0.1.3"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: codepulse
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - Patrick Navarro
 bindir: bin
 cert_chain: []
-date: 2025-12-27 00:00:00.000000000 Z
+date: 2026-01-11 00:00:00.000000000 Z
 dependencies: []
 description: Terminal tool to analyze GitHub pull request pickup times, merge times,
   and sizes using the gh CLI.