gemstar 1.1.1 → 1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aba5f74f93dc292f713a6f5d1a824cc04d7601fffac736f075c75f08ea769ff7
-  data.tar.gz: f13a06cba387d9ae4ec744ed6e9703bbe8c1aea95cd8f27ab2f4efd816af33d6
+  metadata.gz: c6157dce9498afdbda3d014af6e1e4e20e7477d73bd3b12129c0d754df28f4f7
+  data.tar.gz: c7fcc69688c21fea79ead9b9f762d026a5b57e5c597206171fe6faaeb5555db1
 SHA512:
-  metadata.gz: e45c7adfbfae8779801141084c0097d57be63415398c1a1b695a090042aa1c8fc6c94764275963aca7ef361de4e63f38f39a172b5158814282cd43ce865f5556
-  data.tar.gz: ad082b18db97c9f7a1a1c74de309fad18ca282cdd41c42918b27818b7bcc6da895fc9320660f35a0546028b75ed56726a5a545b7e709f4eb82d9a49237f938f5
+  metadata.gz: 89b29cc2ff749b326e1e8dfd2cc98279b45d05a961b1d1aab8ea0cfcc9e4c2acab238fbaf40c4b947b0c9201a6254a80beb5102aa8c28c348d1afde67ced305a
+  data.tar.gz: 55182c82a720bd6a5baf9ab26e7369df6c834c24ae959b05301a40da16ac0e447a6ada98ac2461064ba137f9e944191026c48084d1ec2f95e923c0cda6b19265

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Change Log
 
+## 1.2
+
+- Server: Cache warmer now pre-fetches package detail pages so browsing warmed gems is faster.
+- Server: Manual browser reloads now refresh the selected package details, including metadata and release notes caches.
+- Server: Fetch GitHub release bodies through the GitHub Releases API before falling back to HTML scraping.
+- Server: Add explicit "Use GitHub CLI" fallback for GitHub-backed release notes when automatic release discovery misses a page.
+
 ## 1.1.1
 
 - Server: Show release dates for changelog entries.

data/lib/gemstar/cache_warmer.rb

@@ -5,10 +5,11 @@ module Gemstar
   class CacheWarmer
     DEFAULT_THREADS = 10
 
-    def initialize(io: $stderr, debug: false, thread_count: DEFAULT_THREADS)
+    def initialize(io: $stderr, debug: false, thread_count: DEFAULT_THREADS, detail_cache_fetcher: nil)
       @io = io
       @debug = debug
       @thread_count = thread_count
+      @detail_cache_fetcher = detail_cache_fetcher
       @mutex = Mutex.new
       @condition = ConditionVariable.new
       @queue = []
@@ -21,6 +22,8 @@ module Gemstar
       @completed_count = 0
     end
 
+    attr_writer :detail_cache_fetcher
+
     def enqueue_many(package_states)
       states = normalize_package_states(package_states)
 
@@ -120,13 +123,22 @@ module Gemstar
 
     def warm_cache_for_package(package_state)
       metadata = metadata_adapter_for(package_state)
-      return unless metadata
+      metadata&.warm_cache(versions: package_versions(package_state))
 
-      metadata.warm_cache(versions: package_versions(package_state))
+      warm_detail_cache_for_package(package_state)
     rescue StandardError => e
       log "Cache refresh failed for #{package_label(package_state)}: #{e.class}: #{e.message}"
     end
 
+    def warm_detail_cache_for_package(package_state)
+      fetcher = @detail_cache_fetcher
+      return unless fetcher
+
+      Array(package_state[:detail_cache_contexts]).each do |context|
+        fetcher.call(package_state, context)
+      end
+    end
+
     def log_progress(package_name, current)
       return unless @debug
       return unless current <= 5 || (current % 25).zero?

data/lib/gemstar/change_log.rb

@@ -2,11 +2,16 @@
 require "cgi"
 require "date"
 require "json"
+require "open3"
 require "time"
+require "timeout"
+require "uri"
+require_relative "cache"
 
 module Gemstar
   class ChangeLog
     @@candidates_found = Hash.new(0)
