gemstar 1.1.1 → 1.3

data/lib/gemstar/change_log.rb

@@ -2,17 +2,31 @@
 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
+    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)
@@ -33,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
@@ -54,7 +68,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 +89,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
@@ -176,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)
@@ -205,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!
@@ -230,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)
@@ -243,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
@@ -271,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?
@@ -294,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 {}
@@ -330,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] ||= []
@@ -369,27 +449,37 @@ 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 parse_github_release_sections(cache_only: false, force_refresh: false)
-      begin
-        require "nokogiri"
-      rescue LoadError
-        return {}
-      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")
 
       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 +596,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 +702,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 +985,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/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