gemstar 1.0.2 → 1.1

data/lib/gemstar/commands/diff.rb

@@ -3,6 +3,8 @@
 require_relative "command"
 require "concurrent-ruby"
 require "tmpdir"
+require "pathname"
+require "uri"
 
 module Gemstar
   module Commands
@@ -16,39 +18,39 @@ module Gemstar
       attr_reader :lockfile_full_path
       attr_reader :output_file
       attr_reader :output_format
+      attr_reader :project
+      attr_reader :ecosystem
+      attr_reader :since
+      attr_reader :considered_commits
+      attr_reader :since_cutoff_commit
 
       def initialize(options)
         super
 
         @debug_gem_regex = Regexp.new(options[:debug_gem_regex] || ENV["GEMSTAR_DEBUG_GEM_REGEX"] || ".*")
 
+        @since = normalize_since(options[:since])
         @from = options[:from] || "HEAD"
         @to = options[:to]
         @lockfile = options[:lockfile] || "Gemfile.lock"
         @output_format = normalize_output_format(options[:format] || options[:output_format])
         @output_file = options[:output_file] || default_output_file
+        @project = options[:project] ? Gemstar::Project.from_cli_argument(options[:project]) : nil
+        @ecosystem = normalize_ecosystem(options[:ecosystem])
+        @considered_commits = []
+        @since_cutoff_commit = nil
 
-        @git_repo = Gemstar::GitRepo.new(File.dirname(@lockfile))
+        @git_repo = project ? project.git_repo : Gemstar::GitRepo.new(File.dirname(@lockfile))
+        @from = resolve_since_commit if since
       end
 
       def run
-        # logic to diff from/to, find updated gems, fetch changelogs
-
-        #+++ edit_gitignore?
-
-        @lockfile_full_path = git_repo.get_full_path(File.basename(lockfile))
-        puts "Lockfile path: #{lockfile_full_path}"
-
-        old = LockFile.new(content: git_repo.show_blob_at(@from, lockfile_full_path))
-        new = @to ?
-                LockFile.new(content: git_repo.show_blob_at(@to, lockfile_full_path)) :
-                LockFile.new(path: lockfile)
-
-        collect_updates(new_lockfile: new, old_lockfile: old)
+        project ? run_project_diff : run_lockfile_diff
+        @considered_commits = collect_considered_commits
 
         rendered_output = output_renderer.render_diff(self)
         File.write(output_file, rendered_output)
-        puts "✅ Changelog report created: #{File.expand_path(output_file)}"
+        puts "✅ Changelog report created: #{output_file_url}"
 
         if failed.any?
           puts "\n⚠️ The following gems failed to process:"
@@ -65,11 +67,46 @@ module Gemstar
         :html
       end
 
+      def normalize_ecosystem(value)
+        normalized = value.to_s.strip.downcase
+        return "all" if normalized.empty?
+        return normalized if %w[all gems js].include?(normalized)
+
+        raise Thor::Error, "Unsupported ecosystem #{value.inspect}. Expected one of: all, gems, js"
+      end
+
+      def normalize_since(value)
+        normalized = value.to_s.strip
+        return nil if normalized.empty?
+
+        if @options[:from].to_s.strip != ""
+          raise Thor::Error, "--since cannot be combined with --from"
+        end
+
+        normalized.match?(/\bago\z/i) ? normalized : "#{normalized} ago"
+      end
+
+      def resolve_since_commit
+        commit = git_repo.commit_before(since)
+        @since_cutoff_commit = git_repo.commit_info(commit)
+        commit
+      end
+
+      def log_since_cutoff
+        return unless since
+
+        puts "Since cutoff: #{since} -> #{format_commit(since_cutoff_commit, fallback_revision: from)}"
+      end
+
       def default_output_file
         extension = output_format == :markdown ? "md" : "html"
         File.join(Dir.tmpdir, "gem_update_changelog.#{extension}")
       end
 
+      def output_file_url
+        "file://#{URI::DEFAULT_PARSER.escape(File.expand_path(output_file))}"
+      end
+
       def output_renderer
         @output_renderer ||= case output_format
         when :markdown
