gemstar 1.1.1 → 1.3

data/lib/gemstar/web/app.rb

@@ -1,9 +1,14 @@
 require "cgi"
 require "erb"
+require "json"
+require "open3"
+require "shellwords"
 require "uri"
 require "kramdown"
 require "nokogiri"
 require "roda"
+require_relative "../crates_io_metadata"
+require_relative "../pypi_metadata"
 
 begin
   require "kramdown-parser-gfm"
@@ -14,7 +19,7 @@ module Gemstar
   module Web
     class App < Roda
       MISSING_METADATA = Object.new
-      CACHE_VERSION = "v7"
+      CACHE_VERSION = "v11"
 
       class << self
         def build(projects:, config_home:, cache_warmer: nil)
@@ -59,13 +64,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
@@ -80,6 +87,23 @@ module Gemstar
           File.read(project.gemfile_path)
         end
 
+        r.post "actions", String do |action_id|
+          response["Content-Type"] = "application/json; charset=utf-8"
+
+          project_index = selected_project_index(r.params["project"])
+          project = @projects[project_index]
+          action = project_action(action_id, project)
+          unless project && action
+            response.status = 404
+            next JSON.generate({ ok: false, error: "Unknown project action." })
+          end
+
+          result = run_project_action(project, action)
+          clear_runtime_state!(project)
+          response.status = result[:ok] ? 200 : 500
+          JSON.generate(result)
+        end
+
         r.on "projects", String do |project_id|
           response.redirect "/?project=#{project_id}"
         end
@@ -102,6 +126,7 @@ module Gemstar
         importmap_stamp = File.file?(project.importmap_path) ? File.mtime(project.importmap_path).to_i : 0
         importmap_vendor_stamp = importmap_vendor_mtime(project)
         package_lock_stamp = File.file?(project.package_lock_path) ? File.mtime(project.package_lock_path).to_i : 0
+        cargo_lock_stamp = File.file?(project.cargo_lock_path) ? File.mtime(project.cargo_lock_path).to_i : 0
 
         [
           CACHE_VERSION,
@@ -111,10 +136,12 @@ module Gemstar
           params["filter"],
           params["scope"],
           package_param(params),
+          params["package_id"],
           lockfile_stamp,
           importmap_stamp,
           importmap_vendor_stamp,
-          package_lock_stamp
+          package_lock_stamp,
+          cargo_lock_stamp
         ]
       end
 
@@ -131,6 +158,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
 
@@ -146,10 +181,12 @@ module Gemstar
         @selected_to_revision_id = selected_to_revision_id(@selected_to_revision_id)
         @gem_states = @selected_project ? @selected_project.gem_states(from_revision_id: @selected_from_revision_id, to_revision_id: @selected_to_revision_id) : []
         requested_package_name = package_param(params)
+        requested_package_id = params["package_id"]
         @requested_gem_name = requested_package_name
-        @selected_package_scope = selected_package_scope(params["scope"], requested_package_name)
-        @selected_filter = selected_filter(params["filter"], requested_package_name)
-        @selected_gem = selected_gem_state(requested_package_name)
+        @requested_package_id = requested_package_id
+        @selected_package_scope = selected_package_scope(params["scope"], requested_package_name, requested_package_id)
+        @selected_filter = selected_filter(params["filter"], requested_package_name, requested_package_id)
+        @selected_gem = selected_gem_state(requested_package_name, requested_package_id)
       end
 
       def package_param(params)
@@ -191,33 +228,36 @@ module Gemstar
         valid_ids.include?(candidate) ? candidate : valid_ids.first || "worktree"
       end
 
-      def selected_filter(raw_filter, raw_gem_name)
+      def selected_filter(raw_filter, raw_gem_name, raw_package_id = nil)
         return "all" if @gem_states.empty?
+        return "all" unless @gem_states.any? { |gem| gem[:status] != :unchanged }
         return raw_filter if %w[updated all].include?(raw_filter)
 
-        selected_gem = @gem_states.find { |gem| gem[:name] == raw_gem_name }
+        selected_gem = requested_gem_state(raw_gem_name, raw_package_id)
         return "all" if selected_gem && selected_gem[:status] == :unchanged
 
         @gem_states.any? { |gem| gem[:status] != :unchanged } ? "updated" : "all"
       end
 