+    GITHUB_CLI_TIMEOUT = 8
     DEFAULT_CHANGELOG_PATHS = %w[
       CHANGELOG.md releases.md CHANGES.md
       Changelog.md changelog.md ChangeLog.md
@@ -54,7 +59,7 @@ module Gemstar
       result
     end
 
-    def sections_for_versions(versions, cache_only: false, force_refresh: false)
+    def sections_for_versions(versions, cache_only: false, force_refresh: false, use_github_cli: false)
       requested_versions = normalize_requested_versions(versions)
       return {} if requested_versions.empty?
 
@@ -75,7 +80,8 @@ module Gemstar
             repo_uri,
             version,
             cache_only: false,
-            force_refresh: force_refresh
+            force_refresh: force_refresh,
+            use_github_cli: use_github_cli
           )
           result.merge!(specific_release) if specific_release
         end
@@ -378,18 +384,21 @@ module Gemstar
     end
 
     def parse_github_release_sections(cache_only: false, force_refresh: false)
-      begin
-        require "nokogiri"
-      rescue LoadError
-        return {}
-      end
-
       repo_uri = @metadata&.repo_uri(cache_only: cache_only, force_refresh: force_refresh)
       return {} unless repo_uri&.include?("github.com")
 
       url = github_releases_url(repo_uri)
       return {} unless url
 
+      api_sections = parse_github_api_release_sections(repo_uri, cache_only: cache_only, force_refresh: force_refresh)
+      return api_sections unless api_sections.empty?
+
+      begin
+        require "nokogiri"
+      rescue LoadError
+        return {}
+      end
+
       html = if cache_only
         Cache.peek("releases-#{url}")
       else
@@ -506,11 +515,90 @@ module Gemstar
       "#{repo}/tags"
     end
 
-    def parse_specific_github_release_pages(repo_uri, version, cache_only:, force_refresh:)
+    def github_releases_api_url(repo_uri = @metadata&.repo_uri)
+      repo_path = github_repo_path(repo_uri)
+      return nil unless repo_path
+
+      "https://api.github.com/repos/#{repo_path}/releases"
+    end
+
+    def github_release_api_url(repo_uri, tag)
+      repo_path = github_repo_path(repo_uri)
+      return nil unless repo_path
+
+      "https://api.github.com/repos/#{repo_path}/releases/tags/#{URI.encode_www_form_component(tag)}"
+    end
+
+    def github_repo_path(repo_uri)
+      uri = URI(repo_uri.to_s)
+      return nil unless uri.host.to_s.end_with?("github.com")
+
+      segments = uri.path.to_s.split("/").reject(&:empty?)
+      return nil if segments.length < 2
+
+      segments.take(2).join("/")
+    rescue URI::InvalidURIError
+      nil
+    end
+
+    def parse_github_api_release_sections(repo_uri, cache_only:, force_refresh:)
+      url = github_releases_api_url(repo_uri)
+      return {} unless url
+
+      json = if cache_only
+        Cache.peek("releases-api-#{url}")
+      else
+        Cache.fetch("releases-api-#{url}", force: force_refresh) do
+          begin
+            URI.open(url, "Accept" => "application/vnd.github+json", read_timeout: 8)&.read
+          rescue => e
+            puts "#{url}: #{e}" if Gemstar.debug?
+            nil
+          end
+        end
+      end
+
+      parse_github_api_releases(json)
+    end
+
+    def parse_github_api_releases(json)
+      releases = JSON.parse(json.to_s)
+      releases = [releases] if releases.is_a?(Hash)
+      return {} unless releases.is_a?(Array)
+
+      releases.each_with_object({}) do |release, sections|
+        next unless release.is_a?(Hash)
+
+        tag_name = (release["tag_name"] || release["tagName"]).to_s
+        next if tag_name.empty?
+        next unless github_tag_matches_metadata?(tag_name)
+
+        version = normalize_github_tag_version(tag_name)
+        next if version.to_s.empty?
+
+        body = release["body"].to_s.strip
+        title = release["name"].to_s.strip
+        content = body.empty? ? title : body
+        next if content.empty?
+
+        sections[version] ||= ["## #{version}\n", content]
+      end
+    rescue JSON::ParserError
+      {}
+    end
+
+    def parse_specific_github_release_pages(repo_uri, version, cache_only:, force_refresh:, use_github_cli: false)
       return {} unless repo_uri&.include?("github.com")
       return {} if version.to_s.empty?
 