@@ -79,8 +116,42 @@ module Gemstar
         end
       end
 
-      def build_entry(gem_name:, old_version:, new_version:)
-        metadata = Gemstar::RubyGemsMetadata.new(gem_name)
+      def collect_considered_commits
+        git_repo.commits_between(from, commit_log_to_revision)
+      rescue StandardError => e
+        warn "Could not collect considered commits: #{e.message}"
+        []
+      end
+
+      def format_commit(commit, fallback_revision:)
+        return fallback_revision.to_s if commit.nil?
+
+        date = commit[:authored_at].to_s.split("T").first
+        label = [commit[:short_sha] || commit[:id], commit[:subject]].compact.join(" ")
+        date.empty? ? label : "#{label} (#{date})"
+      end
+
+      public :format_commit
+
+      def commit_log_to_revision
+        return "HEAD" if to.nil? || to == "worktree"
+
+        to
+      end
+
+      def project_name
+        return project.name if project
+
+        Pathname.getwd.basename.to_s
+      end
+
+      public :project_name
+
+      def build_entry(package_state:)
+        package_name = package_state[:name]
+        old_version = package_state[:old_version]
+        new_version = package_state[:new_version]
+        metadata = metadata_for(package_state)
         repo_url = metadata.repo_uri
         changelog = Gemstar::ChangeLog.new(metadata)
         sections = changelog.extract_relevant_sections(old_version, new_version)
@@ -102,14 +173,17 @@ module Gemstar
           end
         end
 
-        homepage_url = metadata.meta["homepage_uri"] || metadata.meta["source_code_uri"] || "https://rubygems.org/gems/#{gem_name}"
+        homepage_url = metadata.meta["homepage_uri"] || metadata.meta["source_code_uri"] || "https://rubygems.org/gems/#{package_name}"
         description = metadata.meta["info"]
 
         entry = {
           old: old_version,
           new: new_version,
           homepage_url: homepage_url,
-          description: description
+          description: description,
+          package_scope: package_state[:package_scope],
+          package_type_label: package_state[:package_type_label],
+          version_label: package_state[:version_label]
         }
         entry[:sections] = sections unless sections.nil? || sections.empty?
         entry[:compare_url] = compare_url if compare_url
@@ -133,29 +207,81 @@ module Gemstar
         entry
       end
 
-      def collect_updates(new_lockfile:, old_lockfile:)
+      def metadata_for(package_state)
+        if package_state[:package_scope] == "js"
+          Gemstar::NpmMetadata.new(package_state[:name])
+        else
+          Gemstar::RubyGemsMetadata.new(package_state[:name])
+        end
+      end
+
+      def run_lockfile_diff
+        validate_lockfile_ecosystem!
+
+        @lockfile_full_path = git_repo.get_full_path(File.basename(lockfile))
+        puts "Lockfile path: #{lockfile_full_path}"
+        log_since_cutoff
+
+        old = LockFile.new(content: git_repo.show_blob_at(@from, lockfile_full_path))
+        new = @to ?
+                LockFile.new(content: git_repo.show_blob_at(@to, lockfile_full_path)) :
+                LockFile.new(path: lockfile)
+
+        collect_lockfile_updates(new_lockfile: new, old_lockfile: old)
+      end
+
+      def run_project_diff
+        puts "Project path: #{project.directory}"
+        log_since_cutoff
+
+        changed_states = project.gem_states(from_revision_id: from, to_revision_id: to || "worktree")
+          .select { |package_state| include_package_state?(package_state) }
+          .reject { |package_state| package_state[:status] == :unchanged }
+        changed_states = disambiguate_duplicate_names(changed_states)
+        collect_project_updates(changed_states)
+      end
+
+      def collect_lockfile_updates(new_lockfile:, old_lockfile:)
+        package_states = new_lockfile.specs.keys.sort.map do |gem_name|
+          old_version = old_lockfile.specs[gem_name]
+          new_version = new_lockfile.specs[gem_name]
+          next if old_version == new_version
+
+          {
+            name: gem_name,
+            display_name: gem_name,
+            package_scope: "gems",
+            package_type_label: "Gem",
+            old_version: old_version,
+            new_version: new_version,
+            version_label: version_label(old_version, new_version)
+          }
+        end.compact
+
+        collect_project_updates(package_states)
+      end
+
+      def collect_project_updates(package_states)
         @updates = {}
         @failed = []
         mutex = Mutex.new
         pool = Concurrent::FixedThreadPool.new(10)
 
