tapioca 0.16.9 → 0.17.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b2d6abd53e84e3b22cc6045597788c98d8f9571f486976baa8db4e5beb6ccd10
-  data.tar.gz: 5aa9162275489d2280f07419f74a4243c9ee813f922dd367e6260bae0fa37331
+  metadata.gz: d003e839857cc260e7b1ab86fd4a48d93efc53e4a43ac9ccac6c85d9a89e63a1
+  data.tar.gz: 900f2d0369802b0fac34f60c04e3c238cd68e439c1d6d60f4b9ed5d8c82770f0
 SHA512:
-  metadata.gz: 4fd946bacca4a56fe9f9befaa65404393719cacedf4877ce2e8ba0d9d5ab150d9957bea7298783a04e456170086b035b06b42b0312bc2840e1465631259801a1
-  data.tar.gz: '0825b9451bed3958b7132008993675de624753d41d5b7b267b50e8b7cf2900f344e5c666ac7726686ebfe9c997592dec6c02b5b2e1d14b144cdbaf837daeac08'
+  metadata.gz: b2f68a283b2499203877730fb5f981ed1e6c09c686a6c3e59297bea18361b5dd2d1831581f7b3edce6cf38936819544feeeebe59b1747520738542b0ae606ffe
+  data.tar.gz: '09769a8ab2aac1763cadecd013c9979c58d750c052f94c26eccfcbbd0a7ca07e0cb027c18e3737e90b90e85d4bebfca2fb4e8e559fdd9c4a0dd472ce5e59ee77'

data/README.md