-      github_release_tag_urls(repo_uri, version).each do |url|
+      github_tag_candidates(version).each do |tag|
+        cli_section = parse_specific_github_cli_release(repo_uri, tag, cache_only: cache_only, force_refresh: force_refresh) if use_github_cli
+        return cli_section if cli_section && !cli_section.empty?
+
+        api_section = parse_specific_github_api_release(repo_uri, tag, cache_only: cache_only, force_refresh: force_refresh)
+        return api_section unless api_section.empty?
+
+        url = github_release_tag_url(repo_uri, tag)
         html = if cache_only
           Cache.peek("releases-#{url}")
         else
@@ -533,6 +621,62 @@ module Gemstar
       {}
     end
 
+    def parse_specific_github_cli_release(repo_uri, tag_name, cache_only:, force_refresh:)
+      repo_path = github_repo_path(repo_uri)
+      return {} unless repo_path
+
+      cache_key = "releases-gh-#{repo_path}-#{tag_name}"
+      json = if cache_only
+        Cache.peek(cache_key)
+      else
+        Cache.fetch(cache_key, force: force_refresh) do
+          fetch_github_cli_release_json(repo_path, tag_name)
+        end
+      end
+
+      parse_github_api_releases(json)
+    end
+
+    def fetch_github_cli_release_json(repo_path, tag_name)
+      stdout, _stderr, status = nil
+      Timeout.timeout(GITHUB_CLI_TIMEOUT) do
+        stdout, _stderr, status = Open3.capture3(
+          "gh",
+          "release",
+          "view",
+          tag_name,
+          "--repo",
+          repo_path,
+          "--json",
+          "body,name,tagName"
+        )
+      end
+
+      status.success? ? stdout : nil
+    rescue Errno::ENOENT, Timeout::Error
+      nil
+    end
+
+    def parse_specific_github_api_release(repo_uri, tag_name, cache_only:, force_refresh:)
+      url = github_release_api_url(repo_uri, URI.decode_www_form_component(tag_name.to_s))
+      return {} unless url
+
+      json = if cache_only
+        Cache.peek("releases-api-#{url}")
+      else
+        Cache.fetch("releases-api-#{url}", force: force_refresh) do
+          begin
+            URI.open(url, "Accept" => "application/vnd.github+json", read_timeout: 8)&.read
+          rescue => e
+            puts "#{url}: #{e}" if Gemstar.debug?
+            nil
+          end
+        end
+      end
+
+      parse_github_api_releases(json)
+    end
+
     def parse_github_tag_sections(repo_uri, cache_only:, force_refresh:)
       return {} unless repo_uri&.include?("github.com")
 
@@ -760,11 +904,15 @@ module Gemstar
 
     def github_release_tag_urls(repo_url, version)
       github_tag_candidates(version).map do |tag|
-        encoded_tag = URI.encode_www_form_component(tag)
-        "#{repo_url}/releases/tag/#{encoded_tag}"
+        github_release_tag_url(repo_url, tag)
       end.uniq
     end
 
+    def github_release_tag_url(repo_url, tag)
+      encoded_tag = URI.encode_www_form_component(tag)
+      "#{repo_url}/releases/tag/#{encoded_tag}"
+    end
+
     def github_tag_candidates(version)
       return @metadata.github_tag_candidates(version) if @metadata.respond_to?(:github_tag_candidates)
 

data/lib/gemstar/commands/server.rb

@@ -1,6 +1,8 @@
 require_relative "command"
+require "rack/mock"
 require "socket"
 require "shellwords"
+require "uri"
 require "rbconfig"
 
 module Gemstar
