Replace the backtraces on the missing-file paths of rbs collection

Running `rbs collection install` before the files it needs exist ended in
an uncaught exception with a full backtrace, because `exe/rbs` has no
rescue. Someone -- or a coding agent -- who sees that concludes that
`rbs collection` is broken and goes back to listing gems with `library`.
`rbs collection init` now points at `rbs collection install`, so these
paths are easier to reach than they were.

Four of them:

- No `rbs_collection.yaml`: `Errno::ENOENT` from `Config.from_path`, for
  both `install` and `update`. Now a message naming `rbs collection init`.
- No `rbs_collection.lock.yaml` under `--frozen`: `Errno::ENOENT` from
  `Installer#initialize`. The message says to run without `--frozen`, or,
  when the config is missing too, to run `rbs collection init` first, so
  that one message is enough to get unstuck.
- No `Gemfile`: `Bundler::GemfileNotFound` from `Bundler.definition`.
- A `Gemfile` but no `Gemfile.lock`: `Bundler.definition` returns, and
  `LockfileGenerator#initialize` dies with `undefined method 'specs' for
  nil` on `definition.locked_gems.specs`. Now a message naming
  `bundle install`.

Raising `RBS::Collection::Config::CollectionNotAvailable`, as the issue
suggested, would keep the backtrace for exactly the same reason, so these
write to `stderr` and return 1 like the rest of `run_collection`.

`already exists` and `should exist to clean` used `Kernel#puts`, which
writes to the real `$stdout` and ignores the injected IO. Both are failures
that return 1, so they go to `stderr` now; this changes which stream they
appear on.

Tests cover each of the four paths, `--frozen` with neither file, and
`--frozen` with a lock file and no config, which keeps working.

Ref: #3093

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01BXtMkmp27LieHgSjNyEWZ8

Author: pocke

lib/rbs/cli.rb

@@ -1089,17 +1089,30 @@ def run_collection(args, options)
 
       case args[0]
       when 'install', 'instal', 'insta', 'inst', 'ins', 'in', 'i'
-        unless params[:frozen]
-          Collection::Config.generate_lockfile(config_path: config_path, definition: Bundler.definition)
+        if params[:frozen]
+          unless lock_path.exist?
+            if config_path.exist?
+              stderr.puts "#{lock_path} not found. Run `rbs collection install` without `--frozen` to generate it."
+            else
+              stderr.puts "#{lock_path} not found. Run `rbs collection init` and `rbs collection install` to generate it."
+            end
+            return 1
+          end
+        else
+          return 1 unless collection_config_available?(config_path)
+          definition = bundler_definition or return 1
+          Collection::Config.generate_lockfile(config_path: config_path, definition: definition)
         end
         Collection::Installer.new(lockfile_path: lock_path, stdout: stdout).install_from_lockfile
       when 'update', 'updat', 'upda', 'upd', 'up', 'u'
+        return 1 unless collection_config_available?(config_path)
+        definition = bundler_definition or return 1
         # TODO: Be aware of argv to update only specified gem
-        Collection::Config.generate_lockfile(config_path: config_path, definition: Bundler.definition, with_lockfile: false)
+        Collection::Config.generate_lockfile(config_path: config_path, definition: definition, with_lockfile: false)
         Collection::Installer.new(lockfile_path: lock_path, stdout: stdout).install_from_lockfile
       when 'init'
         if config_path.exist?
-          puts "#{config_path} already exists"
+          stderr.puts "#{config_path} already exists"
           return 1
         end
 
@@ -1142,20 +1155,38 @@ def run_collection(args, options)
         MESSAGE
       when 'clean'
         unless lock_path.exist?
-          puts "#{lock_path} should exist to clean"
+          stderr.puts "#{lock_path} should exist to clean"
           return 1
         end
         Collection::Cleaner.new(lockfile_path: lock_path)
       when 'help', 'hel', 'he', 'h'
-        puts opts.help
+        stdout.puts opts.help
       else
-        puts opts.help
+        stdout.puts opts.help
         return 1
       end
 
       0
     end
 
+    def collection_config_available?(config_path)
+      return true if config_path.exist?
+
+      stderr.puts "#{config_path} not found. Run `rbs collection init` to generate it."
+      false
+    end
+
+    def bundler_definition
+      definition = Bundler.definition
+      return definition if definition.lockfile.file?
+
+      stderr.puts "#{definition.lockfile} not found. Run `bundle install` to generate it."
+      nil
+    rescue Bundler::GemfileNotFound
+      stderr.puts "Gemfile not found. `rbs collection` reads the gems to install from Gemfile.lock."
+      nil
+    end
+
     def collection_options(args)
       OptionParser.new do |opts|
         opts.banner = <<~HELP