@@ -52,6 +52,9 @@ Tapioca makes it easy to work with [Sorbet](https://sorbet.org) in your codebase
     * [Writing custom DSL extensions](#writing-custom-dsl-extensions)
   * [RBI files for missing constants and methods](#rbi-files-for-missing-constants-and-methods)
   * [Configuration](#configuration)
+* [Editor Integration](#editor-integration)
+  * [Setup](#setup)
+  * [Features](#features)
 * [Contributing](#contributing)
   * [DSL compilers](#dsl-compilers)
 * [License](#license)
@@ -395,6 +398,12 @@ Tapioca also supports pulling annotations from multiple sources:
 $ bin/tapioca annotations --sources https://raw.githubusercontent.com/$USER/$REPO1/$BRANCH https://raw.githubusercontent.com/$USER/$REPO2/$BRANCH
 ```
 
+You can also specify a local directory path to pull annotations from
+
+```shell
+$ bin/tapioca annotations --sources path/to/folder
+```
+
 #### Basic authentication
 
 Private repositories can be used as sources by passing the option `--auth` with an authentication string. For Github, this string is `token $TOKEN` where `$TOKEN` is a [personal access token](https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/creating-a-personal-access-token):
@@ -993,6 +1002,18 @@ annotations:
 ```
 <!-- END_CONFIG_TEMPLATE -->
 
+## Editor Integration
+
+### Setup
+
+Tapioca supports generating RBIs upon file changes through the [Ruby LSP's add-on system](https://shopify.github.io/ruby-lsp/#add-ons). It's enabled by default on VS Code using [Ruby LSP](https://shopify.github.io/ruby-lsp/#usage), and you can enable it for other editors by supplying the `enabledFeatureFlags` option in LSP configuration with a hash value of `"tapiocaAddon": true`.
+
+If you'd like to disable the Tapioca add-on you can set `tapiocaAddon` to `false` in your LSP configuration. For VS Code this looks like `"rubyLsp.featureFlags": { "tapiocaAddon": false }` in your `settings.json`.
+
+### Features
+- DSL RBI generation: When editing a Ruby file, Tapioca will execute `bin/tapioca dsl` with the constants found in your file, e.g. `bin/tapioca dsl MyClass`
+- Gem RBI generation: When changes are made to `Gemfile.lock`, Tapioca will execute `bin/tapioca gem` with the updated gem names, e.g. `bin/tapioca gem my_gem`
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/Shopify/tapioca. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](https://github.com/Shopify/tapioca/blob/main/CODE_OF_CONDUCT.md) code of conduct.

data/exe/tapioca

@@ -27,4 +27,9 @@ end
 
 require_relative "../lib/tapioca/internal"
 
-Tapioca::Cli.start(ARGV)
+begin
+  Tapioca::Cli.start(ARGV)
+rescue Tapioca::Error => e
+  warn(e.message)
+  exit(1)
+end

data/lib/ruby_lsp/tapioca/addon.rb

@@ -1,7 +1,7 @@
 # typed: strict
 # frozen_string_literal: true
 
-RubyLsp::Addon.depend_on_ruby_lsp!(">= 0.23.1", "< 0.24")
+RubyLsp::Addon.depend_on_ruby_lsp!(">= 0.23.10", "< 0.27")
 
 begin
   # The Tapioca add-on depends on the Rails add-on to add a runtime component to the runtime server. We can allow the
@@ -18,21 +18,20 @@ require "ruby_lsp/tapioca/run_gem_rbi_check"
 module RubyLsp
   module Tapioca
     class Addon < ::RubyLsp::Addon
-      extend T::Sig
-
-      sig { void }
+      #: -> void
       def initialize
         super
 
-        @global_state = T.let(nil, T.nilable(RubyLsp::GlobalState))
-        @rails_runner_client = T.let(Rails::NullClient.new, RubyLsp::Rails::RunnerClient)
-        @index = T.let(nil, T.nilable(RubyIndexer::Index))
-        @file_checksums = T.let({}, T::Hash[String, String])
-        @lockfile_diff = T.let(nil, T.nilable(String))
-        @outgoing_queue = T.let(nil, T.nilable(Thread::Queue))
+        @global_state = nil #: RubyLsp::GlobalState?
+        @rails_runner_client = Rails::NullClient.new #: RubyLsp::Rails::RunnerClient
+        @index = nil #: RubyIndexer::Index?
+        @file_checksums = {} #: Hash[String, String]
+        @lockfile_diff = nil #: String?
+        @outgoing_queue = nil #: Thread::Queue?
       end
 
-      sig { override.params(global_state: RubyLsp::GlobalState, outgoing_queue: Thread::Queue).void }
+      # @override
+      #: (RubyLsp::GlobalState global_state, Thread::Queue outgoing_queue) -> void
       def activate(global_state, outgoing_queue)
         @global_state = global_state
         return unless @global_state.enabled_feature?(:tapiocaAddon)
@@ -43,7 +42,7 @@ module RubyLsp
           # Get a handle to the Rails add-on's runtime client. The call to `rails_runner_client` will block this thread
           # until the server has finished booting, but it will not block the main LSP. This has to happen inside of a
           # thread
-          addon = T.cast(::RubyLsp::Addon.get("Ruby LSP Rails", ">= 0.4.0", "< 0.5"), ::RubyLsp::Rails::Addon)
+          addon = ::RubyLsp::Addon.get("Ruby LSP Rails", ">= 0.4.0", "< 0.5") #: as ::RubyLsp::Rails::Addon
           @rails_runner_client = addon.rails_runner_client
           @outgoing_queue << Notification.window_log_message("Activating Tapioca add-on v#{version}")
           @rails_runner_client.register_server_addon(File.expand_path("server_addon.rb", __dir__))
@@ -53,8 +52,11 @@ module RubyLsp
             workspace_path: @global_state.workspace_path,
           )
 
+          send_usage_telemetry("activated")
           run_gem_rbi_check
         rescue IncompatibleApiError
+          send_usage_telemetry("incompatible_api_error")
+
           # The requested version for the Rails add-on no longer matches. We need to upgrade and fix the breaking
           # changes
           @outgoing_queue << Notification.window_log_message(
@@ -64,36 +66,39 @@ module RubyLsp
         end
       end
 
-      sig { override.void }
+      # @override
+      #: -> void
       def deactivate
       end
 
-      sig { override.returns(String) }
+      # @override
+      #: -> String
       def name
         "Tapioca"
       end
 
-      sig { override.returns(String) }
+      # @override
+      #: -> String
       def version
-        "0.1.1"
+        "0.1.3"
       end
 
-      sig { params(changes: T::Array[{ uri: String, type: Integer }]).void }
+      #: (Array[{uri: String, type: Integer}] changes) -> void
       def workspace_did_change_watched_files(changes)
-        return unless T.must(@global_state).enabled_feature?(:tapiocaAddon)
+        return unless @global_state&.enabled_feature?(:tapiocaAddon)
         return unless @rails_runner_client.connected?
 
-        has_route_change = T.let(false, T::Boolean)
-        has_fixtures_change = T.let(false, T::Boolean)
-        needs_compiler_reload = T.let(false, T::Boolean)
+        has_route_change = false #: bool
+        has_fixtures_change = false #: bool
+        needs_compiler_reload = false #: bool
+        index = @index #: as !nil
 
         constants = changes.flat_map do |change|
-          path = URI(change[:uri]).to_standardized_path
-          next if path.end_with?("_test.rb", "_spec.rb")
-          next unless file_updated?(change, path)
+          path = URI(change[:uri]).to_standardized_path #: String?
+          next unless path && file_updated?(change, path)
 
-          if File.fnmatch?("**/tapioca/**/compilers/**/*.rb", path, File::FNM_PATHNAME)
-            needs_compiler_reload = true
+          if File.fnmatch("**/fixtures/**/*.yml{,.erb}", path, File::FNM_PATHNAME | File::FNM_EXTGLOB)
+            has_fixtures_change = true
             next
           end
 
@@ -102,13 +107,14 @@ module RubyLsp
             next
           end
 
-          # NOTE: We only get notification for fixtures if ruby-lsp-rails is v0.3.31 or higher
-          if File.fnmatch("**/fixtures/**/*.yml{,.erb}", path, File::FNM_PATHNAME | File::FNM_EXTGLOB)
-            has_fixtures_change = true
+          next if File.fnmatch?("**/{test,spec,features}/**/*", path, File::FNM_PATHNAME | File::FNM_EXTGLOB)
+
+          if File.fnmatch?("**/tapioca/**/compilers/**/*.rb", path, File::FNM_PATHNAME)
+            needs_compiler_reload = true
             next
           end
 
-          entries = T.must(@index).entries_for(change[:uri])
+          entries = index.entries_for(change[:uri])
           next unless entries
 
           entries.filter_map do |entry|
@@ -124,19 +130,22 @@ module RubyLsp
           @rails_runner_client.delegate_notification(
             server_addon_name: "Tapioca",
             request_name: "reload_workspace_compilers",
-            workspace_path: T.must(@global_state).workspace_path,
+            workspace_path: @global_state.workspace_path,
           )
         end
 
         if has_route_change
+          send_usage_telemetry("route_dsl")
           @rails_runner_client.delegate_notification(server_addon_name: "Tapioca", request_name: "route_dsl")
         end
 
         if has_fixtures_change
+          send_usage_telemetry("fixtures_dsl")
           @rails_runner_client.delegate_notification(server_addon_name: "Tapioca", request_name: "fixtures_dsl")
         end
 
         if constants.any?
+          send_usage_telemetry("dsl")
           @rails_runner_client.delegate_notification(
             server_addon_name: "Tapioca",
             request_name: "dsl",
@@ -147,8 +156,29 @@ module RubyLsp
 
       private
 
-      sig { params(change: T::Hash[Symbol, T.untyped], path: String).returns(T::Boolean) }
+      #: (String feature_name) -> void
+      def send_usage_telemetry(feature_name)
+        return unless @outgoing_queue && @global_state
+
+        # Telemetry is not captured by default even if events are produced by the server
+        # See https://github.com/Shopify/ruby-lsp/tree/main/vscode#telemetry
+        @outgoing_queue << Notification.telemetry({
+          eventName: "tapioca_addon.feature_usage",
+          type: "data",
+          data: {
+            type: "counter",
+            attributes: {
+              label: feature_name,
+              machineId: @global_state.telemetry_machine_id,
+            },
+          },
+        })
+      end
+
+      #: (Hash[Symbol, untyped] change, String path) -> bool
       def file_updated?(change, path)
+        queue = @outgoing_queue #: as !nil
+
         case change[:type]
         when Constant::FileChangeType::CREATED
           @file_checksums[path] = Zlib.crc32(File.read(path)).to_s
@@ -156,7 +186,7 @@ module RubyLsp
         when Constant::FileChangeType::CHANGED
           current_checksum = Zlib.crc32(File.read(path)).to_s
           if @file_checksums[path] == current_checksum
-            T.must(@outgoing_queue) << Notification.window_log_message(
+            queue << Notification.window_log_message(
               "File has not changed. Skipping #{path}",
               type: Constant::MessageType::INFO,
             )
@@ -167,7 +197,7 @@ module RubyLsp
         when Constant::FileChangeType::DELETED
           @file_checksums.delete(path)
         else
-          T.must(@outgoing_queue) << Notification.window_log_message(
+          queue << Notification.window_log_message(
             "Unexpected file change type: #{change[:type]}",
             type: Constant::MessageType::WARNING,
           )
@@ -176,18 +206,18 @@ module RubyLsp
         false
       end
 
-      sig { void }
+      #: -> void
       def run_gem_rbi_check
-        gem_rbi_check = RunGemRbiCheck.new(T.must(@global_state).workspace_path)
+        state = @global_state #: as !nil
+        gem_rbi_check = RunGemRbiCheck.new(state.workspace_path)
         gem_rbi_check.run
 
-        T.must(@outgoing_queue) << Notification.window_log_message(
-          gem_rbi_check.stdout,
-        ) unless gem_rbi_check.stdout.empty?
-        T.must(@outgoing_queue) << Notification.window_log_message(
-          gem_rbi_check.stderr,
-          type: Constant::MessageType::WARNING,
-        ) unless gem_rbi_check.stderr.empty?
+        queue = @outgoing_queue #: as !nil
+        queue << Notification.window_log_message(gem_rbi_check.stdout) unless gem_rbi_check.stdout.empty?
+
+        unless gem_rbi_check.stderr.empty?
+          queue << Notification.window_log_message(gem_rbi_check.stderr, type: Constant::MessageType::WARNING)
+        end
       end
     end
   end

data/lib/ruby_lsp/tapioca/run_gem_rbi_check.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require "open3"
@@ -7,21 +7,21 @@ require "ruby_lsp/tapioca/lockfile_diff_parser"
 module RubyLsp
   module Tapioca
     class RunGemRbiCheck
-      extend T::Sig
+      #: String
+      attr_reader :stdout, :stderr
 
-      attr_reader :stdout
-      attr_reader :stderr
+      #: Process::Status?
       attr_reader :status
 
-      sig { params(project_path: String).void }
+      #: (String project_path) -> void
       def initialize(project_path)
         @project_path = project_path
-        @stdout = T.let("", String)
-        @stderr = T.let("", String)
-        @status = T.let(nil, T.nilable(Process::Status))
+        @stdout = "" #: String
+        @stderr = "" #: String
+        @status = nil #: Process::Status?
       end
 
-      sig { void }
+      #: -> void
       def run
         return log_message("Not a git repository") unless git_repo?
 
@@ -34,37 +34,35 @@ module RubyLsp
 
       private
 
-      attr_reader :project_path
-
-      sig { returns(T.nilable(T::Boolean)) }
+      #: -> bool?
       def git_repo?
-        _, status = Open3.capture2e("git", "rev-parse", "--is-inside-work-tree", chdir: project_path)
+        _, status = Open3.capture2e("git", "rev-parse", "--is-inside-work-tree", chdir: @project_path)
         status.success?
       end
 
-      sig { returns(T::Boolean) }
+      #: -> bool
       def lockfile_changed?
         !lockfile_diff.empty?
       end
 
-      sig { returns(Pathname) }
+      #: -> Pathname
       def lockfile
-        @lockfile ||= T.let(Pathname(project_path).join("Gemfile.lock"), T.nilable(Pathname))
+        @lockfile ||= Pathname(@project_path).join("Gemfile.lock") #: Pathname?
       end
 
-      sig { returns(String) }
+      #: -> String
       def lockfile_diff
-        @lockfile_diff ||= T.let(read_lockfile_diff, T.nilable(String))
+        @lockfile_diff ||= read_lockfile_diff #: String?
       end
 
-      sig { returns(String) }
+      #: -> String
       def read_lockfile_diff
         return "" unless lockfile.exist?
 
         execute_in_project_path("git", "diff", lockfile.to_s).strip
       end
 
-      sig { void }
+      #: -> void
       def generate_gem_rbis
         parser = Tapioca::LockfileDiffParser.new(@lockfile_diff)
         removed_gems = parser.removed_gems
@@ -78,18 +76,19 @@ module RubyLsp
         end
       end
 
-      sig { params(gems: T::Array[String]).void }
+      #: (Array[String] gems) -> void
       def execute_tapioca_gem_command(gems)
         Bundler.with_unbundled_env do
-          stdout, stderr, status = T.unsafe(Open3).capture3(
-            "bundle",
-            "exec",
-            "tapioca",
-            "gem",
-            "--lsp_addon",
-            *gems,
-            chdir: project_path,
-          )
+          stdout, stderr, status = Open3 #: as untyped
+            .capture3(
+              "bundle",
+              "exec",
+              "tapioca",
+              "gem",
+              "--lsp_addon",
+              *gems,
+              chdir: @project_path,
+            )
 
           log_message(stdout) unless stdout.empty?
           @stderr = stderr unless stderr.empty?
@@ -97,16 +96,16 @@ module RubyLsp
         end
       end
 
-      sig { params(gems: T::Array[String]).void }
+      #: (Array[String] gems) -> void
       def remove_rbis(gems)
         files = Dir.glob(
           "sorbet/rbi/gems/{#{gems.join(",")}}@*.rbi",
-          base: project_path,
+          base: @project_path,
         )
         delete_files(files, "Removed RBIs for")
       end
 
-      sig { void }
+      #: -> void
       def cleanup_orphaned_rbis
         untracked_files = git_ls_gem_rbis("--others", "--exclude-standard")
         deleted_files = git_ls_gem_rbis("--deleted")
@@ -115,37 +114,38 @@ module RubyLsp
         restore_files(deleted_files, "Restored deleted RBIs")
       end
 
-      sig { params(flags: T.untyped).returns(T::Array[String]) }
+      #: (*untyped flags) -> Array[String]
       def git_ls_gem_rbis(*flags)
-        flags = T.unsafe(["git", "ls-files", *flags, "sorbet/rbi/gems/"])
-
-        execute_in_project_path(*flags)
+        self #: as untyped # rubocop:disable Style/RedundantSelf
+          .execute_in_project_path("git", "ls-files", *flags, "sorbet/rbi/gems/")
           .lines
           .map(&:strip)
       end
 
-      sig { params(files: T::Array[String], message: String).void }
+      #: (Array[String] files, String message) -> void
       def delete_files(files, message)
-        files_to_remove = files.map { |file| File.join(project_path, file) }
+        files_to_remove = files.map { |file| File.join(@project_path, file) }
         FileUtils.rm(files_to_remove)
         log_message("#{message}: #{files.join(", ")}") unless files.empty?
       end
 
-      sig { params(files: T::Array[String], message: String).void }
+      #: (Array[String] files, String message) -> void
       def restore_files(files, message)
         execute_in_project_path("git", "checkout", "--pathspec-from-file=-", stdin: files.join("\n"))
         log_message("#{message}: #{files.join(", ")}") unless files.empty?
       end
 
-      sig { params(message: String).void }
+      #: (String message) -> void
       def log_message(message)
         @stdout += "#{message}\n"
       end
 
+      #: (*String, ?stdin: String?) -> String
       def execute_in_project_path(*parts, stdin: nil)
-        options = { chdir: project_path }
+        options = { chdir: @project_path }
         options[:stdin_data] = stdin if stdin
-        stdout_and_stderr, _status = T.unsafe(Open3).capture2e(*parts, options)
+        stdout_and_stderr, _status = Open3 #: as untyped
+          .capture2e(*parts, options)
         stdout_and_stderr
       end
     end

data/lib/ruby_lsp/tapioca/server_addon.rb

@@ -2,8 +2,6 @@
 # frozen_string_literal: true
 
 require "tapioca/internal"
-require "tapioca/dsl/compilers/url_helpers"
-require "tapioca/dsl/compilers/active_record_fixtures"
 
 module RubyLsp
   module Tapioca
@@ -21,13 +19,16 @@ module RubyLsp
         when "load_compilers_and_extensions"
           # Load DSL extensions and compilers ahead of time, so that we don't have to pay the price of invoking
           # `Gem.find_files` on every execution, which is quite expensive
-          @loader = ::Tapioca::Loaders::Dsl.new(
-            tapioca_path: ::Tapioca::TAPIOCA_DIR,
-            eager_load: false,
-            app_root: params[:workspace_path],
-            halt_upon_load_error: false,
-          )
-          @loader.load_dsl_extensions_and_compilers
+          with_notification_wrapper("load_compilers_and_extensions", "Loading DSL compilers") do
+            ::Tapioca::Dsl::Compiler.extend(T::Generic)
+            @loader = ::Tapioca::Loaders::Dsl.new(
+              tapioca_path: ::Tapioca::TAPIOCA_DIR,
+              eager_load: false,
+              app_root: params[:workspace_path],
+              halt_upon_load_error: false,
+            )
+            @loader.load_dsl_extensions_and_compilers
+          end
         when "dsl"
           fork do
             with_notification_wrapper("dsl", "Generating DSL RBIs") do
@@ -62,11 +63,13 @@ module RubyLsp
       def dsl(constants, *args)
         load("tapioca/cli.rb") # Reload the CLI to reset thor defaults between requests
 
+        ::Tapioca::Cli.addon_mode!
+
         # Order here is important to avoid having Thor confuse arguments. Do not put an array argument at the end before
         # the list of constants
         arguments = ["dsl"]
         arguments.concat(args)
-        arguments.push("--lsp_addon", "--workers=1")
+        arguments.push("--workers=1")
         arguments.concat(constants)
 
         ::Tapioca::Cli.start(arguments)

data/lib/tapioca/bundler_ext/auto_require_hook.rb

@@ -6,19 +6,16 @@ module Tapioca
     # This is a module that gets prepended to `Bundler::Dependency` and
     # makes sure even gems marked as `require: false` are required during
     # `Bundler.require`.
+    # @requires_ancestor: ::Bundler::Dependency
     module AutoRequireHook
       extend T::Sig
-      extend T::Helpers
-
-      requires_ancestor { ::Bundler::Dependency }
-
-      @exclude = T.let([], T::Array[String])
-      @enabled = T.let(false, T::Boolean)
+      @exclude = [] #: Array[String]
+      @enabled = false #: bool
 
       class << self
         extend T::Sig
 
-        sig { params(name: T.untyped).returns(T::Boolean) }
+        #: (untyped name) -> bool
         def excluded?(name)
           @exclude.include?(name)
         end
@@ -27,12 +24,7 @@ module Tapioca
           @enabled
         end
 
-        sig do
-          type_parameters(:Result).params(
-            exclude: T::Array[String],
-            blk: T.proc.returns(T.type_parameter(:Result)),
-          ).returns(T.type_parameter(:Result))
-        end
+        #: [Result] (exclude: Array[String]) { -> Result } -> Result
         def override_require_false(exclude:, &blk)
           @enabled = true
           @exclude = exclude
@@ -42,7 +34,7 @@ module Tapioca
         end
       end
 
-      sig { returns(T.untyped).checked(:never) }
+      #: -> untyped
       def autorequire
         value = super
 

data/lib/tapioca/cli.rb

@@ -143,11 +143,6 @@ module Tapioca
       type: :hash,
       desc: "Options to pass to the DSL compilers",
       default: {}
-    option :lsp_addon,
-      type: :boolean,
-      desc: "Generate DSL RBIs from the LSP add-on. Internal to Tapioca and not intended for end-users",
-      default: false,
-      hide: true
     def dsl(*constant_or_paths)
       set_environment(options)
 
@@ -170,7 +165,7 @@ module Tapioca
         app_root: options[:app_root],
         halt_upon_load_error: options[:halt_upon_load_error],
         compiler_options: options[:compiler_options],
-        lsp_addon: options[:lsp_addon],
+        lsp_addon: self.class.addon_mode,
       }
 
       command = if options[:verify]
@@ -358,7 +353,7 @@ module Tapioca
       default: {}
     def annotations
       if !options[:netrc] && options[:netrc_file]
-        raise Thor::Error, set_color("Options `--no-netrc` and `--netrc-file` can't be used together", :bold, :red)
+        raise Tapioca::Error, set_color("Options `--no-netrc` and `--netrc-file` can't be used together", :bold, :red)
       end
 
       command = Commands::Annotations.new(
@@ -379,9 +374,22 @@ module Tapioca
     end
 
     no_commands do
+      @addon_mode = false
+
       class << self
+        extend T::Sig
+
+        # Indicates that we are running from the LSP, set using the `addon_mode!` method
+        attr_reader :addon_mode
+
+        #: -> void
+        def addon_mode!
+          @addon_mode = true
+        end
+
+        #: -> bool
         def exit_on_failure?
-          true
+          !@addon_mode
         end
       end
     end