@@ -45,7 +47,9 @@ module Gemstar
         projects = load_projects
         log_loaded_projects(projects)
         cache_warmer = build_cache_warmer
-        app = Gemstar::Web::App.build(projects: projects, config_home: Gemstar::Config.home_directory, cache_warmer: cache_warmer)
+        web_app = Gemstar::Web::App.build(projects: projects, config_home: Gemstar::Config.home_directory, cache_warmer: cache_warmer)
+        cache_warmer.detail_cache_fetcher = build_detail_cache_fetcher(web_app)
+        app = web_app
         app = Gemstar::RequestLogger.new(app, io: $stderr) if debug_request_logging?
 
         puts "Gemstar server listening on http://#{bind}:#{port}"
@@ -183,8 +187,21 @@ module Gemstar
       end
 
       def start_background_cache_refresh(projects, cache_warmer)
-        package_states = projects.flat_map do |project|
-          project.gem_states(from_revision_id: "worktree", to_revision_id: "worktree")
+        package_states = projects.flat_map.with_index do |project, project_index|
+          from_revision_id = project.default_from_revision_id
+          to_revision_id = "worktree"
+          states = project.gem_states(from_revision_id: from_revision_id, to_revision_id: to_revision_id)
+          detail_cache_contexts = detail_cache_contexts_for(
+            project: project,
+            project_index: project_index,
+            from_revision_id: from_revision_id,
+            to_revision_id: to_revision_id,
+            package_states: states
+          )
+
+          states.map do |state|
+            state.merge(detail_cache_contexts: detail_cache_contexts_for_package(state, detail_cache_contexts))
+          end
         end
 
         return nil if package_states.empty?
@@ -192,6 +209,53 @@ module Gemstar
         cache_warmer.enqueue_many(package_states)
       end
 
+      def detail_cache_contexts_for(project:, project_index:, from_revision_id:, to_revision_id:, package_states:)
+        default_filter = package_states.any? { |state| state[:status] != :unchanged } ? "updated" : "all"
+        default_scope = project.package_scope_options.map { |option| option[:id] } == ["gems"] ? "gems" : "all"
+
+        [
+          {
+            project: project_index,
+            from: from_revision_id,
+            to: to_revision_id,
+            filter: default_filter,
+            scope: default_scope
+          },
+          {
+            project: project_index,
+            from: from_revision_id,
+            to: to_revision_id,
+            filter: "all",
+            scope: default_scope
+          }
+        ].uniq
+      end
+
+      def detail_cache_contexts_for_package(package_state, base_contexts)
+        package_scope = package_state[:package_scope]
+
+        base_contexts.flat_map do |context|
+          [
+            context,
+            context.merge(scope: package_scope)
+          ]
+        end.uniq
+      end
+
+      def build_detail_cache_fetcher(app)
+        lambda do |package_state, context|
+          params = context.merge(package: package_state[:name])
+          env = Rack::MockRequest.env_for(
+            "/detail?#{URI.encode_www_form(params)}",
+            "REQUEST_METHOD" => "GET",
+            "gemstar.detail_cache_warm" => true
+          )
+          response = app.call(env)
+          body = response[2]
+          body.close if body.respond_to?(:close)
+        end
+      end
+
       def server_start_callback(projects, cache_warmer)
         proc do
           Thread.new do

data/lib/gemstar/npm_metadata.rb

@@ -64,13 +64,13 @@ module Gemstar
       repo
     end
 
-    def changelog_sections(versions: nil, cache_only: false, force_refresh: false)
+    def changelog_sections(versions: nil, cache_only: false, force_refresh: false, use_github_cli: false)
       requested_versions = Array(versions).compact
       changelog = Gemstar::ChangeLog.new(self)
       if requested_versions.empty?
         changelog.sections(cache_only: cache_only, force_refresh: force_refresh)
       else
-        changelog.sections_for_versions(requested_versions, cache_only: cache_only, force_refresh: force_refresh)
+        changelog.sections_for_versions(requested_versions, cache_only: cache_only, force_refresh: force_refresh, use_github_cli: use_github_cli)
       end
     end
 

