gemstar 1.2 → 1.3

data/lib/gemstar/commands/server.rb

@@ -1,4 +1,5 @@
 require_relative "command"
+require_relative "../project"
 require "rack/mock"
 require "socket"
 require "shellwords"
@@ -33,6 +34,8 @@ module Gemstar
       end
 
       def run
+        projects = load_projects
+
         restart_with_rerun if reload_requested?
 
         require "rackup"
@@ -44,7 +47,6 @@ module Gemstar
         Gemstar::Config.ensure_home_directory!
         @port = resolve_port
 
-        projects = load_projects
         log_loaded_projects(projects)
         cache_warmer = build_cache_warmer
         web_app = Gemstar::Web::App.build(projects: projects, config_home: Gemstar::Config.home_directory, cache_warmer: cache_warmer)
@@ -54,15 +56,19 @@ module Gemstar
 
         puts "Gemstar server listening on http://#{bind}:#{port}"
         puts "Config home: #{Gemstar::Config.home_directory}"
-        Rackup::Server.start(
-          app: app,
-          server: "webrick",
-          Host: bind,
-          Port: port,
-          AccessLog: [],
-          Logger: Gemstar::WEBrickLogger.new($stderr, WEBrick::BasicLog::INFO),
-          StartCallback: server_start_callback(projects, cache_warmer)
-        )
+        begin
+          Rackup::Server.start(
+            app: app,
+            server: "webrick",
+            Host: bind,
+            Port: port,
+            AccessLog: [],
+            Logger: Gemstar::WEBrickLogger.new($stderr, WEBrick::BasicLog::INFO),
+            StartCallback: server_start_callback(projects, cache_warmer)
+          )
+        ensure
+          stop_background_cache_refresh(cache_warmer)
+        end
       end
 
       private
@@ -147,6 +153,9 @@ module Gemstar
 
       def load_projects
         project_inputs.map { |input| Gemstar::Project.from_cli_argument(input) }
+      rescue Gemstar::Project::UnsupportedProjectError => e
+        warn e.message
+        exit 1
       end
 
       def log_loaded_projects(projects)
@@ -258,14 +267,26 @@ module Gemstar
 
       def server_start_callback(projects, cache_warmer)
         proc do
-          Thread.new do
+          @server_start_thread = Thread.new do
+            Thread.current.name = "gemstar-server-start" if Thread.current.respond_to?(:name=)
             sleep 0.15
             start_background_cache_refresh(projects, cache_warmer)
             launch_browser
+          rescue StandardError => e
+            warn "Background cache refresh failed: #{e.class}: #{e.message}"
           end
         end
       end
 
+      def stop_background_cache_refresh(cache_warmer)
+        cache_warmer.shutdown if cache_warmer.respond_to?(:shutdown)
+
+        return unless @server_start_thread&.alive?
+
+        @server_start_thread.kill
+        @server_start_thread.join(0.5)
+      end
+
       def launch_browser
         return unless open_browser
 

