codepulse 0.1.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 99017cc087fdcfba362ff60116de661091bd1b13d5d2eb400bc8f89da0909f03
-  data.tar.gz: 9f1af9cc518ec5ef016a1bb878d66de50f19bd9bf0b6955d5fb07162e3c5b95d
+  metadata.gz: a8a474f7a151ae2edf2f67c74aa3f8347cef950039b6f87777455206afccdc94
+  data.tar.gz: 65af6a80141c769edbc30571a818a5af805d6a8e3366a93a8e04c9d1ab5d7d58
 SHA512:
-  metadata.gz: b2b4d17ff35c834f4d7ba656edbb412c7bc4942ae3d7d1eea74b88007af0f72da105383a419a0ccb0170095e3e9d95bc01fbc02bf52f94f3794eb77b4cf5cd62
-  data.tar.gz: cdc071c5a7e113ba93bf00b6f9df4e8127fa0feed5f66e9d8b7820ca211847e91d7597b6031e296d4646f696c372a2acdb59aacd87e6df64885c3cddbe63bf03
+  metadata.gz: c6664055a79fbc73d73cbd2293cb16ef28f3a8417baad8b97f3c8f97582e82eb0d8a5724ac69d7280d112e90f72a47c24af2d4ed133b3d4e1f45fd9df26e44ff
+  data.tar.gz: 20b9addb4cbd4bd6d8874edc4509d355e1c2a688ee25d20947b6bb590dd5bd8df8d689725f1c6b25f399bf6e917c92b8cec81f484570f9bee4a110b7ceb836c3

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

@@ -122,8 +122,9 @@ 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..."
+      client.pull_requests_with_activity(repo, state: @options.fetch(:state), limit: limit)
     end
 
     def effective_limit
@@ -143,13 +144,12 @@ module Codepulse
       pull_requests
     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
 

data/lib/codepulse/formatter.rb

@@ -206,11 +206,11 @@ module Codepulse
       sorted = values.sort
       average_seconds = (values.sum / values.length.to_f).round
 
-      puts "  Average #{label.downcase}:  #{format_duration_compact(average_seconds)}"
-      puts "  Median #{label.downcase}:   #{format_duration_compact(percentile_value(sorted, 50))}"
-      puts "  p95 #{label.downcase}:      #{format_duration_compact(percentile_value(sorted, 95))}" if values.length >= MIN_FOR_P95
-      puts "  Fastest #{label.downcase}: #{format_duration_compact(sorted.first)}"
-      puts "  Slowest #{label.downcase}: #{format_duration_compact(sorted.last)}"
+      print_stat_line("Average", label, format_duration_compact(average_seconds))
+      print_stat_line("Median", label, format_duration_compact(median_value(sorted)))
+      print_stat_line("p95", label, format_duration_compact(percentile_value(sorted, 95))) if values.length >= MIN_FOR_P95
+      print_stat_line("Fastest", label, format_duration_compact(sorted.first))
+      print_stat_line("Slowest", label, format_duration_compact(sorted.last))
     end
 
     def print_number_stats(label, values)
@@ -219,11 +219,16 @@ module Codepulse
       sorted = values.sort
       average_value = (values.sum / values.length.to_f).round(1)
 
-      puts "  Average #{label.downcase}:  #{format_number_compact(average_value)}"
-      puts "  Median #{label.downcase}:   #{format_number_compact(percentile_value(sorted, 50))}"
-      puts "  p95 #{label.downcase}:      #{format_number_compact(percentile_value(sorted, 95))}" if values.length >= MIN_FOR_P95
-      puts "  Min #{label.downcase}:      #{format_number_compact(sorted.first)}"
-      puts "  Max #{label.downcase}:      #{format_number_compact(sorted.last)}"
+      print_stat_line("Average", label, format_number_compact(average_value))
+      print_stat_line("Median", label, format_number_compact(median_value(sorted)))
+      print_stat_line("p95", label, format_number_compact(percentile_value(sorted, 95))) if values.length >= MIN_FOR_P95
+      print_stat_line("Min", label, format_number_compact(sorted.first))
+      print_stat_line("Max", label, format_number_compact(sorted.last))
+    end
+
+    def print_stat_line(prefix, label, value)
+      stat_label = "#{prefix} #{label.downcase}:"
+      puts "  #{stat_label.ljust(28)} #{value}"
     end
 
     def truncate(value, length)
@@ -274,7 +279,7 @@ module Codepulse
     end
 
     # Returns the value at the given percentile from a sorted array.
-    # Uses nearest-rank method: p50 = median, p95 = 95th percentile.
+    # Uses nearest-rank method for percentiles like p95.
     def percentile_value(sorted_values, percentile)
       count = sorted_values.length
       rank = (percentile / 100.0 * count).ceil
@@ -282,6 +287,21 @@ module Codepulse
       sorted_values[index]
     end
 
+    # Returns the median of a sorted array.
+    # For odd counts, returns the middle value.
+    # For even counts, returns the average of the two middle values.
+    def median_value(sorted_values)
+      count = sorted_values.length
+      return nil if count.zero?
+
+      if count.odd?
+        sorted_values[count / 2]
+      else
+        mid = count / 2
+        (sorted_values[mid - 1] + sorted_values[mid]) / 2.0
+      end
+    end
+
     def format_number_compact(value)
       return "0" if value.nil?
 

data/lib/codepulse/gh_cli_client.rb

@@ -1,27 +1,131 @@
 # 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: \"#{cursor}\"" : ""
+      states_clause = states.join(", ")
+
+      <<~GRAPHQL
+        {
+          repository(owner: "#{owner}", name: "#{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 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.2"
+  VERSION = "0.1.4"
 end

metadata

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