data/lib/gemstar/ruby_gems_metadata.rb

@@ -88,8 +88,13 @@ module Gemstar
       repo
     end
 
-    def changelog_sections(versions: nil, cache_only: false, force_refresh: false)
-      Gemstar::ChangeLog.new(self).sections(cache_only: cache_only, force_refresh: force_refresh)
+    def changelog_sections(versions: nil, cache_only: false, force_refresh: false, use_github_cli: false)
+      changelog = Gemstar::ChangeLog.new(self)
+      if use_github_cli && Array(versions).compact.any?
+        changelog.sections_for_versions(versions, cache_only: cache_only, force_refresh: force_refresh, use_github_cli: true)
+      else
+        changelog.sections(cache_only: cache_only, force_refresh: force_refresh)
+      end
     end
 
     def registry_release_dates(cache_only: false, force_refresh: false)

data/lib/gemstar/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Gemstar # :nodoc:
-  VERSION = "1.1.1"
+  VERSION = "1.2"
   def self.debug?
     return @debug if defined?(@debug)
     @debug = ENV["GEMSTAR_DEBUG"] == "true"

data/lib/gemstar/web/app.rb

@@ -59,13 +59,15 @@ module Gemstar
         r.get "detail" do
           request_cache_key = detail_request_cache_key(r.params)
           request_cache = self.class.opts[:detail_request_cache]
-          if request_cache_key && request_cache.key?(request_cache_key)
+          refresh_detail = detail_refresh_requested?(r.params)
+          if request_cache_key && !refresh_detail && request_cache.key?(request_cache_key)
             next request_cache[request_cache_key]
           end
+          request_cache.delete(request_cache_key) if request_cache_key && refresh_detail
 
           load_state(r.params)
-          prioritize_selected_gem
-          detail_html = render_detail
+          prioritize_selected_gem unless r.env["gemstar.detail_cache_warm"]
+          detail_html = render_detail(force_refresh: refresh_detail, use_github_cli: detail_use_github_cli_requested?(r.params))
           request_cache[request_cache_key] = detail_html if request_cache_key
           detail_html
         end
@@ -131,6 +133,14 @@ module Gemstar
         0
       end
 
+      def detail_refresh_requested?(params)
+        %w[1 true yes].include?(params["refresh"].to_s.downcase)
+      end
+
+      def detail_use_github_cli_requested?(params)
+        %w[1 true yes].include?(params["use_gh"].to_s.downcase)
+      end
+
       def page_title
         return "Gemstar" unless @selected_project
 
@@ -480,10 +490,10 @@ module Gemstar
         HTML
       end
 
-      def render_detail
+      def render_detail(force_refresh: false, use_github_cli: false)
         return empty_detail_html unless @selected_gem
 
-        metadata = metadata_for(@selected_gem, refresh_if_missing: true)
+        metadata = metadata_for(@selected_gem, refresh_if_missing: true, force_refresh: force_refresh)
         cache_key = [
           CACHE_VERSION,
           @selected_project_index,
@@ -502,9 +512,9 @@ module Gemstar
           @selected_gem[:status]
         ]
         detail_cache = self.class.opts[:detail_html_cache]
-        return detail_cache[cache_key] if detail_cache.key?(cache_key)
+        return detail_cache[cache_key] if !force_refresh && detail_cache.key?(cache_key)
 
-        groups = grouped_change_sections(@selected_gem)
+        groups = grouped_change_sections(@selected_gem, force_refresh: force_refresh, use_github_cli: use_github_cli)
         detail_pending = detail_pending?(@selected_gem[:name], metadata, groups)
 
         detail_html = <<~HTML
@@ -860,8 +870,8 @@ module Gemstar
         %(<span class="revision-release-date" title="Estimated release date">#{h(release_date)}</span>)
       end
 
-      def grouped_change_sections(gem_state)
-        sections = change_sections(gem_state)
+      def grouped_change_sections(gem_state, force_refresh: false, use_github_cli: false)
+        sections = change_sections(gem_state, force_refresh: force_refresh, use_github_cli: use_github_cli)
         latest = sections.select { |section| section[:kind] == :future }
         current = sections.select { |section| section[:kind] == :current }
         previous = sections.select { |section| section[:kind] == :previous }
@@ -878,8 +888,8 @@ module Gemstar
         }
       end
 