data/lib/gemstar/crates_io_metadata.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require "json"
+require "open-uri"
+require "time"
+require "uri"
+require_relative "version"
+
+module Gemstar
+  class CratesIOMetadata
+    USER_AGENT = "gemstar/#{Gemstar::VERSION} (+https://github.com/FDj/gemstar)"
+
+    def initialize(crate_name)
+      @crate_name = crate_name
+    end
+
+    attr_reader :crate_name
+
+    alias_method :gem_name, :crate_name
+
+    def cache_key
+      "crates-io-#{crate_name}"
+    end
+
+    def meta(cache_only: false, force_refresh: false)
+      return @meta if !cache_only && defined?(@meta)
+
+      parsed = raw_meta(cache_only: cache_only, force_refresh: force_refresh)
+      normalized = normalize_meta(parsed)
+      @meta = normalized unless cache_only
+      normalized
+    end
+
+    def repo_uri(cache_only: false, force_refresh: false)
+      resolved_meta = meta(cache_only: cache_only, force_refresh: force_refresh)
+      return nil unless resolved_meta
+      return @repo_uri if !cache_only && defined?(@repo_uri)
+
+      uri = normalize_repo_uri(resolved_meta["source_code_uri"])
+      @repo_uri = uri unless cache_only
+      uri
+    end
+
+    def changelog_sections(versions: nil, cache_only: false, force_refresh: false, use_github_cli: false)
+      requested_versions = Array(versions).compact
+      changelog = Gemstar::ChangeLog.new(self)
+      if requested_versions.empty?
+        changelog.sections(cache_only: cache_only, force_refresh: force_refresh)
+      else
+        changelog.sections_for_versions(requested_versions, cache_only: cache_only, force_refresh: force_refresh, use_github_cli: use_github_cli)
+      end
+    end
+
+    def registry_release_dates(cache_only: false, force_refresh: false)
+      parsed = raw_meta(cache_only: cache_only, force_refresh: force_refresh)
+      Array(parsed&.dig("versions")).each_with_object({}) do |version, dates|
+        number = version["num"]
+        created_at = version["created_at"]
+        next if number.to_s.empty? || created_at.to_s.empty?
+
+        dates[number] = Time.parse(created_at).utc.strftime("%b %-d, %Y")
+      end
+    rescue JSON::ParserError, ArgumentError
+      {}
+    end
+
+    def warm_cache(versions: nil)
+      meta
+      repo_uri
+      changelog_sections(versions: versions)
+    end
+
+    def discover_github_tag_sections?
+      true
+    end
+
+    def github_tag_candidates(version)
+      raw = version.to_s
+      [
+        raw,
+        (raw.start_with?("v") ? raw : "v#{raw}"),
+        "#{crate_name}-#{raw}",
+        "#{crate_name}-v#{raw}",
+        "#{crate_name}@#{raw}"
+      ].uniq
+    end
+
+    def github_tag_matches?(tag_name)
+      decoded = URI.decode_www_form_component(tag_name.to_s.split("?").first.to_s)
+      return true if decoded.match?(/\Av?\d/)
+
+      decoded.match?(/\A#{Regexp.escape(crate_name)}(?:-|@)v?\d/i)
+    end
+
+    private
+
+    def raw_meta(cache_only: false, force_refresh: false)
+      json = if cache_only
+        Cache.peek(cache_key)
+      else
+        url = "https://crates.io/api/v1/crates/#{URI.encode_www_form_component(crate_name)}"
+        Cache.fetch(cache_key, force: force_refresh) do
+          options = {read_timeout: 8}
+          options["User-Agent"] = USER_AGENT
+          URI.parse(url).open(options).read
+        end
+      end
+
+      JSON.parse(json) if json
+    end
+
+    def normalize_meta(parsed)
+      return nil unless parsed.is_a?(Hash)
+
+      crate = parsed["crate"] || {}
+      name = crate["name"] || crate["id"] || crate_name
+      {
+        "name" => name,
+        "version" => crate["max_version"] || crate["newest_version"],
+        "info" => crate["description"],
+        "homepage_uri" => crate["homepage"],
+        "source_code_uri" => crate["repository"],
+        "project_uri" => "https://crates.io/crates/#{name}",
+        "documentation_uri" => crate["documentation"]
+      }
+    end
+
+    def normalize_repo_uri(uri)
+      value = uri.to_s
+      return "" if value.empty?
+
+      value = value.sub(/\Agit\+/, "")
+      value = value.sub(/\Agit:\/\//, "https://")
+      value = value.sub(/\Ahttp:\/\//, "https://")
+      value = value.gsub(/\.git\z/, "")
+      value = value[%r{\Ahttps?://github\.com/[^/]+/[^/]+}] || value if value.include?("github.com")
+      value
+    end
+  end
+end

data/lib/gemstar/data/ruby_gems_metadata.json

@@ -5,5 +5,15 @@
       "paths": ["CHANGELOG.md"],
       "branches": [""]
     }
+  },
+  "thruster": {
+    "changelog": {
+      "raw_base": "https://raw.githubusercontent.com/basecamp/thruster/v{version}",
+      "paths": ["CHANGELOG.md"],
+      "branches": [""],
+      "version_overrides": {
+        "0.1.22@2026-07-16": "0.1.23"
+      }
+    }
   }
 }

data/lib/gemstar/outputs/html.rb

@@ -78,6 +78,8 @@ module Gemstar
 
       def icon_for(info)
         return "📦" if info[:package_scope] == "js"
+        return "🐍" if info[:package_scope] == "python"
+        return "🦀" if info[:package_scope] == "cargo"
         return "🐙" if info[:homepage_url]&.include?("github.com")
 
         "💎"

data/lib/gemstar/project.rb

@@ -1,8 +1,29 @@
 require "time"
+require_relative "cargo_lock_file"
+require_relative "uv_lock_file"
 
 module Gemstar
   class Project
     REVISION_HISTORY_LIMIT = 100
+    SUPPORTED_PROJECT_FILES = [
+      "Gemfile",
+      "Gemfile.lock",
+      "config/importmap.rb",
+      "package.json",
+      "package-lock.json",
+      "uv.lock",
+      "Cargo.toml",
+      "Cargo.lock"
+    ].freeze
+
+    class UnsupportedProjectError < ArgumentError
+      def initialize(directory)
+        super(<<~MESSAGE.chomp)
+          Directory #{File.expand_path(directory)} does not contain a recognized project file.
+          Only #{Project.supported_project_files_sentence} are supported.
+        MESSAGE
+      end
+    end
 
     attr_reader :directory
     attr_reader :gemfile_path
@@ -10,6 +31,9 @@ module Gemstar
     attr_reader :importmap_path
     attr_reader :package_json_path
     attr_reader :package_lock_path
+    attr_reader :uv_lock_path
+    attr_reader :cargo_toml_path
+    attr_reader :cargo_lock_path
     attr_reader :name
 
     def self.from_cli_argument(input)
@@ -20,26 +44,36 @@ module Gemstar
         basename = File.basename(expanded_input)
         directory =
           case basename
-          when "Gemfile", "package.json", "package-lock.json"
+          when "Gemfile", "Gemfile.lock", "package.json", "package-lock.json", "uv.lock", "Cargo.toml", "Cargo.lock"
             File.dirname(expanded_input)
           when "importmap.rb"
-            File.dirname(File.dirname(expanded_input))
-          else
-            nil
+            File.dirname(expanded_input, 2)
           end
       end
 
-      raise ArgumentError, "No supported project files found for #{input}" unless directory
-      raise ArgumentError, "No supported project files found for #{input}" unless supported_project_directory?(directory)
+      unless directory
+        unsupported_directory = File.directory?(expanded_input) ? expanded_input : File.dirname(expanded_input)
+        raise UnsupportedProjectError, unsupported_directory
+      end
+
+      raise UnsupportedProjectError, directory unless supported_project_directory?(directory)
 
       new(directory: directory)
     end
 
     def self.supported_project_directory?(directory)
       File.file?(File.join(directory, "Gemfile")) ||
+        File.file?(File.join(directory, "Gemfile.lock")) ||
         File.file?(File.join(directory, "config", "importmap.rb")) ||
         File.file?(File.join(directory, "package.json")) ||
-        File.file?(File.join(directory, "package-lock.json"))
+        File.file?(File.join(directory, "package-lock.json")) ||
+        File.file?(File.join(directory, "uv.lock")) ||
+        File.file?(File.join(directory, "Cargo.toml")) ||
+        File.file?(File.join(directory, "Cargo.lock"))
+    end
+
+    def self.supported_project_files_sentence
+      "#{SUPPORTED_PROJECT_FILES[0...-1].join(", ")}, and #{SUPPORTED_PROJECT_FILES[-1]}"
     end
 
     def initialize(directory:)
@@ -49,10 +83,15 @@ module Gemstar
       @importmap_path = File.join(@directory, "config", "importmap.rb")
       @package_json_path = File.join(@directory, "package.json")
       @package_lock_path = File.join(@directory, "package-lock.json")
+      @uv_lock_path = File.join(@directory, "uv.lock")
+      @cargo_toml_path = File.join(@directory, "Cargo.toml")
+      @cargo_lock_path = File.join(@directory, "Cargo.lock")
       @name = File.basename(@directory)
       @lockfile_cache = {}
       @importmap_cache = {}
       @package_lock_cache = {}
+      @uv_lock_cache = {}
+      @cargo_lock_cache = {}
       @gem_states_cache = {}
       @gem_added_on_cache = {}
       @history_cache = {}
@@ -104,6 +143,46 @@ module Gemstar
       @current_package_lock ||= Gemstar::PackageLockFile.new(path: package_lock_path)
     end
 
+    def uv_lock?
+      File.file?(uv_lock_path)
+    end
+
+    def current_uv_lock
+      return nil unless uv_lock?
+
+      @current_uv_lock ||= Gemstar::UvLockFile.new(path: uv_lock_path)
+    end
+
+    def cargo_toml?
+      File.file?(cargo_toml_path)
+    end
+
+    def cargo_lock?
+      File.file?(cargo_lock_path)
+    end
+
+    def current_cargo_lock
+      return nil unless cargo_lock?
+
+      @current_cargo_lock ||= Gemstar::CargoLockFile.new(path: cargo_lock_path)
+    end
+
+    def clear_cache!
+      @current_lockfile = nil
+      @current_importmap = nil
+      @current_package_lock = nil
+      @current_uv_lock = nil
+      @current_cargo_lock = nil
+      @lockfile_cache.clear
+      @importmap_cache.clear
+      @package_lock_cache.clear
+      @uv_lock_cache.clear
+      @cargo_lock_cache.clear
+      @gem_states_cache.clear
+      @gem_added_on_cache.clear
+      @history_cache.clear
+    end
+
     def revision_history(limit: REVISION_HISTORY_LIMIT)
       history_for_paths(tracked_git_paths, limit: limit)
     end
@@ -133,7 +212,7 @@ module Gemstar
     end
 
     def revision_options(limit: REVISION_HISTORY_LIMIT)
-      [{ id: "worktree", label: "Worktree", description: "Current Gemfile.lock in the working tree" }] +
+      [{ id: "worktree", label: "Worktree", description: "Current project files in the working tree" }] +
         revision_history(limit: limit).map do |revision|
           {
             id: revision[:id],
@@ -147,6 +226,8 @@ module Gemstar
       scopes = []
       scopes << :gems if gemfile? || lockfile?
       scopes << :js if importmap? || package_lock? || package_json?
+      scopes << :python if uv_lock?
+      scopes << :cargo if cargo_toml? || cargo_lock?
       scopes
     end
 
@@ -163,6 +244,16 @@ module Gemstar
       package_scopes == [:gems] ? "Gems" : "Packages"
     end
 
+    def package_item_label
+      case package_scopes
+      when [:gems] then "gem"
+      when [:js] then "JavaScript package"
+      when [:python] then "Python package"
+      when [:cargo] then "Rust crate"
+      else "package"
+      end
+    end
+
     def lockfile_for_revision(revision_id)
       cache_key = revision_id || "worktree"
       return @lockfile_cache[cache_key] if @lockfile_cache.key?(cache_key)
@@ -208,6 +299,36 @@ module Gemstar
       @package_lock_cache[cache_key] = Gemstar::PackageLockFile.new(content: content)
     end
 
+    def uv_lock_for_revision(revision_id)
+      cache_key = revision_id || "worktree"
+      return @uv_lock_cache[cache_key] if @uv_lock_cache.key?(cache_key)
+      return @uv_lock_cache[cache_key] = current_uv_lock if revision_id.nil? || revision_id == "worktree"
+      return nil unless uv_lock?
+
+      relative_uv_lock_path = git_repo.relative_path(uv_lock_path)
+      return nil if relative_uv_lock_path.nil?
+
+      content = git_repo.try_git_command(["show", "#{revision_id}:#{relative_uv_lock_path}"])
+      return nil if content.nil? || content.empty?
+
+      @uv_lock_cache[cache_key] = Gemstar::UvLockFile.new(content: content)
+    end
+
+    def cargo_lock_for_revision(revision_id)
+      cache_key = revision_id || "worktree"
+      return @cargo_lock_cache[cache_key] if @cargo_lock_cache.key?(cache_key)
+      return @cargo_lock_cache[cache_key] = current_cargo_lock if revision_id.nil? || revision_id == "worktree"
+      return nil unless cargo_lock?
+
+      relative_cargo_lock_path = git_repo.relative_path(cargo_lock_path)
+      return nil if relative_cargo_lock_path.nil?
+
+      content = git_repo.try_git_command(["show", "#{revision_id}:#{relative_cargo_lock_path}"])
+      return nil if content.nil? || content.empty?
+
+      @cargo_lock_cache[cache_key] = Gemstar::CargoLockFile.new(content: content)
+    end
+
     def gem_states(from_revision_id: default_from_revision_id, to_revision_id: "worktree")
       cache_key = [from_revision_id, to_revision_id]
       return @gem_states_cache[cache_key] if @gem_states_cache.key?(cache_key)
@@ -298,11 +419,67 @@ module Gemstar
         }
       end
 
-      @gem_states_cache[cache_key] = (gem_states + js_states + npm_states).sort_by { |gem| [gem[:name], gem[:package_scope], gem[:package_source_file].to_s] }
+      from_uv_lock = uv_lock_for_revision(from_revision_id)
+      to_uv_lock = uv_lock_for_revision(to_revision_id)
+      from_python_specs = from_uv_lock&.specs || {}
+      to_python_specs = to_uv_lock&.specs || {}
+      python_states = (from_python_specs.keys | to_python_specs.keys).map do |package_name|
+        old_version = from_python_specs[package_name]
+        new_version = to_python_specs[package_name]
+        effective_uv_lock = new_version ? to_uv_lock : from_uv_lock
+
+        {
+          name: package_name,
+          package_scope: "python",
+          package_type_label: "Python",
+          package_source_file: :uv_lock,
+          old_version: old_version,
+          new_version: new_version,
+          status: gem_status(old_version, new_version),
+          version_label: version_label(old_version, new_version),
+          platform: nil,
+          source: effective_uv_lock&.source_for(package_name),
+          bundle_origins: [],
+          bundle_origin_labels: []
+        }
+      end
+
+      from_cargo_lock = cargo_lock_for_revision(from_revision_id)
+      to_cargo_lock = cargo_lock_for_revision(to_revision_id)
+      from_cargo_specs = from_cargo_lock&.specs || {}
+      to_cargo_specs = to_cargo_lock&.specs || {}
+      cargo_states = (from_cargo_specs.keys | to_cargo_specs.keys).map do |package_key|
+        old_version = from_cargo_specs[package_key]
+        new_version = to_cargo_specs[package_key]
+        effective_cargo_lock = new_version ? to_cargo_lock : from_cargo_lock
+        source = effective_cargo_lock&.source_for(package_key)
+        package_name = source&.dig(:package_name) || package_key
+        display_name = package_key == package_name ? package_name : "#{package_name} @ #{new_version || old_version}"
+
+        {
+          name: display_name,
+          metadata_package_name: package_name,
+          package_lock_key: package_key,
+          package_scope: "cargo",
+          package_type_label: "Crate",
+          package_source_file: :cargo_lock,
+          old_version: old_version,
+          new_version: new_version,
+          status: gem_status(old_version, new_version),
+          version_label: version_label(old_version, new_version),
+          platform: nil,
+          source: source,
+          bundle_origins: [],
+          bundle_origin_labels: []
+        }
+      end
+
+      @gem_states_cache[cache_key] = (gem_states + js_states + npm_states + python_states + cargo_states).sort_by { |gem| [gem[:name], gem[:package_scope], gem[:package_source_file].to_s] }
     end
 
-    def package_added_on(package_name, package_scope:, revision_id: "worktree", source_file: nil)
-      cache_key = [package_name, package_scope, source_file, revision_id]
+    def package_added_on(package_name, package_scope:, revision_id: "worktree", source_file: nil, package_key: nil)
+      lookup_name = package_key || package_name
+      cache_key = [lookup_name, package_scope, source_file, revision_id]
       return @gem_added_on_cache[cache_key] if @gem_added_on_cache.key?(cache_key)
 
       tracked_file, reader =
@@ -310,22 +487,30 @@ module Gemstar
           [importmap_path, method(:importmap_for_revision)]
         elsif source_file == :package_lock
           [package_lock_path, method(:package_lock_for_revision)]
+        elsif source_file == :uv_lock
+          [uv_lock_path, method(:uv_lock_for_revision)]
+        elsif source_file == :cargo_lock
+          [cargo_lock_path, method(:cargo_lock_for_revision)]
         elsif package_scope == "js"
           [importmap_path, method(:importmap_for_revision)]
+        elsif package_scope == "python"
+          [uv_lock_path, method(:uv_lock_for_revision)]
+        elsif package_scope == "cargo"
+          [cargo_lock_path, method(:cargo_lock_for_revision)]
         else
           [lockfile_path, method(:lockfile_for_revision)]
         end
       return @gem_added_on_cache[cache_key] = nil unless File.file?(tracked_file)
 
       target_snapshot = reader.call(revision_id)
-      return @gem_added_on_cache[cache_key] = nil unless target_snapshot&.specs&.key?(package_name)
+      return @gem_added_on_cache[cache_key] = nil unless target_snapshot&.specs&.key?(lookup_name)
 
       relative_path = git_repo.relative_path(tracked_file)
       return @gem_added_on_cache[cache_key] = nil if relative_path.nil?
 
       first_seen_revision = history_for_paths([relative_path], limit: nil, reverse: true).find do |revision|
         snapshot = reader.call(revision[:id])
-        snapshot&.specs&.key?(package_name)
+        snapshot&.specs&.key?(lookup_name)
       end
 
       return @gem_added_on_cache[cache_key] = worktree_added_on_info(tracked_file) if first_seen_revision.nil? && revision_id == "worktree"
@@ -346,14 +531,20 @@ module Gemstar
       current_specs = current_lockfile&.specs || {}
       current_importmap_specs = current_importmap&.specs || {}
       current_package_lock_specs = current_package_lock&.specs || {}
+      current_uv_lock_specs = current_uv_lock&.specs || {}
+      current_cargo_lock_specs = current_cargo_lock&.specs || {}
 
       revision_history(limit: REVISION_HISTORY_LIMIT).find do |revision|
         revision_lockfile = lockfile_for_revision(revision[:id])
         revision_importmap = importmap_for_revision(revision[:id])
         revision_package_lock = package_lock_for_revision(revision[:id])
+        revision_uv_lock = uv_lock_for_revision(revision[:id])
+        revision_cargo_lock = cargo_lock_for_revision(revision[:id])
         (revision_lockfile && revision_lockfile.specs != current_specs) ||
           (revision_importmap && revision_importmap.specs != current_importmap_specs) ||
-          (revision_package_lock && revision_package_lock.specs != current_package_lock_specs)
+          (revision_package_lock && revision_package_lock.specs != current_package_lock_specs) ||
+          (revision_uv_lock && revision_uv_lock.specs != current_uv_lock_specs) ||
+          (revision_cargo_lock && revision_cargo_lock.specs != current_cargo_lock_specs)
       end&.dig(:id)
     end
 
@@ -384,7 +575,7 @@ module Gemstar
     end
 
     def tracked_git_paths
-      [gemfile_path, lockfile_path, importmap_path, package_json_path, package_lock_path, *importmap_vendor_paths].filter_map do |path|
+      [gemfile_path, lockfile_path, importmap_path, package_json_path, package_lock_path, uv_lock_path, cargo_toml_path, cargo_lock_path, *importmap_vendor_paths].filter_map do |path|
         next unless File.file?(path)
 
         git_repo.relative_path(path)
@@ -531,6 +722,7 @@ module Gemstar
       when :gems then "gems"
       when :js then "js"
       when :python then "python"
+      when :cargo then "cargo"
       else scope.to_s
       end
     end
@@ -540,6 +732,7 @@ module Gemstar
       when :gems then "Gems"
       when :js then "JS"
       when :python then "Python"
+      when :cargo then "Cargo"
       else scope.to_s.capitalize
       end
     end