sig/cli.rbs

@@ -76,6 +76,12 @@ module RBS
 
     def run_collection: (Array[String], LibraryOptions) -> Integer
 
+    # Returns `true` if the collection config exists, otherwise prints a message to `stderr` and returns `false`
+    def collection_config_available?: (Pathname) -> bool
+
+    # Returns `nil` if `Gemfile` or `Gemfile.lock` is not found, after printing a message to `stderr`
+    def bundler_definition: () -> Bundler::Definition?
+
     def run_annotate: (Array[String], top) -> Integer
 
     def run_subtract: (Array[String], top) -> Integer

sig/shims/bundler.rbs

@@ -1,4 +1,7 @@
 module Bundler
+  class GemfileNotFound < StandardError
+  end
+
   class LockfileParser
     def initialize: (String) -> void
 

test/rbs/cli_test.rb

@@ -1106,6 +1106,110 @@ def test_collection_init
     end
   end
 
+  def test_collection_install_without_config
+    Dir.mktmpdir do |dir|
+      Dir.chdir(dir) do
+        with_cli do |cli|
+          refute_cli_success do
+            cli.run(%w(collection install))
+          end
+
+          assert_match(/rbs_collection\.yaml not found/, stderr.string)
+          assert_match(/rbs collection init/, stderr.string)
+        end
+      end
+    end
+  end
+
+  def test_collection_update_without_config
+    Dir.mktmpdir do |dir|
+      Dir.chdir(dir) do
+        with_cli do |cli|
+          refute_cli_success do
+            cli.run(%w(collection update))
+          end
+
+          assert_match(/rbs_collection\.yaml not found/, stderr.string)
+          assert_match(/rbs collection init/, stderr.string)
+        end
+      end
+    end
+  end
+
+  def test_collection_install_without_gemfile
+    Dir.mktmpdir do |dir|
+      Dir.chdir(dir) do
+        Pathname(dir).join(RBS::Collection::Config::PATH).write(<<~YAML)
+          sources: []
+          path: .gem_rbs_collection
+        YAML
+
+        _stdout, stderr = run_rbs_collection("install", bundler: false) do |status|
+          refute_predicate status, :success?
+        end
+
+        assert_match(/Gemfile not found/, stderr)
+      end
+    end
+  end
+
+  def test_collection_install_without_gemfile_lock
+    Dir.mktmpdir do |dir|
+      Dir.chdir(dir) do
+        dir = Pathname(dir)
+        dir.join(RBS::Collection::Config::PATH).write(<<~YAML)
+          sources: []
+          path: .gem_rbs_collection
+        YAML
+        dir.join("Gemfile").write(<<~RUBY)
+          source "https://rubygems.org"
+        RUBY
+
+        _stdout, stderr = run_rbs_collection("install", bundler: false) do |status|
+          refute_predicate status, :success?
+        end
+
+        assert_match(/Gemfile\.lock not found/, stderr)
+        assert_match(/bundle install/, stderr)
+      end
+    end
+  end
+
+  def test_collection_install_frozen_without_lockfile
+    Dir.mktmpdir do |dir|
+      Dir.chdir(dir) do
+        Pathname(dir).join(RBS::Collection::Config::PATH).write(<<~YAML)
+          sources: []
+          path: .gem_rbs_collection
+        YAML
+
+        with_cli do |cli|
+          refute_cli_success do
+            cli.run(%w(collection install --frozen))
+          end
+
+          assert_match(/rbs_collection\.lock\.yaml not found/, stderr.string)
+          assert_match(/without `--frozen`/, stderr.string)
+        end
+      end
+    end
+  end
+
+  def test_collection_install_frozen_without_config_and_lockfile
+    Dir.mktmpdir do |dir|
+      Dir.chdir(dir) do
+        with_cli do |cli|
+          refute_cli_success do
+            cli.run(%w(collection install --frozen))
+          end
+
+          assert_match(/rbs_collection\.lock\.yaml not found/, stderr.string)
+          assert_match(/rbs collection init/, stderr.string)
+        end
+      end
+    end
+  end
+
   def test_collection_install
     omit_on_jruby! "`rbs collection install` runs `bundle install`, which builds native gem extensions that do not compile on JRuby"