-      def change_sections(gem_state)
-        metadata_hash = metadata_for(gem_state) || {}
+      def change_sections(gem_state, force_refresh: false, use_github_cli: false)
+        metadata_hash = metadata_for(gem_state, refresh_if_missing: force_refresh, force_refresh: force_refresh) || {}
         current_version = effective_package_version(gem_state, metadata_hash)
         cache_key = [
           CACHE_VERSION,
@@ -894,18 +904,18 @@ module Gemstar
           gem_state[:status]
         ]
         change_sections_cache = self.class.opts[:change_sections_cache]
-        return change_sections_cache[cache_key] if change_sections_cache.key?(cache_key)
+        return change_sections_cache[cache_key] if !force_refresh && change_sections_cache.key?(cache_key)
 
         return [] if gem_state[:new_version].nil? &&
           gem_state[:old_version].nil? &&
           (current_version.nil? || current_version.to_s.empty?)
         metadata = metadata_adapter_for(gem_state)
         return change_sections_cache[cache_key] = [] unless metadata
-        sections = resolved_sections(metadata, gem_state)
+        sections = resolved_sections(metadata, gem_state, force_refresh: force_refresh, use_github_cli: use_github_cli)
         return change_sections_cache[cache_key] = [] if sections.nil? || sections.empty?
 
         previous_version = gem_state[:old_version]
-        release_dates = resolved_release_dates(metadata, sections.keys, gem_state)
+        release_dates = resolved_release_dates(metadata, sections.keys, gem_state, force_refresh: force_refresh)
 
         rendered_sections = sections.keys.filter_map do |version|
           kind = section_kind(version, previous_version, current_version, gem_state[:status])
@@ -927,10 +937,10 @@ module Gemstar
         []
       end
 
-      def resolved_sections(metadata, gem_state)
+      def resolved_sections(metadata, gem_state, force_refresh: false, use_github_cli: false)
         changelog = Gemstar::ChangeLog.new(metadata)
-        cached_sections = changelog.sections(cache_only: true) || {}
-        return cached_sections unless selected_gem_requires_refresh?(gem_state, cached_sections)
+        cached_sections = force_refresh ? {} : changelog.sections(cache_only: true) || {}
+        return cached_sections unless force_refresh || selected_gem_requires_refresh?(gem_state, cached_sections)
 
         @metadata_cache.delete([gem_state[:package_scope], gem_state[:name]])
         metadata.meta(cache_only: false, force_refresh: true)
@@ -938,17 +948,18 @@ module Gemstar
         refreshed_sections = metadata.changelog_sections(
           versions: relevant_package_versions(gem_state, metadata),
           cache_only: false,
-          force_refresh: true
+          force_refresh: true,
+          use_github_cli: use_github_cli
         )
         cached_sections.merge(refreshed_sections || {})
       end
 
-      def resolved_release_dates(metadata, versions, gem_state)
+      def resolved_release_dates(metadata, versions, gem_state, force_refresh: false)
         changelog = Gemstar::ChangeLog.new(metadata)
-        cached_dates = changelog.release_dates(versions: versions, cache_only: true) || {}
+        cached_dates = force_refresh ? {} : changelog.release_dates(versions: versions, cache_only: true) || {}
         return cached_dates unless selected_gem_missing_release_dates?(gem_state, versions, cached_dates)
 
-        fetched_dates = changelog.release_dates(versions: versions, cache_only: false) || {}
+        fetched_dates = changelog.release_dates(versions: versions, cache_only: false, force_refresh: force_refresh) || {}
         cached_dates.merge(fetched_dates)
       rescue StandardError
         {}
@@ -1077,7 +1088,7 @@ module Gemstar
       end
 
       def strip_leading_version_heading(text, heading_version)