-      def selected_package_scope(raw_scope, raw_gem_name)
+      def selected_package_scope(raw_scope, raw_gem_name, raw_package_id = nil)
         return "all" if @gem_states.empty?
 
         available_scopes = available_package_scopes
         default_scope = available_scopes == ["gems"] ? "gems" : "all"
         return raw_scope if raw_scope == "all" || available_scopes.include?(raw_scope)
 
-        selected_gem = @gem_states.find { |gem| gem[:name] == raw_gem_name }
+        selected_gem = requested_gem_state(raw_gem_name, raw_package_id)
         return selected_gem[:package_scope] if selected_gem
 
         default_scope
       end
 
-      def selected_gem_state(raw_gem_name)
+      def selected_gem_state(raw_gem_name, raw_package_id = nil)
         return nil if @gem_states.empty?
 
-        exact_match = @gem_states.find { |gem| gem[:name] == raw_gem_name && gem_visible_in_selected_scope?(gem) }
+        exact_match = @gem_states.find { |gem| package_identity(gem) == raw_package_id && gem_visible_in_selected_scope?(gem) } unless raw_package_id.to_s.empty?
+        exact_match ||= @gem_states.find { |gem| package_identity(gem) == raw_package_id } unless raw_package_id.to_s.empty?
+        exact_match ||= @gem_states.find { |gem| gem[:name] == raw_gem_name && gem_visible_in_selected_scope?(gem) }
         exact_match ||= @gem_states.find { |gem| gem[:name] == raw_gem_name }
         return exact_match if exact_match
 
@@ -227,6 +267,23 @@ module Gemstar
           @gem_states.first
       end
 
+      def requested_gem_state(raw_gem_name, raw_package_id)
+        unless raw_package_id.to_s.empty?
+          identity_match = @gem_states.find { |gem| package_identity(gem) == raw_package_id }
+          return identity_match if identity_match
+        end
+
+        @gem_states.find { |gem| gem[:name] == raw_gem_name }
+      end
+
+      def package_identity(gem_state)
+        [
+          gem_state[:package_scope],
+          gem_state[:package_source_file],
+          gem_state[:package_lock_key] || gem_state[:name]
+        ].join(":")
+      end
+
       def gem_visible_in_selected_filter?(gem_state)
         return false unless gem_visible_in_selected_scope?(gem_state)
         return true if @selected_filter != "updated"
@@ -394,13 +451,231 @@ module Gemstar
               <strong>#{@gem_states.count { |gem| gem[:status] != :unchanged }}</strong> changes from #{h(selected_from_revision_label)} to #{h(selected_to_revision_label)}
             </div>
             <div class="toolbar-actions">
-              <button type="button" class="action" disabled="disabled">bundle install</button>
-              <button type="button" class="action action-primary" disabled="disabled">bundle update</button>
+              #{render_project_action_buttons}
             </div>
           </section>
         HTML
       end
 
