gemstar 1.2 → 1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c6157dce9498afdbda3d014af6e1e4e20e7477d73bd3b12129c0d754df28f4f7
-  data.tar.gz: c7fcc69688c21fea79ead9b9f762d026a5b57e5c597206171fe6faaeb5555db1
+  metadata.gz: 6eab7d36aeffe59f5863dffb07696c7ed8aab64dfb8828ae962122d607ad0b28
+  data.tar.gz: 9120441dae108fb6ff9d9a009cb9e6988349b884f011c40037460a86c45ef42a
 SHA512:
-  metadata.gz: 89b29cc2ff749b326e1e8dfd2cc98279b45d05a961b1d1aab8ea0cfcc9e4c2acab238fbaf40c4b947b0c9201a6254a80beb5102aa8c28c348d1afde67ced305a
-  data.tar.gz: 55182c82a720bd6a5baf9ab26e7369df6c834c24ae959b05301a40da16ac0e447a6ada98ac2461064ba137f9e944191026c48084d1ec2f95e923c0cda6b19265
+  metadata.gz: 5857f33b3a6b36759b2978b768749d7240f8ce54c73e57c48bce10ca407db846a955b80ba7c93d5db2a03bccbc6cb964ee55759ed4d75deb6982e23da681f5c8
+  data.tar.gz: 61dc580cfbb69aca3535428107a299833343ad132bb5e437cc01380ae4d58d90d525498818aed462793b036348e9f3666d83d8c6a7d2b821b62313f52c289381

data/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Change Log
 
+## 1.3
+
+- **Python uv projects** are now supported with our new `uv.lock` file parser and pypi package support!
+- **Rust Cargo projects** are now supported with a new `Cargo.lock` parser and crates.io package support!
+- Changelogs in rst format are now supported.
+- Changelogs: Fix parsing of documentation percentages, linked version headings, and version-first headings with dotted dates.
+- Changelogs: Do not treat version-looking prose inside release notes as a new release heading.
+- Changelogs: Prefer repository-branch changelogs when gem metadata points to a release-pinned file that may omit its own release.
+- Changelogs: Discover extensionless changelog files and direct GitHub changelog links, including Roda and Selenium release histories.
+- Changelogs: Correct known upstream release-heading typos through package metadata, including Thruster 0.1.23.
+- Server: Sort changelog cards with semantic version comparison so Selenium's `4.x` releases appear ahead of `3.142.x` and `3.141.x`.
+- Server: Render linked changelog version headings without Markdown brackets.
+- Server: Keep the details focus ring visible around its sticky header.
+- Server: Keep keyboard-selected sidebar packages visible below the sticky filter header.
+- Documentation: List Python package support in the README and gem metadata.
+- Server: Details heading is now sticky.
+- Server: Changed display of available versions to be more clear and concise.
+- CLI: Improve message shown when no supported project files are found.
+- CLI: Add `--version` to print the Gemstar version.
+
 ## 1.2
 
 - Server: Cache warmer now pre-fetches package detail pages so browsing warmed gems is faster.

data/README.md