-        stripped = text.sub(/\A\s*#+\s*v?#{Regexp.escape(heading_version)}\s*\n+/i, "")
+        stripped = text.sub(/\A\s*#+\s*(?:Version\s+)?v?#{Regexp.escape(heading_version)}\b[^\n]*\n+/i, "")
         return strip_leading_heading_separator(stripped) unless stripped == text
 
         lines = text.lines
@@ -1085,8 +1096,8 @@ module Gemstar
 
         first_line = lines.first.to_s
         heading_like =
-          first_line.match?(/\A\s*v?#{Regexp.escape(heading_version)}\b/i) ||
-          first_line.match?(/\A\s*[\[(]?v?#{Regexp.escape(heading_version)}\b/i)
+          first_line.match?(/\A\s*(?:Version\s+)?v?#{Regexp.escape(heading_version)}\b/i) ||
+          first_line.match?(/\A\s*[\[(]?(?:Version\s+)?v?#{Regexp.escape(heading_version)}\b/i)
 
         return text unless heading_like
 
@@ -1105,26 +1116,26 @@ module Gemstar
         left.to_s <=> right.to_s
       end
 
-      def metadata_for(package_state_or_name, refresh_if_missing: false)
+      def metadata_for(package_state_or_name, refresh_if_missing: false, force_refresh: false)
         package_state = package_state_or_name.is_a?(Hash) ? package_state_or_name : { name: package_state_or_name, package_scope: "gems" }
         gem_name = package_state[:name]
         cache_key = [package_state[:package_scope], gem_name]
         cached = @metadata_cache[cache_key]
-        return nil if cached.equal?(MISSING_METADATA)
-        return cached if cached
+        return nil if !force_refresh && cached.equal?(MISSING_METADATA)
+        return cached if !force_refresh && cached
 
         if package_state[:package_scope] != "gems"
           metadata = local_package_metadata(package_state)
           adapter = metadata_adapter_for(package_state)
-          remote_metadata = adapter&.meta(cache_only: true)
+          remote_metadata = force_refresh ? nil : adapter&.meta(cache_only: true)
           remote_metadata = adapter&.meta(cache_only: false, force_refresh: true) if remote_metadata.nil? && refresh_if_missing
           metadata = metadata.compact.merge(remote_metadata || {})
           @metadata_cache[cache_key] = metadata || MISSING_METADATA
           return metadata
         end
 
-        metadata = Gemstar::RubyGemsMetadata.new(gem_name).meta(cache_only: true)
-        if metadata.nil? && refresh_if_missing
+        metadata = force_refresh ? nil : Gemstar::RubyGemsMetadata.new(gem_name).meta(cache_only: true)
+        if metadata.nil? && (refresh_if_missing || force_refresh)
           metadata = Gemstar::RubyGemsMetadata.new(gem_name).meta(cache_only: false, force_refresh: true)
         end
 
@@ -1305,16 +1316,27 @@ module Gemstar
         else
           %(<a href="#{h(fallback_url)}" target="_blank" rel="noreferrer">#{h(fallback_label)}</a>)
         end
+        github_cli_action = render_github_cli_release_button(version, repo_url)
 
         {
           version: version,
           title: version,
           kind: :current,
           previous_version: fallback_previous_version_for(gem_state, previous_sections),
-          html: "<p>No release information available. Check #{fallback_link} for more information.</p>"
+          html: "<p>No release information available. Check #{fallback_link} for more information.</p>#{github_cli_action}"
         }
       end
 
+      def render_github_cli_release_button(version, repo_url)
+        return "" unless repo_url.to_s.include?("github.com")
+
+        <<~HTML
+          <div class="detail-inline-actions">
+            <button type="button" class="action" data-detail-use-gh data-release-version="#{h(version)}">Use GitHub CLI</button>
+          </div>
+        HTML
+      end
+
       def fallback_previous_version_for(gem_state, previous_sections)
         return gem_state[:old_version] if gem_state[:new_version]
         return previous_sections.first[:version] if previous_sections.any?

data/lib/gemstar/web/templates/app.css

@@ -455,6 +455,12 @@
         background: #fff;
         padding: 0.5rem;
       }
+      .detail-inline-actions {
+        display: flex;
+        flex-wrap: wrap;
+        gap: 0.35rem;
+        margin-top: 0.55rem;
+      }
       .detail-loading-shell {
         min-height: 14rem;
         display: grid;

data/lib/gemstar/web/templates/app.js.erb

@@ -19,6 +19,12 @@
   const emptyDetailHtml = <%= empty_detail_html_json %>;
   const packageCollectionLabel = <%= (@selected_project&.package_collection_label || "Packages").downcase.dump %>;
   const detailDisclosureStorageKey = "gemstar.detailDisclosureOpen";
+  const pageWasReloaded = (() => {
+    const navigationEntry = performance.getEntriesByType && performance.getEntriesByType("navigation")[0];
+    if (navigationEntry) return navigationEntry.type === "reload";
+    return performance.navigation && performance.navigation.type === 1;
+  })();
+  let pendingManualDetailRefresh = pageWasReloaded;
 
   const visibleGemLinks = () => gemLinks.filter((link) => !link.hidden);
   const currentSelectedIndex = () => visibleGemLinks().findIndex((link) => link.classList.contains("is-selected"));
@@ -170,7 +176,15 @@
     </section>
   `;
 
-  const fetchDetail = (url, historyMode = "push") => {
+  const fetchDetail = (url, historyMode = "push", options = {}) => {
+    const requestUrl = new URL(url, window.location.origin);
+    if (options.refresh) {
+      requestUrl.searchParams.set("refresh", "1");
+    }
+    if (options.useGh) {
+      requestUrl.searchParams.set("use_gh", "1");
+      requestUrl.searchParams.set("refresh", "1");
+    }
     const normalizedUrl = new URL(url, window.location.origin).toString();
     const requestToken = ++detailRequestToken;
     activeDetailUrl = normalizedUrl;
@@ -180,7 +194,7 @@
       replaceDetail(loadingDetailHtml(normalizedUrl));
     }, 1000);
 
-    fetch(url, { headers: { "X-Requested-With": "gemstar-detail" } })
+    fetch(requestUrl.toString(), { headers: { "X-Requested-With": "gemstar-detail" } })
       .then((response) => response.text())
       .then((html) => {
         stopDetailLoading();
@@ -232,7 +246,8 @@
         window.history.replaceState({}, "", pageUrl);
       }
       if (detailNeedsInitialFetch()) {
-        fetchDetail(detailLink.dataset.detailUrl || detailLink.href, requested ? "none" : "replace");
+        fetchDetail(detailLink.dataset.detailUrl || detailLink.href, requested ? "none" : "replace", { refresh: pendingManualDetailRefresh });
+        pendingManualDetailRefresh = false;
       }
       return;
     }
@@ -241,7 +256,11 @@
 
     const firstVisibleLink = visibleGemLinks()[0];
     if (firstVisibleLink) {
-      activateGemLink(firstVisibleLink, "replace", true);
+      const refresh = pendingManualDetailRefresh;
+      pendingManualDetailRefresh = false;
+      syncSidebarSelection(firstVisibleLink.dataset.gemName, true);
+      fetchDetail(firstVisibleLink.dataset.detailUrl || firstVisibleLink.href, "replace", { refresh });
+      focusSidebar();
     }
   };
 
@@ -309,6 +328,16 @@
     });
   }
 
+  document.addEventListener("click", (event) => {
+    const button = event.target.closest("[data-detail-use-gh]");
+    if (!button || !detailPanel || !detailPanel.dataset.detailUrl) return;
+
+    event.preventDefault();
+    button.disabled = true;
+    button.textContent = "Checking...";
+    fetchDetail(detailPanel.dataset.detailUrl, "none", { refresh: true, useGh: true });
+  });
+
   const navigate = (params) => {
     const url = new URL(window.location.href);
     Object.entries(params).forEach(([key, value]) => {

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gemstar
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: '1.2'
 platform: ruby
 authors:
 - Florian Dejako