+      def render_project_action_buttons
+        actions = project_actions
+        actions.map do |action|
+          primary = action[:primary] ? " action-primary" : ""
+          command_label = project_action_display_command(@selected_project, action)
+          <<~HTML
+            <button
+              type="button"
+              class="action#{primary}"
+              data-project-action="#{h(action[:id])}"
+              data-project-action-command="#{h(command_label)}"
+            >#{h(action[:label])}</button>
+          HTML
+        end.join
+      end
+
+      def project_actions(project = @selected_project)
+        return [] unless project
+
+        actions = []
+        if project.gemfile? || project.lockfile?
+          actions << {
+            id: "bundle_install",
+            label: "#{bundle_command(project).join(" ")} install",
+            command: [*bundle_command(project), "install"]
+          }
+          actions << {
+            id: "bundle_update",
+            label: "#{bundle_command(project).join(" ")} update",
+            command: [*bundle_command(project), "update"],
+            primary: true
+          }
+        end
+
+        if project.uv_lock?
+          actions << {
+            id: "uv_sync",
+            label: "uv sync",
+            command: %w[uv sync]
+          }
+          actions << {
+            id: "uv_lock_upgrade",
+            label: "uv lock --upgrade",
+            command: %w[uv lock --upgrade],
+            primary: true
+          }
+        end
+
+
+        if project.cargo_toml? || project.cargo_lock?
+          actions << {
+            id: "cargo_fetch",
+            label: "cargo fetch",
+            command: %w[cargo fetch]
+          }
+          actions << {
+            id: "cargo_update",
+            label: "cargo update",
+            command: %w[cargo update],
+            primary: true
+          }
+        end
+
+        if project.package_lock?
+          actions << {
+            id: "npm_install",
+            label: "npm install",
+            command: %w[npm install]
+          }
+          actions << {
+            id: "npm_update",
+            label: "npm update",
+            command: %w[npm update],
+            primary: true
+          }
+        elsif project.package_json?
+          actions << {
+            id: "npm_install",
+            label: "npm install",
+            command: %w[npm install]
+          }
+        end
+
+        if project.importmap?
+          actions << {
+            id: "importmap_update",
+            label: "bin/importmap update",
+            command: %w[bin/importmap update]
+          }
+        end
+
+        actions
+      end
+
+      def project_action(action_id, project)
+        project_actions(project).find { |action| action[:id] == action_id }
+      end
+
+      def run_project_action(project, action)
+        command = project_action_command(project, action)
+        shell_command = project_action_shell_command(project, command)
+        stdout, stderr, status = Open3.capture3(project_action_environment, user_shell, "-lc", shell_command)
+        {
+          ok: status.success?,
+          action: action[:id],
+          command: shell_command,
+          output: truncated_action_output([stdout, stderr].reject(&:empty?).join("\n").strip)
+        }
+      rescue Errno::ENOENT => e
+        {
+          ok: false,
+          action: action[:id],
+          command: project_action_display_command(project, action),
+          output: e.message
+        }
+      end
+
+      def project_action_display_command(project, action)
+        project_action_shell_command(project, project_action_command(project, action))
+      end
+
+      def project_action_shell_command(project, command)
+        "cd #{Shellwords.escape(project.directory)} && #{Shellwords.join(command)}"
+      end
+
+      def project_action_command(project, action)
+        return action[:command] unless project_uses_mise?(project)
+
+        mise = mise_executable
+        return action[:command] unless mise
+
+        [mise, "exec", "--", *mise_command(action[:command])]
+      end
+
+      def mise_command(command)
+        executable, *arguments = command
+        case executable
+        when /\Abin\//
+          ["ruby", executable, *arguments]
+        when "bundle"
+          ["ruby", "-S", executable, *arguments]
+        else
+          command
+        end
+      end
+
+      def project_action_environment
+        {
+          "BUNDLE_BIN_PATH" => nil,
+          "BUNDLE_APP_CONFIG" => nil,
+          "BUNDLE_GEMFILE" => nil,
+          "BUNDLE_PATH" => nil,
+          "BUNDLE_WITHOUT" => nil,
+          "BUNDLER_VERSION" => nil,
+          "GEM_HOME" => nil,
+          "GEM_PATH" => nil,
+          "GEM_ROOT" => nil,
+          "MY_RUBY_HOME" => nil,
+          "RBENV_VERSION" => nil,
+          "RUBYLIB" => nil,
+          "RUBYGEMS_GEMDEPS" => nil,
+          "RUBYOPT" => nil,
+          "rvm_path" => nil,
+          "rvm_ruby_string" => nil
+        }
+      end
+
+      def user_shell
+        shell = ENV["SHELL"].to_s
+        shell.empty? ? "/bin/sh" : shell
+      end
+
+      def bundle_command(project)
+        File.file?(File.join(project.directory, "bin", "bundle")) ? %w[bin/bundle] : %w[bundle]
+      end
+
+      def project_uses_mise?(project)
+        directory = project.directory
+        loop do
+          return true if File.file?(File.join(directory, "mise.toml")) ||
+            File.file?(File.join(directory, ".mise.toml")) ||
+            File.file?(File.join(directory, ".ruby-version"))
+
+          parent = File.dirname(directory)
+          break if parent == directory
+
+          directory = parent
+        end
+
+        false
+      end
+
+      def mise_executable
+        ENV["PATH"].to_s.split(File::PATH_SEPARATOR).each do |directory|
+          path = File.join(directory, "mise")
+          return path if File.executable?(path)
+        end
+
+        [
+          "/opt/homebrew/bin/mise",
+          "/usr/local/bin/mise",
+          File.expand_path("~/.local/bin/mise")
+        ].find { |path| File.executable?(path) }
+      end
+
+      def truncated_action_output(output)
+        return output if output.length <= 8_000
+
+        "#{output[0, 8_000]}\n\n... output truncated ..."
+      end
+
+      def clear_runtime_state!(project)
+        project&.clear_cache! if project.respond_to?(:clear_cache!)
+        self.class.opts[:change_sections_cache].clear
+        self.class.opts[:detail_html_cache].clear
+        self.class.opts[:detail_request_cache].clear
+        self.class.opts[:metadata_cache].clear
+      end
+
       def selected_from_revision_label
         @revision_options.find { |option| option[:id] == @selected_from_revision_id }&.dig(:label) || "worktree"
       end