-        new_lockfile.specs.keys.sort.each do |gem_name|
+        package_states.each do |package_state|
           pool.post do
-            next unless @debug_gem_regex.match?(gem_name)
-
-            old_version = old_lockfile.specs[gem_name]
-            new_version = new_lockfile.specs[gem_name]
-            next if old_version == new_version
+            package_name = package_state[:name]
+            next unless @debug_gem_regex.match?(package_name)
 
-            puts "#{gem_name} (#{old_version || "new"} → #{new_version})..."
+            puts "#{package_state[:display_name] || package_name} (#{package_state[:version_label]})..."
 
             begin
-              entry = build_entry(gem_name: gem_name, old_version: old_version, new_version: new_version)
+              entry = build_entry(package_state: package_state)
+              display_name = package_state[:display_name] || package_name
 
-              mutex.synchronize { updates[gem_name] = entry }
+              mutex.synchronize { updates[display_name] = entry }
             rescue => e
-              mutex.synchronize { failed << [gem_name, e.message] }
-              puts "⚠️ Failed to process #{gem_name}: #{e.message}"
+              mutex.synchronize { failed << [package_name, e.message] }
+              puts "⚠️ Failed to process #{package_name}: #{e.message}"
             end
           end
         end
@@ -165,6 +291,46 @@ module Gemstar
 
         @updates = updates
       end
+
+      def include_package_state?(package_state)
+        ecosystem == "all" || package_state[:package_scope] == ecosystem
+      end
+
+      def validate_lockfile_ecosystem!
+        return if %w[all gems].include?(ecosystem)
+
+        raise Thor::Error, "--ecosystem=#{ecosystem} requires --project because lockfile mode only supports gems"
+      end
+
+      def disambiguate_duplicate_names(package_states)
+        counts = package_states.each_with_object(Hash.new(0)) do |package_state, index|
+          index[package_state[:name]] += 1
+        end
+
+        package_states.map do |package_state|
+          next package_state.merge(display_name: package_state[:name]) if counts[package_state[:name]] == 1
+
+          suffix = case package_state[:package_source_file]
+          when :importmap
+            "importmap"
+          when :package_lock
+            "package-lock"
+          else
+            package_state[:package_scope]
+          end
+
+          package_state.merge(display_name: "#{package_state[:name]} (#{suffix})")
+        end
+      end
+
+      def version_label(old_version, new_version)
+        return "new → #{new_version}" if old_version.nil? && !new_version.nil?
+        return "#{old_version} → removed" if !old_version.nil? && new_version.nil?
+        return new_version.to_s if old_version == new_version
+
+        "#{old_version} → #{new_version}"
+      end
+
     end
   end
 end

data/lib/gemstar/commands/server.rb

@@ -1,5 +1,7 @@
 require_relative "command"
+require "socket"
 require "shellwords"
+require "rbconfig"
 
 module Gemstar
   module Commands
@@ -14,14 +16,18 @@ module Gemstar
       attr_reader :port
       attr_reader :project_inputs
       attr_reader :reload
+      attr_reader :open_browser
+      attr_reader :explicit_port
 
       def initialize(options)
         super
 
         @bind = options[:bind] || DEFAULT_BIND
+        @explicit_port = !options[:port].nil?
         @port = (options[:port] || DEFAULT_PORT).to_i
         @project_inputs = normalize_project_inputs(options[:project])
         @reload = options[:reload]
+        @open_browser = options[:open]
       end
 
       def run
@@ -34,10 +40,11 @@ module Gemstar
         require "gemstar/web/app"
 
         Gemstar::Config.ensure_home_directory!
