rigortype 0.1.19 → 0.2.0

data/lib/rigor/cli/coverage_command.rb

@@ -1,14 +1,25 @@
 # frozen_string_literal: true
 
+require "English"
 require "optionparser"
 require "prism"
 
 require_relative "../configuration"
+require_relative "options"
 require_relative "../environment"
 require_relative "../inference/precision_scanner"
+require_relative "../inference/protection_scanner"
+require_relative "../inference/parameter_inference_collector"
+require_relative "../protection/mutation_scanner"
+require_relative "../language_server/project_context"
 require_relative "../scope"
 require_relative "coverage_report"
 require_relative "coverage_renderer"
+require_relative "coverage_scan"
+require_relative "protection_report"
+require_relative "protection_renderer"
+require_relative "mutation_protection_report"
+require_relative "mutation_protection_renderer"
 require_relative "command"
 
 module Rigor
@@ -32,10 +43,15 @@ module Rigor
       # @return [Integer] CLI exit status.
       def run
         options = parse_options
+        return mutation_misuse_error if options[:mutation] && !options[:protection]
+        return run_mutation_protection(options) if options[:mutation]
+
         paths = collect_paths(@argv, command_name: "coverage")
         return CLI::EXIT_USAGE if paths.nil?
         return usage_error if paths.empty?
 
+        return run_protection(paths, options) if options[:protection]
+
         report = scan_paths(paths, options)
         CoverageRenderer.new(out: @out).render(report, format: options.fetch(:format))
         determine_exit(report, options)
@@ -44,45 +60,112 @@ module Rigor
       private
 
       def parse_options
-        options = { format: "text", threshold: nil, config: nil }
+        options = { format: "text", threshold: nil, config: nil, protection: false, mutation: false }
 
         OptionParser.new do |opts|
           opts.banner = USAGE
           opts.on("--format=FORMAT", "Output format: text or json") { |v| options[:format] = v }
-          opts.on("--config=PATH", "Path to the Rigor configuration file") { |v| options[:config] = v }
+          Options.add_config(opts, options)
+          opts.on(
+            "--protection",
+            "Report type-protection coverage (ADR-63 Tier 1) instead of type precision"
+          ) { options[:protection] = true }
+          opts.on(
+            "--mutation",
+            "With --protection: measure actual mutation effectiveness (ADR-63 Tier 2). " \
+            "Scopes to git-changed files when no paths are given; explicit paths override."
+          ) { options[:mutation] = true }
           opts.on(
             "--threshold=RATIO", Float,
-            "Exit 1 when precision ratio is below RATIO (0.0–1.0)"
+            "Exit 1 when the precision (or, with --protection, protection/effectiveness) ratio is below RATIO (0.0–1.0)"
           ) { |v| options[:threshold] = v }
         end.parse!(@argv)
 
         options
       end
 
-      def usage_error
-        @err.puts("coverage: at least one path is required")
+      def mutation_misuse_error
+        @err.puts("coverage: --mutation requires --protection")
         @err.puts(USAGE)
         CLI::EXIT_USAGE
       end
 
-      def scan_paths(paths, options)
+      def run_protection(paths, options)
+        report = scan_protection(paths, options)
+        ProtectionRenderer.new(out: @out).render(report, format: options.fetch(:format))
+        determine_protection_exit(report, options)
+      end
+
+      def scan_protection(paths, options)
         configuration = Configuration.load(options.fetch(:config))
-        scope = Scope.empty(environment: project_environment(configuration))
-        scanner = Inference::PrecisionScanner.new(scope: scope)
-        accumulator = CoverageAccumulator.new
+        environment = project_environment(configuration)
+        scope = scope_with_inferred_params(paths, configuration, environment)
+        scanner = Inference::ProtectionScanner.new(scope: scope)
+        accumulator = ProtectionAccumulator.new
 
         paths.each { |path| scan_one(path, scanner, accumulator, configuration) }
-        accumulator.to_report(paths, options)
+        accumulator.to_report
       end
 