@@ -443,19 +718,22 @@ module Gemstar
         HTML
 
         items = @gem_states.map do |gem|
-          selected = gem[:name] == @selected_gem[:name] ? " is-selected" : ""
+          identity = package_identity(gem)
+          selected = identity == package_identity(@selected_gem) ? " is-selected" : ""
           status_class = " status-#{gem[:status]}"
           updated = gem[:status] != :unchanged
-          hidden = (!gem_visible_in_selected_scope?(gem) || (@selected_filter == "updated" && !updated && gem[:name] != @requested_gem_name)) ? ' hidden="hidden"' : ""
+          requested = identity == @requested_package_id || (@requested_package_id.to_s.empty? && gem[:name] == @requested_gem_name)
+          hidden = (!gem_visible_in_selected_scope?(gem) || (@selected_filter == "updated" && !updated && !requested)) ? ' hidden="hidden"' : ""
           <<~HTML
             <a
               class="gem-row#{selected}#{status_class}"
-              href="#{project_query(project: @selected_project_index, from: @selected_from_revision_id, to: @selected_to_revision_id, filter: @selected_filter, scope: @selected_package_scope, package: gem[:name])}"
+              href="#{project_query(project: @selected_project_index, from: @selected_from_revision_id, to: @selected_to_revision_id, filter: @selected_filter, scope: @selected_package_scope, package: gem[:name], package_id: identity)}"
               data-gem-link="true"
               data-gem-name="#{h(gem[:name])}"
+              data-package-id="#{h(identity)}"
               data-gem-updated="#{updated}"
               data-package-scope="#{h(gem[:package_scope])}"
-              data-detail-url="#{h(detail_query(project: @selected_project_index, from: @selected_from_revision_id, to: @selected_to_revision_id, filter: @selected_filter, scope: @selected_package_scope, package: gem[:name]))}"
+              data-detail-url="#{h(detail_query(project: @selected_project_index, from: @selected_from_revision_id, to: @selected_to_revision_id, filter: @selected_filter, scope: @selected_package_scope, package: gem[:name], package_id: identity))}"
               #{hidden}
             >
               <span class="gem-name-row">
@@ -480,10 +758,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,14 +780,15 @@ 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
-          <section class="detail" data-detail-panel tabindex="0" data-detail-pending="#{detail_pending}" data-detail-url="#{h(detail_query(project: @selected_project_index, from: @selected_from_revision_id, to: @selected_to_revision_id, filter: @selected_filter, scope: @selected_package_scope, package: @selected_gem[:name]))}">
+          <section class="detail" data-detail-panel tabindex="0" data-detail-pending="#{detail_pending}" data-detail-url="#{h(detail_query(project: @selected_project_index, from: @selected_from_revision_id, to: @selected_to_revision_id, filter: @selected_filter, scope: @selected_package_scope, package: @selected_gem[:name], package_id: package_identity(@selected_gem)))}">
             #{render_detail_hero(metadata)}
+            #{render_selected_dependency_details}
             #{render_detail_loading_notice if detail_pending}
             #{render_detail_revision_panel(groups)}
           </section>
@@ -528,7 +807,8 @@ module Gemstar
           to: @selected_to_revision_id,
           filter: @selected_filter,
           scope: @selected_package_scope,
-          package: @selected_gem[:name]
+          package: @selected_gem[:name],
+          package_id: package_identity(@selected_gem)
         )
 
         <<~HTML
@@ -541,11 +821,13 @@ module Gemstar
       end
 
       def empty_detail_html(loading: false)
+        package_label = @selected_project&.package_item_label || "package"
+
         <<~HTML
           <section class="detail" data-detail-panel tabindex="0">
             <div class="empty-panel">
-              <h2>#{loading ? "Loading details" : "No gem selected"}</h2>
-              <p>#{loading ? "Preparing the selected gem details." : "Choose a gem from the list to inspect its current version and changelog revisions."}</p>
+              <h2>#{loading ? "Loading details" : "No #{h(package_label)} selected"}</h2>
+              <p>#{loading ? "Preparing the selected #{h(package_label)} details." : "Choose a #{h(package_label)} from the list to inspect its current version and changelog revisions."}</p>
             </div>
           </section>
         HTML