@@ -3,7 +3,7 @@
 [![JRuby Build](https://github.com/FDj/gemstar/workflows/JRuby%20Build/badge.svg)](https://github.com/FDj/gemstar/actions)
 
 # Gemstar
-Helps you keep track of your gems and JavaScript packages.
+Helps you keep track of your Ruby gems, JavaScript packages, Python packages, and Rust crates.
 
 ## Installation
 
@@ -72,7 +72,7 @@ To examine a specific Gemfile.lock, pass it like this:
 gemstar diff --lockfile=~/MyProject/Gemfile.lock
 ```
 
-To diff a project from anywhere, pass the project directory or a supported project file. In project mode, gemstar includes Ruby gems plus JS packages from `importmap.rb` and `package-lock.json` when present:
+To diff a project from anywhere, pass the project directory or a supported project file. In project mode, gemstar includes Ruby gems, JS packages from `importmap.rb` and `package-lock.json`, Python packages from `uv.lock`, and Rust crates from `Cargo.lock` when present:
 
 ```shell
 gemstar diff --project ~/Code/my-app
@@ -83,6 +83,8 @@ To filter a project diff down to one ecosystem:
 ```shell
 gemstar diff --project ~/Code/my-app --ecosystem js
 gemstar diff --project ~/Code/my-app --ecosystem gems
+gemstar diff --project ~/Code/my-app --ecosystem python
+gemstar diff --project ~/Code/my-app --ecosystem cargo
 ```
 
 To write markdown instead of html:

data/lib/gemstar/cache_warmer.rb

@@ -1,5 +1,7 @@
 require "set"
 require "thread"
+require_relative "crates_io_metadata"
+require_relative "pypi_metadata"
 
 module Gemstar
   class CacheWarmer
@@ -18,6 +20,7 @@ module Gemstar
       @completed = Set.new
       @workers = []
       @started = false
+      @stopping = false
       @total = 0
       @completed_count = 0
     end
@@ -28,6 +31,8 @@ module Gemstar
       states = normalize_package_states(package_states)
 
       @mutex.synchronize do
+        return self if @stopping
+
         states.each do |package_state|
           key = package_key(package_state)
           next if @completed.include?(key) || @queued.include?(key) || @in_progress.include?(key)
@@ -74,6 +79,28 @@ module Gemstar
       @condition.broadcast
     end
 
+    def shutdown(timeout: 0.5)
+      workers = nil
+
+      @mutex.synchronize do
+        @stopping = true
+        @queue.clear
+        @queued.clear
+        @condition.broadcast
+        workers = @workers.dup
+      end
+
+      workers.each do |worker|
+        worker.join(timeout)
+        worker.kill if worker.alive?
+      end
+
+      @mutex.synchronize do
+        @workers.clear
+        @started = false
+      end
+    end
+
     def pending?(package_name)
       @mutex.synchronize do
         @queue.any? { |item| item[:name] == package_name || item.dig(:source, :package_name) == package_name } ||
@@ -97,9 +124,10 @@ module Gemstar
 
       loop do
         package_state = @mutex.synchronize do
-          while @queue.empty?
+          while @queue.empty? && !@stopping
             @condition.wait(@mutex)
           end
+          return if @stopping && @queue.empty?
 
           next_package = @queue.shift
           key = package_key(next_package)
@@ -180,6 +208,13 @@ module Gemstar
     end
 
     def metadata_adapter_for(package_state)
+      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 Gemstar::PyPIMetadata.new(package_state[:name]) if package_state[:package_scope] == "python"
+
       if package_state[:package_scope] == "js"
         provider_gem = package_state.dig(:source, :provider_gem)
         return Gemstar::RubyGemsMetadata.new(provider_gem) unless provider_gem.to_s.empty?

data/lib/gemstar/cargo_lock_file.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module Gemstar
+  class CargoLockFile
+    attr_reader :specs
+    attr_reader :spec_sources
+
+    def initialize(path: nil, content: nil)
+      parsed = parse_content(content || File.read(path))
+      @specs = parsed[:specs]
+      @spec_sources = parsed[:spec_sources]
+    end
+
+    def source_for(name)
+      spec_sources[name]
+    end
+
+    private
+
+    def parse_content(content)
+      packages = package_blocks(content).filter_map do |block|
+        name = scalar_value(block, "name")
+        version = scalar_value(block, "version")
+        source = scalar_value(block, "source")
+        next if name.to_s.empty? || version.to_s.empty?
+        next if source.to_s.empty?
+
+        {
+          name: name,
+          version: version,
+          source: source_for_package(source, name, version)
+        }
+      end
+
+      specs = {}
+      spec_sources = {}
+      packages.group_by { |package| package[:name] }.each_value do |named_packages|
+        sorted_packages(named_packages).each_with_index do |package, index|
+          key = package_key(package, index, named_packages.length)
+          specs[key] = package[:version]
+          spec_sources[key] = package[:source]
+        end
+      end
+
+      {specs: specs, spec_sources: spec_sources}
+    end
+
+    def package_blocks(content)
+      content.to_s.split(/^\[\[package\]\]\s*$/).drop(1)
+    end
+
+    def scalar_value(block, key)
+      block[/^#{Regexp.escape(key)}\s*=\s*"((?:\\.|[^"])*)"/, 1]&.gsub('\\"', '"')
+    end
+
+    def source_for_package(raw_source, name, version)
+      if raw_source.start_with?("git+")
+        git_source(raw_source, name, version)
+      else
+        registry_source(raw_source, name, version)
+      end
+    end
+
+    def git_source(raw_source, name, version)
+      remote_with_query, revision = raw_source.delete_prefix("git+").split("#", 2)
+      remote, query = remote_with_query.split("?", 2)
+      params = URI.decode_www_form(query.to_s).to_h
+
+      {
+        type: :git,
+        remote: remote,
+        revision: revision,
+        branch: params["branch"],
+        tag: params["tag"],
+        package_name: name,
+        package_version: version
+      }.compact
+    rescue ArgumentError
+      {
+        type: :git,
+        remote: raw_source.delete_prefix("git+").split(/[?#]/, 2).first,
+        revision: raw_source.split("#", 2)[1],
+        package_name: name,
+        package_version: version
+      }.compact
+    end
+
+    def registry_source(raw_source, name, version)
+      registry = raw_source.sub(/\A(?:registry|sparse)\+/, "")
+      crates_io = crates_io_registry?(registry)
+
+      {
+        type: :cargo,
+        remote: registry,
+        package_name: name,
+        package_version: version,
+        registry_url: crates_io ? "https://crates.io/crates/#{name}" : registry,
+        crates_io: crates_io
+      }
+    end
+
+    def crates_io_registry?(registry)
+      registry.include?("crates.io-index") || registry.include?("index.crates.io")
+    end
+
+    def sorted_packages(packages)
+      packages.sort do |left, right|
+        comparison = compare_versions(right[:version], left[:version])
+        comparison.zero? ? left[:source].to_s <=> right[:source].to_s : comparison
+      end
+    end
+
+    def compare_versions(left, right)
+      Gem::Version.new(left) <=> Gem::Version.new(right)
+    rescue ArgumentError
+      left.to_s <=> right.to_s
+    end
+
+    def package_key(package, index, package_count)
+      return package[:name] if package_count == 1
+
+      key = "#{package[:name]}@#{package[:version]}"
+      if index.zero? || !@used_package_keys&.include?(key)
+        remember_package_key(key)
+      else
+        remember_package_key("#{key}:#{index + 1}")
+      end
+    end
+
+    def remember_package_key(key)
+      @used_package_keys ||= []
+      @used_package_keys << key
+      key
+    end
+  end
+end

data/lib/gemstar/change_log.rb

@@ -12,12 +12,21 @@ module Gemstar
   class ChangeLog
     @@candidates_found = Hash.new(0)
     GITHUB_CLI_TIMEOUT = 8
+    MAX_CHANGELOG_REDIRECTS = 3
+    CHANGELOG_REDIRECT_PATTERN = /\b(?:change\s*log|changelog|release\s+notes?)\b.{0,160}\b(?:moved|relocated|now\s+lives|lives\s+here)\b/im
     DEFAULT_CHANGELOG_PATHS = %w[
-      CHANGELOG.md releases.md CHANGES.md
+      CHANGELOG.md CHANGELOG releases.md CHANGES.md
       Changelog.md changelog.md ChangeLog.md
       Changes.md changes.md
       HISTORY.md History.md history.md
-      History CHANGELOG.rdoc
+      History
+      RELEASE_NOTES.md Release_Notes.md release_notes.md
+      RELEASE-NOTES.md Release-Notes.md release-notes.md
+      CHANGELOG.rst Changelog.rst changelog.rst ChangeLog.rst
+      CHANGES.rst Changes.rst changes.rst
+      HISTORY.rst History.rst history.rst
+      CHANGES Changes
+      CHANGELOG.rdoc
     ].freeze
 
     def initialize(metadata)
@@ -38,7 +47,7 @@ module Gemstar
       return @sections if !cache_only && defined?(@sections) && !force_refresh
 
       metadata_key = @metadata.respond_to?(:cache_key) ? @metadata.cache_key : @metadata.gem_name
-      cache_key = "sections-v5-#{metadata_key}"
+      cache_key = "sections-v10-#{metadata_key}"
       serialized = if cache_only
         Cache.peek(cache_key)
       else
@@ -182,25 +191,10 @@ module Gemstar
       value = version.to_s.strip
       return nil if value.empty?
 
-      value.sub(/\Av/i, "")
-    end
-
-    # Extract a version token from a heading line, preferring explicit version forms
-    # and avoiding returning a date string when both are present.
-    def extract_version_from_heading(line)
-      return nil unless line
-      heading = line.to_s
-      version_token = /(\d+\.\d+(?:\.\d+)?(?:[-.][A-Za-z0-9]+)*)/
-      # 1) Prefer version inside parentheses after a date: "### 2025-11-07 (2.16.0)"
-      #    Ensure we ONLY treat it as a version if it actually looks like a version (has a dot),
-      #    so we don't capture dates like (2025-11-21).
-      return $1 if heading[/\(\s*v?#{version_token}(?![A-Za-z0-9])\s*\)/]
-      # 2) Version-first with optional leading markers/labels: "## v1.2.6 - 2025-10-21"
-      #    Require a dot in the numeric token to avoid capturing dates like 2025-11-21.
-      return $1 if heading[/^\s*(?:[-*]\s+)?(?:#+|=+)?\s*(?:Version\s+)?\[*v?#{version_token}(?![A-Za-z0-9])\]*/i]
-      # 3) Anywhere: first semver-like token with a dot
-      return $1 if heading[/\bv?#{version_token}(?![A-Za-z0-9])\b/]
-      nil
+      value = value.sub(/\Av/i, "")
+      Gem::Version.new(value.gsub(/-[\w\-]+$/, "")).canonical_segments.join(".")
+    rescue ArgumentError
+      value
     end
 
     def extract_release_date_from_heading(line)
@@ -211,23 +205,24 @@ module Gemstar
     end
 
     def changelog_uri_candidates(cache_only: false, force_refresh: false)
-      candidates = []
-
       repo_uri = @metadata.repo_uri(cache_only: cache_only, force_refresh: force_refresh)
       return [] if repo_uri.nil? || repo_uri.empty?
 
       meta = @metadata.meta(cache_only: cache_only, force_refresh: force_refresh)
-      candidates += changelog_uri_markdown_candidates(meta["changelog_uri"]) if meta
+      explicit_candidates = meta ? changelog_uri_markdown_candidates(meta["changelog_uri"]) : []
 
       changelog_source = metadata_changelog_source(repo_uri, cache_only: cache_only, force_refresh: force_refresh)
       return [] unless changelog_source
 
-      candidates += changelog_source[:paths].product(changelog_source[:branches]).map do |file, branch|
+      repository_candidates = changelog_source[:paths].product(changelog_source[:branches]).map do |file, branch|
         [changelog_source[:base], branch, file].reject { |segment| segment.to_s.empty? }.join("/")
       end
 
-      # Add the gem's changelog_uri last as it's usually not the most parsable:
-      candidates += [Gemstar::GitHub::github_blob_to_raw(meta["changelog_uri"])] if meta
+      candidates = if version_pinned_changelog_uri?(meta)
+        repository_candidates + explicit_candidates
+      else
+        explicit_candidates + repository_candidates
+      end
 
       candidates.flatten!
       candidates.uniq!
@@ -236,12 +231,24 @@ module Gemstar
       candidates
     end
 
+    def version_pinned_changelog_uri?(meta)
+      changelog_uri = meta&.fetch("changelog_uri", nil).to_s
+      version = meta&.fetch("version", nil).to_s.sub(/\Av/i, "")
+      return false if changelog_uri.empty? || version.empty?
+
+      raw_uri = Gemstar::GitHub::github_blob_to_raw(changelog_uri)
+      path_segments = URI(raw_uri).path.split("/")
+      path_segments.include?(version) || path_segments.include?("v#{version}")
+    rescue URI::InvalidURIError
+      false
+    end
+
     def changelog_uri_markdown_candidates(changelog_uri)
       raw_uri = Gemstar::GitHub::github_blob_to_raw(changelog_uri)
       return [] if raw_uri.to_s.empty?
 
       candidates = []
-      candidates << raw_uri if raw_uri.match?(/\.(?:md|markdown|rdoc|txt)\z/i)
+      candidates << raw_uri if raw_uri.match?(/\.(?:md|markdown|rdoc|rst|txt)\z/i)
 
       begin
         uri = URI(raw_uri)
@@ -249,9 +256,14 @@ module Gemstar
         if path.end_with?("/")
           uri.path = "#{path.chomp("/")}.md"
           candidates << uri.to_s
+          uri.path = "#{path.chomp("/")}.rst"
+          candidates << uri.to_s
         elsif File.extname(path).empty?
+          candidates << raw_uri if uri.host == "raw.githubusercontent.com"
           uri.path = "#{path}.md"
           candidates << uri.to_s
+          uri.path = "#{path}.rst"
+          candidates << uri.to_s
         end
       rescue URI::InvalidURIError
         nil
@@ -277,15 +289,14 @@ module Gemstar
       content = nil
 
       changelog_uri_candidates(cache_only: cache_only, force_refresh: force_refresh).find do |candidate|
-        content = if cache_only
-          Cache.peek("changelog-#{candidate}")
-        else
-          Cache.fetch("changelog-#{candidate}", force: force_refresh) do
-            URI.open(candidate, read_timeout: 8)&.read
-          rescue => e
-            puts "#{candidate}: #{e}" if Gemstar.debug?
-            nil
-          end
+        content = fetch_changelog_uri(candidate, cache_only: cache_only, force_refresh: force_refresh)
+        if content
+          content = follow_changelog_redirects(
+            content,
+            source_uri: candidate,
+            cache_only: cache_only,
+            force_refresh: force_refresh
+          )
         end
 
         # puts "fetch_changelog_content #{candidate}:\n#{content}" if Gemstar.debug?
@@ -300,13 +311,74 @@ module Gemstar
       content
     end
 
+    def fetch_changelog_uri(uri, cache_only:, force_refresh:)
+      if cache_only
+        Cache.peek("changelog-#{uri}")
+      else
+        Cache.fetch("changelog-#{uri}", force: force_refresh) do
+          URI.open(uri, read_timeout: 8)&.read
+        rescue => e
+          puts "#{uri}: #{e}" if Gemstar.debug?
+          nil
+        end
+      end
+    end
+
+    def follow_changelog_redirects(content, source_uri:, cache_only:, force_refresh:)
+      current_content = content
+      current_uri = source_uri
+      visited = {source_uri => true}
+
+      MAX_CHANGELOG_REDIRECTS.times do
+        redirect_uri = changelog_redirect_uri(current_content, current_uri)
+        break if redirect_uri.nil? || visited[redirect_uri]
+
+        redirected_content = fetch_changelog_uri(
+          redirect_uri,
+          cache_only: cache_only,
+          force_refresh: force_refresh
+        )
+        break if redirected_content.nil? || redirected_content.strip.empty?
+
+        puts "Following changelog redirect: #{current_uri} -> #{redirect_uri}" if Gemstar.debug?
+        visited[redirect_uri] = true
+        current_uri = redirect_uri
+        current_content = redirected_content
+      end
+
+      current_content
+    end
+
+    def changelog_redirect_uri(content, source_uri)
+      text = content.to_s
+      return nil if text.bytesize > 4096 || text.lines.count > 12
+      return nil unless text.match?(CHANGELOG_REDIRECT_PATTERN)
+
+      links = text.scan(/\[([^\]]+)\]\(\s*<?([^\s)>]+)>?(?:\s+["'][^"']*["'])?\s*\)/)
+      redirect_link = links.find { |link_label, _| link_label.match?(/\A(?:here|changelog|change\s*log|release\s+notes?)\z/i) }
+      redirect_link ||= links.find { |_, link_href| link_href.match?(%r{(?:change(?:log|s)|history|releases?)}i) }
+      href = redirect_link&.last
+      return nil if href.nil?
+
+      resolved = URI.join(source_uri, CGI.unescapeHTML(href)).to_s
+      uri = URI(Gemstar::GitHub::github_blob_to_raw(resolved))
+      return nil unless %w[http https].include?(uri.scheme)
+
+      uri.fragment = nil
+      uri.to_s
+    rescue URI::InvalidURIError
+      nil
+    end
+
     VERSION_PATTERNS = [
-      /^\s*(?:[-*]\s+)?(?:#+|=+)\s*\d{4}-\d{2}-\d{2}\s*\(\s*v?(\d+\.\d+(?:\.\d+)?(?:[-.][A-Za-z0-9]+)*)(?![A-Za-z0-9])\s*\)/, # prefer this
-      /^\s*(?:[-*]\s+)?(?:#+|=+)\s*\[*v?(\d+\.\d+(?:\.\d+)?(?:[-.][A-Za-z0-9]+)*)(?![A-Za-z0-9])\]*\s*(?:—|–|-)\s*\d{4}-\d{2}-\d{2}\b/,
-      /^\s*(?:[-*]\s+)?(?:#+|=+)\s*(?:Version\s+)?(?:(?:[^\s\d][^\s]*\s+)+)\[*v?(\d+\.\d+(?:\.\d+)?(?:[-.][A-Za-z0-9]+)*)(?![A-Za-z0-9])\]*(?:\s*[-(].*)?/i,
-      /^\s*(?:[-*]\s+)?(?:#+|=+)\s*(?:Version\s+)?\[*v?(\d+\.\d+(?:\.\d+)?(?:[-.][A-Za-z0-9]+)*)(?![A-Za-z0-9])\]*(?:\s*[-(].*)?/i,
-      /^\s*(?:[-*]\s+)?(?:Version\s+)?v?(\d+\.\d+(?:\.\d+)?(?:[-.][A-Za-z0-9]+)*)(?![A-Za-z0-9])(?:\s*[-(].*)?/i
+      /^\s*(?:[-*]\s+)?(?:#+|=+)\s*\d{4}-\d{2}-\d{2}\s*\(\s*v?(\d+(?:\.\d+)+(?:[-.][A-Za-z0-9]+)*)(?![A-Za-z0-9]|\s*%)\s*\)/, # prefer this
+      /^\s*(?:[-*]\s+)?(?:#+|=+)\s*\[*v?(\d+(?:\.\d+)+(?:[-.][A-Za-z0-9]+)*)(?![A-Za-z0-9]|\s*%)\]*\s*(?:—|–|-)\s*\d{4}-\d{2}-\d{2}\b/,
+      /^\s*(?:[-*]\s+)?(?:#+|=+)\s*(?:Version\s+)?(?:(?:[^\s\d][^\s]*\s+)+)\[*v?(\d+(?:\.\d+)+(?:[-.][A-Za-z0-9]+)*)(?![A-Za-z0-9]|\s*%)\]*(?:\s*[-(].*)?/i,
+      /^\s*(?:[-*]\s+)?(?:#+|=+)\s*(?:Version\s+)?\[*v?(\d+(?:\.\d+)+(?:[-.][A-Za-z0-9]+)*)(?![A-Za-z0-9]|\s*%)\]*(?:\s*[-(].*)?/i,
+      /^\s*(?:[-+*]\s+)?Starting with version\s+v?(\d+(?:\.\d+)+(?:[-.][A-Za-z0-9]+)*)(?![A-Za-z0-9]|\s*%)/i,
+      /^\s*(?:[-+*]\s+)?(?:Version\s+)?v?(\d+(?:\.\d+)+(?:[-.][A-Za-z0-9]+)*)(?![A-Za-z0-9]|\s*%)(?:\s*[-(].*)?\s*$/i
     ]
+    RST_ADORNMENT_PATTERN = /^\s*[=\-~`^"']{3,}\s*$/
 
     def parse_changelog_sections(cache_only: false, force_refresh: false)
       # If the fetched content looks like a GitHub Releases HTML page, return {}
@@ -336,11 +408,13 @@ module Gemstar
       lines.each do |line|
         # Convert rdoc to markdown:
         line = line.gsub(/^=+/) { |m| "#" * m.length }
+        next if line.match?(/^\s*\.\.\s+_v?[\w.-]+:/)
+        next if line.match?(RST_ADORNMENT_PATTERN)
 
         m = VERSION_PATTERNS.lazy.map { |re| line.match(re) }.find(&:itself)
 
         if m
-          new_key = extract_version_from_heading(line) || $1
+          new_key = corrected_changelog_version(m[1], line)
 
           if current_key
             sections[current_key] ||= []
@@ -375,14 +449,21 @@ module Gemstar
 
       c.lines.each_with_object({}) do |line, dates|
         line = line.gsub(/^=+/) { |m| "#" * m.length }
-        next unless VERSION_PATTERNS.any? { |re| line.match?(re) }
+        match = VERSION_PATTERNS.lazy.map { |pattern| line.match(pattern) }.find(&:itself)
+        next unless match
 
-        version = extract_version_from_heading(line)
+        version = corrected_changelog_version(match[1], line)
         date = extract_release_date_from_heading(line)
         dates[version] ||= date if version && date
       end
     end
 
+    def corrected_changelog_version(version, heading)
+      return version unless @metadata.respond_to?(:correct_changelog_version)
+
+      @metadata.correct_changelog_version(version, heading: heading) || version
+    end
+
     def parse_github_release_sections(cache_only: false, force_refresh: false)
       repo_uri = @metadata&.repo_uri(cache_only: cache_only, force_refresh: force_refresh)
       return {} unless repo_uri&.include?("github.com")

data/lib/gemstar/cli.rb

@@ -5,7 +5,8 @@ module Gemstar
   class CLI < Thor
     package_name "gemstar"
 
-    map "-D" => "diff"
+    map "-D" => "diff",
+      "--version" => "version"
 
     class_option :verbose, type: :boolean, default: false, desc: "Enable verbose output"
     class_option :lockfile, type: :string, default: "Gemfile.lock", desc: "Lockfile path"
@@ -15,7 +16,7 @@ module Gemstar
     method_option :to, type: :string, desc: "Git ref or lockfile"
     method_option :since, type: :string, desc: "Set --from to the latest commit before this relative time (for example: '3 weeks')"
     method_option :project, type: :string, desc: "Project directory or supported project file path"
-    method_option :ecosystem, type: :string, desc: "Filter packages by ecosystem (all, gems, js)"
+    method_option :ecosystem, type: :string, desc: "Filter packages by ecosystem (all, gems, js, python, cargo)"
     method_option :format, type: :string, desc: "Output format (html or markdown)"
     method_option :output_file, type: :string, desc: "Output file path"
     method_option :debug_gem_regex, type: :string, desc: "Debug matching gems", hide: true
@@ -36,6 +37,11 @@ module Gemstar
     desc "cache SUBCOMMAND ...ARGS", "Manage gemstar caches"
     subcommand "cache", Gemstar::CacheCLI
 
+    desc "version", "Print gemstar version"
+    def version
+      puts Gemstar::VERSION
+    end
+
     # desc "pick", "Interactively cherry-pick and upgrade gems"
     # option :gem, type: :string, desc: "Gem name to cherry-pick"
     # def pick

data/lib/gemstar/commands/diff.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require_relative "command"
+require_relative "../pypi_metadata"
+require_relative "../crates_io_metadata"
 require "concurrent-ruby"
 require "tmpdir"
 require "pathname"
@@ -70,9 +72,9 @@ module Gemstar
       def normalize_ecosystem(value)
         normalized = value.to_s.strip.downcase
         return "all" if normalized.empty?
-        return normalized if %w[all gems js].include?(normalized)
+        return normalized if %w[all gems js python cargo].include?(normalized)
 
-        raise Thor::Error, "Unsupported ecosystem #{value.inspect}. Expected one of: all, gems, js"
+        raise Thor::Error, "Unsupported ecosystem #{value.inspect}. Expected one of: all, gems, js, python, cargo"
       end
 
       def normalize_since(value)
@@ -210,6 +212,11 @@ module Gemstar
       def metadata_for(package_state)
         if package_state[:package_scope] == "js"
           Gemstar::NpmMetadata.new(package_state[:name])
+        elsif package_state[:package_scope] == "python"
+          Gemstar::PyPIMetadata.new(package_state[:name])
+        elsif package_state[:package_scope] == "cargo"
+          package_name = package_state[:metadata_package_name] || package_state.dig(:source, :package_name) || package_state[:name]
+          Gemstar::CratesIOMetadata.new(package_name)
         else
           Gemstar::RubyGemsMetadata.new(package_state[:name])
         end
@@ -315,6 +322,10 @@ module Gemstar
             "importmap"
           when :package_lock
             "package-lock"
+          when :uv_lock
+            "uv.lock"
+          when :cargo_lock
+            "Cargo.lock"
           else
             package_state[:package_scope]
           end