+        @port = resolve_port
 
         projects = load_projects
         log_loaded_projects(projects)
-        cache_warmer = start_background_cache_refresh(projects)
+        cache_warmer = build_cache_warmer
         app = Gemstar::Web::App.build(projects: projects, config_home: Gemstar::Config.home_directory, cache_warmer: cache_warmer)
         app = Gemstar::RequestLogger.new(app, io: $stderr) if debug_request_logging?
 
@@ -45,10 +52,12 @@ module Gemstar
         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)
+          Logger: Gemstar::WEBrickLogger.new($stderr, WEBrick::BasicLog::INFO),
+          StartCallback: server_start_callback(projects, cache_warmer)
         )
       end
 
@@ -121,9 +130,10 @@ module Gemstar
       def server_arguments_without_reload
         args = [
           "server",
-          "--bind", bind,
-          "--port", port.to_s
+          "--bind", bind
         ]
+        args += ["--port", port.to_s] if explicit_port
+        args << "--open" if open_browser
         project_inputs.each do |project|
           args << "--project"
           args << project
@@ -146,14 +156,88 @@ module Gemstar
         ENV["DEBUG"] == "1"
       end
 
-      def start_background_cache_refresh(projects)
-        gem_names = projects.flat_map do |project|
-          project.current_lockfile&.specs&.keys || []
-        end.uniq.sort
+      def resolve_port
+        return port if explicit_port
 
-        return nil if gem_names.empty?
+        find_available_port(starting_at: port)
+      end
+
+      def find_available_port(starting_at:, limit: 100)
+        starting_at.upto(starting_at + limit - 1) do |candidate|
+          return candidate if port_available?(candidate)
+        end
+
+        raise Thor::Error, "No available port found from #{starting_at} to #{starting_at + limit - 1}"
+      end
+
+      def port_available?(candidate)
+        server = TCPServer.new(bind, candidate)
+        server.close
+        true
+      rescue Errno::EADDRINUSE, Errno::EACCES, SocketError
+        false
+      end
+
+      def build_cache_warmer
+        Gemstar::CacheWarmer.new(io: $stderr, debug: debug_request_logging? || Gemstar.debug?, thread_count: 10)
+      end
+
+      def start_background_cache_refresh(projects, cache_warmer)
+        package_states = projects.flat_map do |project|
+          project.gem_states(from_revision_id: "worktree", to_revision_id: "worktree")
+        end
+
+        return nil if package_states.empty?
+
+        cache_warmer.enqueue_many(package_states)
+      end
+
+      def server_start_callback(projects, cache_warmer)
+        proc do
+          Thread.new do
+            sleep 0.15
+            start_background_cache_refresh(projects, cache_warmer)
+            launch_browser
+          end
+        end
+      end
+
+      def launch_browser
+        return unless open_browser
+
+        command = browser_command(root_url)
+        return unless command
+
+        pid = spawn(*command, out: File::NULL, err: File::NULL)
+        Process.detach(pid)
+      rescue StandardError => e
+        warn "Could not open browser automatically: #{e.message}"
+      end
+
+      def browser_command(url)
+        host_os = RbConfig::CONFIG["host_os"].to_s
+
+        if host_os.include?("darwin")
+          [find_executable("open") || "/usr/bin/open", url]
+        elsif host_os.match?(/linux|bsd/)
+          executable = find_executable("xdg-open")
+          executable ? [executable, url] : nil
+        elsif host_os.match?(/mswin|mingw|cygwin/)
+          ["cmd", "/c", "start", "", url]
+        end
+      end
+
+      def find_executable(name)
+        ENV.fetch("PATH", "").split(File::PATH_SEPARATOR).each do |directory|
+          candidate = File.join(directory, name)
+          return candidate if File.file?(candidate) && File.executable?(candidate)
+        end
+
+        nil
+      end
 
-        Gemstar::CacheWarmer.new(io: $stderr, debug: debug_request_logging? || Gemstar.debug?, thread_count: 10).enqueue_many(gem_names)
+      def root_url
+        "http://#{bind}:#{port}/"
       end
     end
   end