@@ -553,10 +835,7 @@ module Gemstar
 
       def render_detail_hero(metadata)
         description = metadata&.dig("info")
-        bundle_origins = Array(@selected_gem[:bundle_origins])
-        requirement_names = selected_gem_requirements
         bundled_version = detail_bundled_version(metadata)
-        added_on = selected_gem_added_on
         title_url = metadata&.dig("homepage_uri")
         title_url = repo_url_for(@selected_gem, metadata: metadata) if title_url.to_s.empty?
         title_markup = if title_url.to_s.empty?
@@ -570,17 +849,50 @@ module Gemstar
             <div class="detail-hero-copy">
               <div class="detail-title-row">
                 <div class="detail-title-lockup">
-                  <h2>#{title_markup}#{bundled_version ? %(<span class="detail-title-version"> #{h(bundled_version)}</span>) : ""}</h2>
+                  <div class="detail-heading">
+                    <h2>#{title_markup}#{bundled_version ? %(<span class="detail-title-version"> #{h(bundled_version)}</span>) : ""}</h2>
+                    #{render_package_type_badge(@selected_gem)}
+                  </div>
                 </div>
                 #{render_detail_links(metadata)}
               </div>
               <div class="detail-subtitle">#{render_detail_subtitle(description)}</div>
-              #{render_dependency_details(bundle_origins, requirement_names, added_on)}
             </div>
           </section>
         HTML
       end
 
+      def render_package_type_badge(package_state)
+        scope = package_state[:package_scope].to_s
+        label, accessible_label, icon_type = case scope
+        when "gems"
+          ["Gem", "Ruby gem", :rubygems]
+        when "cargo"
+          ["Crate", "Rust crate", :cargo]
+        when "js"
+          ["JS", "JavaScript package", :javascript]
+        when "python"
+          ["Python", "Python package", :python]
+        else
+          [package_state[:package_type_label] || "Package", "Package", :package]
+        end
+
+        <<~HTML.chomp
+          <span class="detail-package-type detail-package-type-#{h(scope)}" aria-label="#{h(accessible_label)}" title="#{h(accessible_label)}">
+            <span class="detail-package-type-icon" aria-hidden="true">#{icon_svg(icon_type)}</span>
+            <span>#{h(label)}</span>
+          </span>
+        HTML
+      end
+
+      def render_selected_dependency_details
+        render_dependency_details(
+          Array(@selected_gem[:bundle_origins]),
+          selected_gem_requirements,
+          selected_gem_added_on
+        )
+      end
+
       def render_detail_subtitle(description)
         text = description.to_s.strip
         return "<p>Metadata will appear here when package information is available.</p>" if text.empty?
@@ -697,6 +1009,7 @@ module Gemstar
           @selected_gem[:name],
           package_scope: @selected_gem[:package_scope],
           source_file: @selected_gem[:package_source_file],
+          package_key: @selected_gem[:package_lock_key],
           revision_id: revision_id
         )
       end
@@ -754,6 +1067,26 @@ module Gemstar
           else
             ["npm (#{h(remote)})"]
           end
+        when :pypi
+          remote = source[:remote]
+          registry_url = source[:registry_url]
+          if remote.to_s.empty? && registry_url.to_s.empty?
+            ["PyPI"]
+          elsif remote.to_s.empty?
+            ["PyPI (#{h(registry_url)})"]
+          else
+            ["PyPI (#{h(remote)})"]
+          end
+        when :cargo
+          remote = source[:remote]
+          registry_url = source[:registry_url]
+          if remote.to_s.empty? && registry_url.to_s.empty?
+            ["Cargo registry"]
+          elsif remote.to_s.empty?
+            ["Cargo registry (#{h(registry_url)})"]
+          else
+            ["Cargo registry (#{h(remote)})"]
+          end
         else
           []
         end
@@ -792,13 +1125,26 @@ module Gemstar
       def render_detail_revision_panel(groups)
         <<~HTML
           <section class="revision-panel">
-            #{render_revision_group("Latest", groups[:latest], empty_message: nil) if groups[:latest].any?}
-            #{render_revision_group(current_section_title, groups[:current], empty_message: "No changelog entries in this revision range.")}
-            #{render_revision_group("Earlier changes", groups[:previous], empty_message: nil) if groups[:previous].any?}
+            #{render_revision_group("Available", groups[:latest], empty_message: nil) if groups[:latest].any?}
+            #{render_current_revision_group(groups)}
+            #{render_previous_revision_group(groups)}
           </section>
         HTML
       end
 