-      def project_environment(configuration)
-        Environment.for_project(
-          libraries: configuration.libraries,
-          signature_paths: configuration.signature_paths
+      # ADR-67 WD3 — seed the call-site parameter-inference table so the
+      # protection scan counts an inferred-parameter receiver (e.g. `node.loc`
+      # where `node` is a `def compile(node)` parameter) as protected when its
+      # call sites resolve to concrete argument types. ONLY the parameter table
+      # is seeded — no cross-file discovery — so every site that does not gain
+      # an inferred parameter type is classified byte-identically to the
+      # un-inferred baseline. Collection spans the scanned `paths`.
+      def scope_with_inferred_params(paths, configuration, environment)
+        base = Scope.empty(environment: environment)
+        table = Inference::ParameterInferenceCollector.collect(
+          files: paths, environment: environment, target_ruby: configuration.target_ruby
         )
+        return base if table.empty?
+
+        base.with_discovery(base.discovery.with(param_inferred_types: table))
       end
 
-      def scan_one(path, scanner, accumulator, configuration)
+      def determine_protection_exit(report, options)
+        return 1 unless report.parse_errors.empty?
+
+        threshold = options[:threshold]
+        return 0 if threshold.nil?
+
+        report.ratio < threshold ? 1 : 0
+      end
+
+      # ADR-63 Tier 2 — the mutation-effectiveness deep dive. Builds the RBS
+      # environment + project pre-pass once (the warm loop), then re-analyses
+      # each target file's mutants against its clean baseline. Defaults to the
+      # git-changed `.rb` files; explicit paths override (and enable the
+      # whole-project opt-in, which is minutes).
+      def run_mutation_protection(options)
+        explicit = collect_paths(@argv, command_name: "coverage")
+        return CLI::EXIT_USAGE if explicit.nil?
+
+        target_files = explicit.empty? ? changed_ruby_files : explicit
+        if target_files.empty?
+          @out.puts("No changed Ruby files to measure — pass paths to measure explicitly.")
+          return 0
+        end
+
+        report = scan_mutation_protection(target_files, options)
+        MutationProtectionRenderer.new(out: @out).render(report, format: options.fetch(:format))
+        determine_protection_exit(report, options)
+      end
+
+      def scan_mutation_protection(paths, options)
+        configuration = Configuration.load(options.fetch(:config))
+        context = LanguageServer::ProjectContext.new(configuration: configuration)
+        scanner = Protection::MutationScanner.new(
+          configuration: configuration, environment: context.environment, project_scan: context.project_scan
+        )
+        accumulator = MutationProtectionAccumulator.new
+
+        paths.each { |path| scan_mutation_one(path, scanner, accumulator, configuration) }
+        accumulator.to_report
+      end
+
+      def scan_mutation_one(path, scanner, accumulator, configuration)
         source = File.read(path)
         parse_result = Prism.parse(source, filepath: path, version: configuration.target_ruby)
         if parse_result.errors.any?
@@ -90,7 +173,56 @@ module Rigor
           return
         end
 
-        accumulator.absorb(path, scanner.scan(parse_result.value))
+        accumulator.absorb(scanner.scan_file(path, source: source))
+      end
+
+      # The git-changed (modified / added / untracked) `.rb` files that exist on
+      # disk — the default Tier 2 scope. Returns [] outside a git work tree or
+      # when git is unavailable; the caller then reports "nothing to measure".
+      def changed_ruby_files
+        output = git_status_porcelain
+        return [] if output.nil?
+
+        output.each_line.filter_map { |line| changed_path(line) }.uniq.select { |p| File.file?(p) }
+      end
+
+      # Parse one `git status --porcelain` line (`XY <path>`, or `R  old -> new`)
+      # into a candidate `.rb` path, or nil.
+      def changed_path(line)
+        path = line[3..]&.chomp
+        return nil if path.nil? || path.empty?
+
+        path = path.split(" -> ", 2).last if path.include?(" -> ")
+        path = path.delete_prefix('"').delete_suffix('"')
+        path.end_with?(".rb") ? path : nil
+      end
+
+      def git_status_porcelain
+        output = IO.popen(%w[git status --porcelain --untracked-files=all], err: File::NULL, &:read)
+        $CHILD_STATUS&.success? ? output : nil
+      rescue SystemCallError
+        nil
+      end
+
+      def usage_error
+        @err.puts("coverage: at least one path is required")
+        @err.puts(USAGE)
+        CLI::EXIT_USAGE
+      end
+
+      def scan_paths(paths, options)
+        CoverageScan.precision_report(files: paths, configuration: Configuration.load(options.fetch(:config)))
+      end
+
+      # Delegated to the shared scan module (see {CoverageScan}); the
+      # protection path below reuses both, and `rigor check --coverage`
+      # reuses `precision_report` over the same machinery.
+      def project_environment(configuration)
+        CoverageScan.project_environment(configuration)
+      end
+
+      def scan_one(path, scanner, accumulator, configuration)
+        CoverageScan.scan_into(path, scanner, accumulator, configuration)
       end
 
       def determine_exit(report, options)

data/lib/rigor/cli/coverage_scan.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "../configuration"
+require_relative "../environment"
+require_relative "../inference/precision_scanner"
+require_relative "../scope"
+require_relative "coverage_report"
+
+module Rigor
+  class CLI
+    # Shared type-precision scan behind both `rigor coverage` (the
+    # dedicated command) and `rigor check --coverage` (the in-run
+    # coverage block). Walks each file's AST, types every expression via
+    # `Scope#type_of`, and accumulates the precision-tier breakdown into a
+    # `CoverageReport`. Extracted so the two surfaces stay byte-identical
+    # on the same file set.
+    module CoverageScan
+      module_function
+
+      # @param files [Array<String>] explicit `.rb` file paths to scan.
+      # @param configuration [Rigor::Configuration]
+      # @return [Rigor::CLI::CoverageReport]
+      def precision_report(files:, configuration:)
+        scope = Scope.empty(environment: project_environment(configuration))
+        scanner = Inference::PrecisionScanner.new(scope: scope)
+        accumulator = CoverageAccumulator.new
+        files.each { |path| scan_into(path, scanner, accumulator, configuration) }
+        accumulator.to_report(files, {})
+      end
+
+      def project_environment(configuration)
+        Environment.for_project(
+          libraries: configuration.libraries,
+          signature_paths: configuration.signature_paths
+        )
+      end
+
+      # Parses one file and feeds the scan result (or a parse-error
+      # record) into `accumulator`. `scanner` / `accumulator` are a
+      # matched pair — a `PrecisionScanner` + `CoverageAccumulator`, or a
+      # `ProtectionScanner` + `ProtectionAccumulator` — both of which
+      # respond to `scan(node)` and `absorb(path, result)`.
+      def scan_into(path, scanner, accumulator, configuration)
+        source = File.read(path)
+        parse_result = Prism.parse(source, filepath: path, version: configuration.target_ruby)
+        if parse_result.errors.any?
+          accumulator.record_parse_error(path, parse_result.errors)
+          return
+        end
+
+        accumulator.absorb(path, scanner.scan(parse_result.value))
+      end
+    end
+  end
+end

data/lib/rigor/cli/explain_command.rb

@@ -95,6 +95,7 @@ module Rigor
         render_section("Fires when:", entry.fires_when)
         render_section("Does not fire when:", entry.does_not_fire_when)
         @out.puts("Suppression: #{entry.suppression}")
+        @out.puts("Documentation: #{entry.documentation_url}")
         @out.puts("Since: rigor #{entry.since}")
       end
 
@@ -109,6 +110,7 @@ module Rigor
         @out.puts("Authored severity: :#{entry.severity_authored}")
         profile_table = entry.severity_by_profile.map { |profile, sev| "#{profile} → :#{sev}" }.join(", ")
         @out.puts("Severity by profile: #{profile_table}")
+        @out.puts("Evidence tier: #{entry.evidence_tier || 'n/a (informational)'}")
         @out.puts("")
       end
 

data/lib/rigor/cli/lsp_command.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "command"
+require_relative "options"
 
 require "optionparser"
 
@@ -8,11 +9,8 @@ module Rigor
   class CLI
     # Executes the `rigor lsp` command.
     #
+    # Starts a long-running LSP server over stdio (JSON-RPC).
     # See `docs/design/20260517-language-server.md` for the design.
-    # Slice 1 (this commit) ships the CLI subcommand entry point.
-    # The actual stdio JSON-RPC reader / writer is queued for slice 2;
-    # invoking `rigor lsp` at slice 1 returns immediately after
-    # validating the transport flag.
     class LspCommand < Command
       USAGE = "Usage: rigor lsp [options]"
 
@@ -109,9 +107,7 @@ module Rigor
           opts.on("--log=PATH", "Write LSP wire log + server debug to PATH (default: stderr)") do |value|
             options[:log] = value
           end
-          opts.on("--config=PATH", "Path to the Rigor configuration file") do |value|
-            options[:config] = value
-          end
+          Options.add_config(opts, options)
         end
         parser.parse!(@argv)
         options

data/lib/rigor/cli/mutation_protection_renderer.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Rigor
+  class CLI
+    # Renders a {MutationProtectionReport} (ADR-63 Tier 2) as text or JSON. The
+    # text form leads with the effectiveness ratio (caught breakages), then the
+    # breakages Rigor missed ("add a type here"), then the least-effective files.
+    # The framing is always *where to add a type*, never "your code is broken".
+    class MutationProtectionRenderer
+      TOP_CALLS = 15
+      TOP_FILES = 10
+
+      def initialize(out:)
+        @out = out
+      end
+
+      def render(report, format:)
+        format == "json" ? render_json(report) : render_text(report)
+      end
+
+      private
+
+      def render_json(report)
+        @out.puts(JSON.pretty_generate(report.to_h))
+      end
+
+      def render_text(report)
+        pct = (report.ratio * 100).round(1)
+        @out.puts "Type-protection effectiveness (Tier 2 — mutation kill rate)"
+        @out.puts "  caught breakages: #{report.total_killed} / #{report.grand_total}  (#{pct}%)"
+        @out.puts "  (effectiveness = when a type-visible bug was introduced, Rigor caught it)"
+        render_missed(report)
+        render_files(report)
+      end
+
+      def render_missed(report)
+        missed = report.missed
+        return if missed.empty?
+
+        @out.puts "\nAdd a type here — breakages Rigor missed (a wrong call that stayed silent):"
+        missed.first(TOP_CALLS).each do |call|
+          @out.puts format("  %<count>-5d #%<method>s   e.g. %<sites>s",
+                           count: call.count, method: call.method_name, sites: call.examples.join("  "))
+        end
+        @out.puts "  (#{missed.size - TOP_CALLS} more)" if missed.size > TOP_CALLS
+      end
+
+      def render_files(report)
+        worst = report.files.reject { |f| f.survived.zero? }.sort_by(&:ratio).first(TOP_FILES)
+        return if worst.empty?
+
+        @out.puts "\nLeast-effective files:"
+        worst.each do |file|
+          total = file.killed + file.survived
+          @out.puts format("  %<pct>5.1f%%  %<path>s  (%<n>d/%<total>d breakages caught)",
+                           pct: file.ratio * 100, path: file.path, n: file.killed, total: total)
+        end
+      end
+    end
+  end
+end

data/lib/rigor/cli/mutation_protection_report.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Rigor
+  class CLI
+    # ADR-63 Tier 2 — aggregates per-file {Protection::MutationScanner}
+    # results into a project-level *effectiveness* report: the kill ratio (when
+    # a type-visible bug was introduced, how often Rigor caught it), the per-file
+    # breakdown, and a ranked "add a type here" list keyed by the method whose
+    # breakage Rigor most often *missed* — the sites where a receiver annotation
+    # would buy real catching power.
+    #
+    # The framing is load-bearing (ADR-63 Criterion A / ADR-62 Criterion A): the
+    # number is *effectiveness*, the survivors are *missed breakages / where to
+    # add a type*, never "your code is broken".
+    FileEffectiveness = Data.define(:path, :killed, :survived, :ratio)
+    MissedBreakage = Data.define(:method_name, :count, :examples)
+
+    MutationProtectionReport = Data.define(:files, :missed, :parse_errors) do
+      def total_killed = files.sum(&:killed)
+      def total_survived = files.sum(&:survived)
+      def grand_total = total_killed + total_survived
+      def ratio = grand_total.zero? ? 1.0 : total_killed.to_f / grand_total
+
+      def to_h
+        {
+          "mode" => "mutation",
+          "killed" => total_killed,
+          "survived" => total_survived,
+          "effectiveness_ratio" => ratio.round(4),
+          "files" => files.map do |f|
+            { "path" => f.path, "killed" => f.killed,
+              "survived" => f.survived, "ratio" => f.ratio.round(4) }
+          end,
+          "add_a_type_here" => missed.map do |m|
+            { "method" => m.method_name, "count" => m.count, "examples" => m.examples }
+          end,
+          "parse_errors" => parse_errors
+        }
+      end
+    end
+
+    class MutationProtectionAccumulator
+      def initialize
+        @files = []
+        @missed = Hash.new { |h, k| h[k] = { count: 0, examples: [] } }
+        @parse_errors = []
+      end
+
+      def absorb(file_result)
+        @files << FileEffectiveness.new(
+          path: file_result.path, killed: file_result.killed,
+          survived: file_result.survived, ratio: file_result.ratio
+        )
+        file_result.sites.each do |site|
+          bucket = @missed[site.method_name]
+          bucket[:count] += 1
+          bucket[:examples] << "#{file_result.path}:#{site.line}" if bucket[:examples].size < 3
+        end
+      end
+
+      def record_parse_error(path, errors)
+        @parse_errors << { "path" => path, "errors" => errors.size }
+      end
+
+      def to_report
+        missed = @missed
+                 .map { |method, v| MissedBreakage.new(method_name: method, count: v[:count], examples: v[:examples]) }
+                 .sort_by { |m| [-m.count, m.method_name] }
+        MutationProtectionReport.new(files: @files, missed: missed, parse_errors: @parse_errors)
+      end
+    end
+  end
+end

data/lib/rigor/cli/options.rb

@@ -17,6 +17,15 @@ module Rigor
     module Options
       module_function
 
+      # Defines the standard `--config=PATH` flag on `parser`, writing the
+      # path into `options[:config]`. Used by every subcommand that loads a
+      # `.rigor.yml`; the few whose `--config` help text is intentionally
+      # bespoke (`diff`, `mcp`, `show-bleedingedge`) keep their own
+      # `parser.on` rather than this shared wording.
+      def add_config(parser, options)
+        parser.on("--config=PATH", "Path to the Rigor configuration file") { |value| options[:config] = value }
+      end
+
       # Defines the `--tmp-file` / `--instead-of` editor-mode flag pair
       # on `parser`, writing into `options`.
       def add_editor_mode(parser, options)

data/lib/rigor/cli/plugins_command.rb

@@ -3,6 +3,7 @@
 require "optparse"
 
 require_relative "../configuration"
+require_relative "options"
 require_relative "../plugin"
 require_relative "../plugin/loader"
 require_relative "../plugin/services"
@@ -102,7 +103,7 @@ module Rigor
         options = { config: nil, format: "text", strict: false, capabilities: false }
         OptionParser.new do |opts|
           opts.banner = USAGE
-          opts.on("--config=PATH", "Path to the Rigor configuration file") { |v| options[:config] = v }
+          Options.add_config(opts, options)
           opts.on("--format=FORMAT", "Output format: text (default) or json") { |v| options[:format] = v }
           opts.on("--strict", "Exit 1 if any plugin failed to load (CI gate)") { options[:strict] = true }
           opts.on("--capabilities", "Emit the per-plugin extension-protocol catalogue (ADR-37)") do

data/lib/rigor/cli/protection_renderer.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Rigor
+  class CLI
+    # Renders an {ProtectionReport} (ADR-63 Tier 1) as text or JSON. The text
+    # form leads with the protected ratio, then the highest-traffic untyped
+    # dispatches ("add a type here"), then the lowest-protected files. The
+    # framing is always *where to add a type*, never "your code is broken".
+    class ProtectionRenderer
+      TOP_CALLS = 15
+      TOP_FILES = 10
+
+      def initialize(out:)
+        @out = out
+      end
+
+      def render(report, format:)
+        format == "json" ? render_json(report) : render_text(report)
+      end
+
+      private
+
+      def render_json(report)
+        @out.puts(JSON.pretty_generate(report.to_h))
+      end
+
+      def render_text(report)
+        pct = (report.ratio * 100).round(1)
+        @out.puts "Type-protection coverage (Tier 1 — dispatch-site receiver concreteness)"
+        @out.puts "  protected dispatch sites: #{report.total_protected} / #{report.grand_total}  (#{pct}%)"
+        @out.puts "  (protected = Rigor can catch a wrong call here; an upper bound on real protection)"
+        render_untyped_calls(report)
+        render_files(report)
+      end
+
+      def render_untyped_calls(report)
+        calls = report.untyped_calls
+        return if calls.empty?
+
+        @out.puts "\nAdd a type here — methods most often called on an untyped receiver:"
+        calls.first(TOP_CALLS).each do |call|
+          @out.puts format("  %<count>-5d #%<method>s   e.g. %<sites>s",
+                           count: call.count, method: call.method_name, sites: call.examples.join("  "))
+        end
+        @out.puts "  (#{calls.size - TOP_CALLS} more)" if calls.size > TOP_CALLS
+      end
+
+      def render_files(report)
+        worst = report.files.reject { |f| f.unprotected_count.zero? }.sort_by(&:ratio).first(TOP_FILES)
+        return if worst.empty?
+
+        @out.puts "\nLeast-protected files:"
+        worst.each do |file|
+          total = file.protected_count + file.unprotected_count
+          @out.puts format("  %<pct>5.1f%%  %<path>s  (%<n>d/%<total>d protected)",
+                           pct: file.ratio * 100, path: file.path, n: file.protected_count, total: total)
+        end
+      end
+    end
+  end
+end

data/lib/rigor/cli/protection_report.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Rigor
+  class CLI
+    # ADR-63 Tier 1 — aggregates per-file {Inference::ProtectionScanner}
+    # results into a project-level protection report: the protected ratio, the
+    # per-file breakdown, and a ranked "add a type here" list keyed by the
+    # method called on an unprotected (`Dynamic`) receiver — the highest-traffic
+    # untyped dispatches, where a receiver annotation buys the most catching
+    # power.
+    FileProtection = Data.define(:path, :protected_count, :unprotected_count, :ratio)
+    UntypedCall = Data.define(:method_name, :count, :examples)
+
+    ProtectionReport = Data.define(:files, :untyped_calls, :parse_errors) do
+      def total_protected = files.sum(&:protected_count)
+      def total_unprotected = files.sum(&:unprotected_count)
+      def grand_total = total_protected + total_unprotected
+      def ratio = grand_total.zero? ? 1.0 : total_protected.to_f / grand_total
+
+      def to_h
+        {
+          "protected" => total_protected,
+          "unprotected" => total_unprotected,
+          "protection_ratio" => ratio.round(4),
+          "files" => files.map do |f|
+            { "path" => f.path, "protected" => f.protected_count,
+              "unprotected" => f.unprotected_count, "ratio" => f.ratio.round(4) }
+          end,
+          "add_a_type_here" => untyped_calls.map do |c|
+            { "method" => c.method_name, "count" => c.count, "examples" => c.examples }
+          end,
+          "parse_errors" => parse_errors
+        }
+      end
+    end
+
+    class ProtectionAccumulator
+      def initialize
+        @files = []
+        @calls = Hash.new { |h, k| h[k] = { count: 0, examples: [] } }
+        @parse_errors = []
+      end
+
+      def absorb(path, file_result)
+        @files << FileProtection.new(
+          path: path, protected_count: file_result.protected_count,
+          unprotected_count: file_result.unprotected_count, ratio: file_result.ratio
+        )
+        file_result.sites.each do |site|
+          bucket = @calls[site.method_name]
+          bucket[:count] += 1
+          bucket[:examples] << "#{path}:#{site.line}" if bucket[:examples].size < 3
+        end
+      end
+
+      def record_parse_error(path, errors)
+        @parse_errors << { "path" => path, "errors" => errors.size }
+      end
+
+      def to_report
+        untyped = @calls
+                  .map { |method, v| UntypedCall.new(method_name: method, count: v[:count], examples: v[:examples]) }
+                  .sort_by { |c| [-c.count, c.method_name] }
+        ProtectionReport.new(files: @files, untyped_calls: untyped, parse_errors: @parse_errors)
+      end
+    end
+  end
+end

data/lib/rigor/cli/sig_gen_command.rb

@@ -3,6 +3,7 @@
 require "optionparser"
 
 require_relative "../configuration"
+require_relative "options"
 require_relative "../sig_gen"
 require_relative "command"
 
@@ -145,7 +146,7 @@ module Rigor
           opts.on("--tighter-returns", "Emit only tighter-return classifications") do
             options[:selection] << SigGen::Classification::TIGHTER_RETURN
           end
-          opts.on("--config=PATH", "Path to the Rigor configuration file") { |value| options[:config] = value }
+          Options.add_config(opts, options)
         end
       end
 

data/lib/rigor/cli/trace_command.rb

@@ -5,6 +5,7 @@ require "optionparser"
 require "prism"
 
 require_relative "../configuration"
+require_relative "options"
 require_relative "../environment"
 require_relative "../scope"
 require_relative "../inference/flow_tracer"
@@ -63,7 +64,7 @@ module Rigor
             options[:line] = value
           end
           opts.on("--verbose", "Include every expression enter/result frame") { options[:verbose] = true }
-          opts.on("--config=PATH", "Path to the Rigor configuration file") { |value| options[:config] = value }
+          Options.add_config(opts, options)
         end
         parser.parse!(@argv)
         options