data/lib/gemstar/data/importmap_package_metadata.json

@@ -0,0 +1,22 @@
+{
+  "@rails/actioncable": {
+    "provider_gem": "actioncable",
+    "repo_url": "https://github.com/rails/rails"
+  },
+  "@rails/actiontext": {
+    "provider_gem": "actiontext",
+    "repo_url": "https://github.com/rails/rails"
+  },
+  "@rails/activestorage": {
+    "provider_gem": "activestorage",
+    "repo_url": "https://github.com/rails/rails"
+  },
+  "@hotwired/stimulus-loading": {
+    "provider_gem": "stimulus-rails",
+    "repo_url": "https://github.com/hotwired/stimulus-rails"
+  },
+  "@hotwired/turbo-rails": {
+    "provider_gem": "turbo-rails",
+    "repo_url": "https://github.com/hotwired/turbo-rails"
+  }
+}

data/lib/gemstar/data/ruby_gems_metadata.json

@@ -0,0 +1,9 @@
+{
+  "aws-*": {
+    "changelog": {
+      "raw_base": "https://raw.githubusercontent.com/aws/aws-sdk-ruby/refs/heads/version-3/gems/{gem_name}",
+      "paths": ["CHANGELOG.md"],
+      "branches": [""]
+    }
+  }
+}

data/lib/gemstar/git_repo.rb

@@ -54,9 +54,7 @@ module Gemstar
       # If it looks like a pure date (or you want to support "date only"),
       # map it to "latest commit before date on default_branch".
       if revish =~ /\d{4}-\d{2}-\d{2}/ || revish =~ /\d{1,2}:\d{2}/i
-        sha = run_git_command(["rev-list", "-1", "--before", revish, default_branch])
-        raise "No commit before #{revish} on #{default_branch}" if sha.empty?
-        return sha
+        return commit_before(revish, default_branch:)
       end
 
       # Otherwise let Git parse whatever the user typed.
@@ -65,6 +63,13 @@ module Gemstar
       sha
     end
 
+    def commit_before(time_expression, default_branch: "HEAD")
+      sha = run_git_command(["rev-list", "-1", "--before", time_expression, default_branch])
+      raise "No commit before #{time_expression} on #{default_branch}" if sha.empty?
+
+      sha
+    end
+
     def show_blob_at(revish, path)
       commit = resolve_commit(revish)
       run_git_command(["show", "#{commit}:#{path}"])
@@ -101,8 +106,41 @@ module Gemstar
       run_git_command(command, in_directory: tree_root_directory)
     end
 
+    def commits_between(from_revision, to_revision = "HEAD")
+      return [] if tree_root_directory.nil? || tree_root_directory.empty?
+
+      range = "#{from_revision}..#{to_revision || "HEAD"}"
+      format = "%H%x1f%h%x1f%aI%x1f%s"
+      output = try_git_command(["log", "--reverse", "--pretty=format:#{format}", range], in_directory: tree_root_directory)
+      return [] if output.nil? || output.empty?
+
+      output.lines.filter_map { |line| parse_commit_log_line(line) }
+    end
+
+    def commit_info(revision)
+      return nil if tree_root_directory.nil? || tree_root_directory.empty?
+
+      format = "%H%x1f%h%x1f%aI%x1f%s"
+      output = try_git_command(["show", "-s", "--pretty=format:#{format}", revision], in_directory: tree_root_directory)
+      return nil if output.nil? || output.empty?
+
+      parse_commit_log_line(output)
+    end
+
     private
 
+    def parse_commit_log_line(line)
+      full_sha, short_sha, authored_at, subject = line.strip.split("\u001f", 4)
+      return nil if full_sha.nil? || full_sha.empty?
+
+      {
+        id: full_sha,
+        short_sha: short_sha,
+        authored_at: authored_at,
+        subject: subject
+      }
+    end
+
     def normalize_remote_url(remote)
       normalized = remote.strip.sub(%r{\.git\z}, "")