+      def render_current_revision_group(groups)
+        return "" if unchanged_worktree_package? && groups[:previous].any?
+
+        render_revision_group(current_section_title, groups[:current], empty_message: "No changelog entries in this revision range.")
+      end
+
+      def render_previous_revision_group(groups)
+        return "" if groups[:previous].empty?
+
+        title = unchanged_worktree_package? ? "Included in #{selected_from_revision_label}" : "Earlier changes"
+        render_revision_group(title, groups[:previous], empty_message: nil)
+      end
+
       def render_detail_loading_notice
         <<~HTML
           <section class="empty-panel">
@@ -860,8 +1206,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 +1224,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 +1240,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])
@@ -922,15 +1268,15 @@ module Gemstar
           }
         end
 
-        change_sections_cache[cache_key] = rendered_sections.sort_by { |section| section_sort_key(section) }
+        change_sections_cache[cache_key] = sort_change_sections(rendered_sections)
       rescue StandardError
         []
       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 +1284,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
         {}
@@ -972,12 +1319,15 @@ module Gemstar
         value = version.to_s.strip
         return nil if value.empty?
 
-        value.sub(/\Av/i, "")
+        value = value.sub(/\Av/i, "")
+        Gem::Version.new(value.gsub(/-[\w\-]+$/, "")).canonical_segments.join(".")
+      rescue ArgumentError
+        value
       end
 
       def relevant_package_versions(gem_state, metadata)
         metadata_hash = metadata_for(gem_state) || {}
-        [
+        explicit_versions = [
           gem_state[:old_version],
           gem_state[:new_version],
           gem_state[:raw_old_version],
@@ -985,6 +1335,27 @@ module Gemstar
           gem_state.dig(:source, :package_version),
           metadata_hash["version"]
         ].compact
+
+        (explicit_versions + registry_versions_between(metadata, gem_state, metadata_hash)).uniq
+      end
+
+      def registry_versions_between(metadata, gem_state, metadata_hash)
+        return [] unless metadata.respond_to?(:registry_release_dates)
+
+        lower_bound = gem_state[:old_version] || gem_state[:raw_old_version] || gem_state.dig(:source, :package_version)
+        current_version = effective_package_version(gem_state, metadata_hash)
+        upper_bound = metadata_hash["version"] || current_version
+        return [] if lower_bound.to_s.empty? || upper_bound.to_s.empty?
+
+        release_dates = metadata.registry_release_dates(cache_only: true)
+        release_dates = metadata.registry_release_dates(cache_only: false) if release_dates.nil? || release_dates.empty?
+
+        release_dates.keys.select do |version|
+          compare_versions(version, lower_bound) == 1 &&
+            compare_versions(version, upper_bound) <= 0
+        end
+      rescue StandardError
+        []
       end
 
       def selected_gem_requires_refresh?(gem_state, cached_sections)
@@ -1031,17 +1402,14 @@ module Gemstar
         :previous if compare_versions(version, lower_bound) <= 0
       end
 
-      def section_sort_key(section)
-        kind_rank = { future: 0, current: 1, previous: 2 }.fetch(section[:kind], 9)
-        [kind_rank, -sortable_version_number(section[:version])]
-      end
+      def sort_change_sections(sections)
+        kind_ranks = { future: 0, current: 1, previous: 2 }
+        sections.sort do |left, right|
+          kind_comparison = kind_ranks.fetch(left[:kind], 9) <=> kind_ranks.fetch(right[:kind], 9)
+          next kind_comparison unless kind_comparison.zero?
 
-      def sortable_version_number(version)
-        Gem::Version.new(version.to_s.gsub(/-[\w\-]+$/, "")).segments.take(6).each_with_index.sum do |segment, index|
-          segment.to_i * (10**(10 - index * 2))
+          compare_versions(right[:version], left[:version])
         end
-      rescue ArgumentError
-        0
       end
 
       def changelog_content(lines, heading_version: nil)
@@ -1077,7 +1445,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 +1453,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
 
@@ -1096,7 +1464,7 @@ module Gemstar
       end
 
       def strip_leading_heading_separator(text)
-        text.sub(/\A\s*(?:#{Regexp.escape("#")}{4,}|[-=]{3,})\s*\n+/, "")
+        text.sub(/\A\s*(?:#{Regexp.escape("#")}{4,}|[-=~`^"']{3,})\s*\n+/, "")
       end
 
       def compare_versions(left, right)
@@ -1105,26 +1473,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
 
@@ -1143,6 +1511,34 @@ module Gemstar
         package_version = source[:package_version].to_s
         registry_url = source[:registry_url].to_s
         provider_gem = source[:provider_gem].to_s
+        if package_state[:package_scope] == "python"
+          package_name = package_state[:name].to_s if package_name.empty?
+          package_version = (package_state[:new_version] || package_state[:old_version]).to_s if package_version.empty?
+          registry_url = "https://pypi.org/project/#{package_name}/" if registry_url.empty? && !package_name.empty?
+
+          return {
+            "info" => "Python package `#{package_name}` locked to `#{package_version}` in uv.lock",
+            "project_uri" => registry_url.empty? ? nil : registry_url,
+            "homepage_uri" => absolute_url?(remote) ? remote : nil,
+            "source_code_uri" => repo_url.empty? ? nil : repo_url
+          }
+        end
+
+        if package_state[:package_scope] == "cargo"
+          package_name = package_state[:metadata_package_name].to_s
+          package_name = source[:package_name].to_s if package_name.empty?
+          package_name = package_state[:name].to_s if package_name.empty?
+          package_version = (package_state[:new_version] || package_state[:old_version]).to_s if package_version.empty?
+          registry_url = "https://crates.io/crates/#{package_name}" if registry_url.empty? && !package_name.empty?
+
+          return {
+            "info" => "Rust crate `#{package_name}` locked to `#{package_version}` in Cargo.lock",
+            "project_uri" => registry_url.empty? ? nil : registry_url,
+            "homepage_uri" => absolute_url?(remote) ? remote : nil,
+            "source_code_uri" => repo_url.empty? ? nil : repo_url
+          }
+        end
+
         package_name = package_state[:name].to_s if package_name.empty? && source[:type] == :npm
         package_version = (package_state[:new_version] || package_state[:old_version]).to_s if package_version.empty? && source[:type] == :npm
         registry_url = "https://www.npmjs.com/package/#{package_name}" if registry_url.empty? && !package_name.empty?
@@ -1190,6 +1586,11 @@ module Gemstar
 
       def metadata_adapter_for(package_state)
         return Gemstar::RubyGemsMetadata.new(package_state[:name]) if package_state[:package_scope] == "gems"
+        return Gemstar::PyPIMetadata.new(package_state[:name]) if package_state[:package_scope] == "python"
+        if package_state[:package_scope] == "cargo"
+          package_name = package_state[:metadata_package_name] || package_state.dig(:source, :package_name) || package_state[:name]
+          return Gemstar::CratesIOMetadata.new(package_name)
+        end
         return nil unless package_state[:package_scope] == "js"
 
         provider_gem = package_state.dig(:source, :provider_gem)
@@ -1224,7 +1625,15 @@ module Gemstar
         when :home
           '<svg viewBox="0 0 16 16" aria-hidden="true"><path fill="currentColor" d="M8 .8 1.2 6.3v8.9h4.3V10h5v5.2h4.3V6.3L8 .8Zm5.2 13.3h-1.8V8.9H4.6v5.2H2.8V6.8L8 2.6l5.2 4.2v7.3Z"/></svg>'
         when :rubygems
-          '<svg viewBox="0 0 16 16" aria-hidden="true"><rect width="16" height="16" rx="2.6" fill="#fff"/><path fill="#111" d="m8 2.35 4.55 2.63v5.24L8 12.85l-4.55-2.63V4.98L8 2.35Zm0 1.3L4.58 5.62v3.96L8 11.55l3.42-1.97V5.62L8 3.65Zm0 1.07 2.5 1.44v2.88L8 10.48 5.5 9.04V6.16L8 4.72Z"/></svg>'
+          '<svg viewBox="0 0 16 16" aria-hidden="true"><path fill="#cc342d" d="M4.2 2.2h7.6l2.7 4.1L8 14.2 1.5 6.3l2.7-4.1Z"/><path fill="#ef5b55" d="m4.2 2.2 1.5 4.1H1.5l2.7-4.1Zm7.6 0 2.7 4.1h-4.2l1.5-4.1Z"/><path fill="#a91f1a" d="M5.7 6.3h4.6L8 14.2 5.7 6.3Z"/><path fill="#fff" fill-opacity=".42" d="m5 3.15.7 2H3.3l1.3-2h.4Z"/></svg>'
+        when :cargo
+          '<svg viewBox="0 0 16 16" aria-hidden="true"><path fill="none" stroke="currentColor" stroke-width="1.25" stroke-linejoin="round" d="m2.2 5 5.8-3 5.8 3v6L8 14l-5.8-3V5Z"/><path fill="none" stroke="currentColor" stroke-width="1.25" stroke-linejoin="round" d="M2.4 5 8 8l5.6-3M8 8v6M5.2 3.45 11 6.5"/></svg>'
+        when :javascript
+          '<svg viewBox="0 0 16 16" aria-hidden="true"><rect x="1.5" y="1.5" width="13" height="13" rx="2" fill="none" stroke="currentColor" stroke-width="1.2"/><text x="8" y="10.8" text-anchor="middle" font-family="ui-monospace, SFMono-Regular, monospace" font-size="6.3" font-weight="700" fill="currentColor">JS</text></svg>'
+        when :python
+          '<svg viewBox="0 0 16 16" aria-hidden="true"><path fill="none" stroke="currentColor" stroke-width="1.2" stroke-linecap="round" stroke-linejoin="round" d="M8 1.8H5.6c-1.7 0-2.4.8-2.4 2.3v2.1h5.6v1.6H4.5C2.8 7.8 2 8.7 2 10.2c0 1.7 1 2.5 2.6 2.5H7"/><path fill="none" stroke="currentColor" stroke-width="1.2" stroke-linecap="round" stroke-linejoin="round" d="M8 14.2h2.4c1.7 0 2.4-.8 2.4-2.3V9.8H7.2V8.2h4.3c1.7 0 2.5-.9 2.5-2.4 0-1.7-1-2.5-2.6-2.5H9"/><circle cx="6" cy="4.2" r=".7" fill="currentColor"/><circle cx="10" cy="11.8" r=".7" fill="currentColor"/></svg>'
+        when :package
+          '<svg viewBox="0 0 16 16" aria-hidden="true"><path fill="none" stroke="currentColor" stroke-width="1.25" stroke-linejoin="round" d="m2.2 5 5.8-3 5.8 3v6L8 14l-5.8-3V5ZM2.4 5 8 8l5.6-3M8 8v6"/></svg>'
         when :info
           '<svg viewBox="0 0 16 16" aria-hidden="true"><circle cx="8" cy="8" r="6.5" fill="none" stroke="currentColor" stroke-width="1.4"/><circle cx="8" cy="4.5" r="0.9" fill="currentColor"/><path d="M8 7v4" stroke="currentColor" stroke-width="1.4" stroke-linecap="round"/></svg>'
         else
@@ -1240,6 +1649,10 @@ module Gemstar
         end
       end
 
+      def unchanged_worktree_package?
+        @selected_to_revision_id == "worktree" && @selected_gem && @selected_gem[:status] == :unchanged
+      end
+
       def range_label(gem_state)
         old_version = gem_state[:old_version]
         new_version = gem_state[:new_version]
@@ -1251,7 +1664,7 @@ module Gemstar
       end
 
       def previous_section_version(versions, current_version)
-        ordered_versions = versions.sort_by { |version| -sortable_version_number(version) }
+        ordered_versions = versions.sort { |left, right| compare_versions(right, left) }
         current_index = ordered_versions.index(current_version)
         return nil if current_index.nil?
 
@@ -1305,16 +1718,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?
@@ -1361,18 +1785,19 @@ module Gemstar
         html
       end
 
-      def detail_query(project:, from:, to:, filter:, scope:, package:)
-        "/detail?#{URI.encode_www_form(project: project, from: from, to: to, filter: filter, scope: scope, package: package)}"
+      def detail_query(project:, from:, to:, filter:, scope:, package:, package_id: nil)
+        "/detail?#{URI.encode_www_form({project: project, from: from, to: to, filter: filter, scope: scope, package: package, package_id: package_id}.compact)}"
       end
 
-      def project_query(project:, from:, to:, filter:, scope:, package:)
+      def project_query(project:, from:, to:, filter:, scope:, package:, package_id: nil)
         params = {
           project: project,
           from: from,
           to: to,
           filter: filter,
           scope: scope,
-          package: package
+          package: package,
+          package_id: package_id
         }.compact
 
         "/?#{URI.encode_www_form(params)}"