rigortype 0.1.6 → 0.1.8

data/lib/rigor/cli/baseline_command.rb

@@ -0,0 +1,377 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+require_relative "../analysis/baseline"
+require_relative "../analysis/runner"
+require_relative "../cache/store"
+require_relative "../configuration"
+
+module Rigor
+  class CLI
+    # ADR-22 Slice 1 — `rigor baseline {generate}` subcommands.
+    # Backed by `Rigor::Analysis::Baseline`. Future slices
+    # extend the subcommand surface with `dump`, `drift`,
+    # `prune`, `regenerate`.
+    #
+    # Initial subcommand: `generate`.
+    #
+    #   rigor baseline generate              # default: rule-ID rows
+    #   rigor baseline generate --match-mode message
+    #   rigor baseline generate --force      # overwrite existing
+    #   rigor baseline generate --output=PATH
+    class BaselineCommand # rubocop:disable Metrics/ClassLength
+      EXIT_USAGE = 64
+      DEFAULT_BASELINE_PATH = ".rigor-baseline.yml"
+
+      SUBCOMMANDS = %w[generate dump drift prune].freeze
+
+      def initialize(argv:, out: $stdout, err: $stderr)
+        @argv = argv
+        @out = out
+        @err = err
+      end
+
+      def run
+        subcommand = @argv.shift
+        case subcommand
+        when nil, "help", "-h", "--help"
+          @out.puts(help)
+          0
+        when "generate" then run_generate
+        when "dump" then run_dump
+        when "drift" then run_drift
+        when "prune" then run_prune
+        else
+          @err.puts("Unknown baseline subcommand: #{subcommand.inspect}")
+          @err.puts(help)
+          EXIT_USAGE
+        end
+      rescue OptionParser::ParseError => e
+        @err.puts(e.message)
+        EXIT_USAGE
+      end
+
+      private
+
+      def run_generate
+        options = parse_generate_options
+        path = options.fetch(:output)
+
+        if File.exist?(path) && !options.fetch(:force)
+          @err.puts("rigor: #{path} already exists. Re-run with --force to overwrite.")
+          return EXIT_USAGE
+        end
+
+        configuration = Configuration.load(options.fetch(:config))
+        diagnostics = collect_diagnostics(configuration, options)
+
+        baseline = Analysis::Baseline.from_diagnostics(diagnostics, match_mode: options.fetch(:match_mode))
+        File.write(path, baseline.to_yaml)
+
+        bucket_count = baseline.size
+        diagnostic_count = diagnostics.size
+        @err.puts(
+          "rigor: wrote baseline to #{path} " \
+          "(#{bucket_count} bucket(s) covering #{diagnostic_count} diagnostic(s); " \
+          "match-mode: #{options.fetch(:match_mode)})"
+        )
+        if configuration.baseline_path.nil?
+          @err.puts(
+            "rigor: note — `.rigor.yml` does not declare `baseline:`; " \
+            "add `baseline: #{path}` to activate the suppression."
+          )
+        end
+        0
+      end
+
+      def parse_generate_options
+        options = {
+          config: nil,
+          output: DEFAULT_BASELINE_PATH,
+          match_mode: :rule,
+          force: false
+        }
+        parser = OptionParser.new do |opts|
+          opts.banner = "Usage: rigor baseline generate [options]"
+          opts.on("--config=PATH", "Path to the Rigor configuration file") { |v| options[:config] = v }
+          opts.on("--output=PATH", "Write baseline to PATH (default: #{DEFAULT_BASELINE_PATH})") do |v|
+            options[:output] = v
+          end
+          opts.on("--match-mode=MODE", %i[rule message],
+                  "Row form: rule (default) or message") do |v|
+            options[:match_mode] = v
+          end
+          opts.on("--force", "Overwrite an existing baseline file") { options[:force] = true }
+        end
+        parser.parse!(@argv)
+        options
+      end
+
+      def collect_diagnostics(configuration, _options)
+        cache_store = Cache::Store.new(root: configuration.cache_path)
+        # IMPORTANT: do NOT activate the existing baseline when
+        # generating a fresh one — otherwise the new file
+        # records the post-filter (silenced) diagnostic set,
+        # which is empty after a successful first run.
+        configuration_for_generation = override_configuration_baseline_off(configuration)
+        runner = Analysis::Runner.new(
+          configuration: configuration_for_generation,
+          cache_store: cache_store,
+          collect_stats: false
+        )
+        runner.run(configuration_for_generation.paths).diagnostics
+      end
+
+      def override_configuration_baseline_off(configuration)
+        # Synthesise a new Configuration with `baseline` explicitly
+        # disabled. The original Configuration is frozen-ish so we
+        # round-trip through the constructor with an override hash.
+        defaults = Configuration::DEFAULTS.merge(
+          "paths" => configuration.paths,
+          "exclude" => configuration.exclude_patterns,
+          "plugins" => configuration.plugins.map(&:to_h),
+          "disable" => configuration.disabled_rules,
+          "libraries" => configuration.libraries,
+          "signature_paths" => configuration.signature_paths,
+          "pre_eval" => configuration.pre_eval,
+          "severity_profile" => configuration.severity_profile.to_s,
+          "severity_overrides" => configuration.severity_overrides,
+          "baseline" => false,
+          "cache" => { "path" => configuration.cache_path }
+        )
+        Configuration.new(defaults)
+      end
+
+      # ---- dump --------------------------------------------------
+
+      def run_dump
+        options = parse_dump_options
+        baseline = load_baseline_or_exit(options.fetch(:baseline))
+        return EXIT_USAGE if baseline == :error
+
+        rows = filter_dump_rows(baseline.buckets, options)
+        case options.fetch(:format)
+        when :json then @out.puts(JSON.pretty_generate(dump_to_json(rows)))
+        else dump_text(rows, options)
+        end
+        0
+      end
+
+      def parse_dump_options
+        options = { baseline: DEFAULT_BASELINE_PATH, format: :text, rule: nil, file: nil }
+        parser = OptionParser.new do |opts|
+          opts.banner = "Usage: rigor baseline dump [options]"
+          opts.on("--baseline=PATH", "Path to the baseline file (default: #{DEFAULT_BASELINE_PATH})") do |v|
+            options[:baseline] = v
+          end
+          opts.on("--format=FORMAT", %i[text json], "Output format: text (default) or json") do |v|
+            options[:format] = v
+          end
+          opts.on("--rule=RULE", "Filter rows by exact rule id") { |v| options[:rule] = v }
+          opts.on("--file=GLOB", "Filter rows by File.fnmatch? glob") { |v| options[:file] = v }
+        end
+        parser.parse!(@argv)
+        options
+      end
+
+      def filter_dump_rows(buckets, options)
+        buckets.select do |b|
+          next false if options[:rule] && b.rule != options[:rule]
+          next false if options[:file] && !File.fnmatch?(options[:file], b.file)
+
+          true
+        end
+      end
+
+      def dump_text(rows, options)
+        if rows.empty?
+          @out.puts("(no baseline rows matching the supplied filters)")
+          return
+        end
+
+        # Group by rule for readability; rules with the most
+        # entries first.
+        by_rule = rows.group_by(&:rule).sort_by { |_rule, group| -group.size }
+        by_rule.each do |rule, group|
+          total = group.sum(&:count)
+          @out.puts("#{rule}  (#{group.size} bucket(s), #{total} occurrence(s))")
+          group.sort_by { |b| [-b.count, b.file] }.each do |bucket|
+            label = if bucket.message_regex
+                      "  #{bucket.file}: #{bucket.count}  ~/#{bucket.message_regex.source}/"
+                    else
+                      "  #{bucket.file}: #{bucket.count}"
+                    end
+            @out.puts(label)
+          end
+          @out.puts("")
+        end
+        @out.puts("Total: #{rows.size} bucket(s), #{rows.sum(&:count)} occurrence(s)")
+        _ = options # reserved for future flags
+      end
+
+      def dump_to_json(rows)
+        {
+          "version" => Analysis::Baseline::CURRENT_VERSION,
+          "ignored" => rows.map do |b|
+            row = { "file" => b.file, "rule" => b.rule, "count" => b.count }
+            row["message"] = b.message_regex.source if b.message_regex
+            row
+          end
+        }
+      end
+
+      # ---- drift --------------------------------------------------
+
+      def run_drift
+        options = parse_drift_options
+        baseline = load_baseline_or_exit(options.fetch(:baseline))
+        return EXIT_USAGE if baseline == :error
+
+        configuration = Configuration.load(options.fetch(:config))
+        diagnostics = collect_diagnostics(configuration, options)
+        drift_rows = baseline.audit(diagnostics)
+
+        shown = if options.fetch(:only).nil?
+                  drift_rows.reject { |r| r.delta.zero? }
+                else
+                  drift_rows.select { |r| r.status == options.fetch(:only) }
+                end
+
+        if shown.empty?
+          @out.puts("No drift detected.")
+          return 0
+        end
+
+        report_drift_rows(shown, baseline_path: options.fetch(:baseline))
+        0
+      end
+
+      def parse_drift_options
+        options = {
+          config: nil,
+          baseline: DEFAULT_BASELINE_PATH,
+          only: nil
+        }
+        parser = OptionParser.new do |opts|
+          opts.banner = "Usage: rigor baseline drift [options]"
+          opts.on("--config=PATH", "Path to the Rigor configuration file") { |v| options[:config] = v }
+          opts.on("--baseline=PATH", "Path to the baseline file (default: #{DEFAULT_BASELINE_PATH})") do |v|
+            options[:baseline] = v
+          end
+          opts.on("--only=STATUS", %i[within over cleared reducible],
+                  "Show only buckets with the given status (within|over|cleared|reducible)") do |v|
+            options[:only] = v
+          end
+        end
+        parser.parse!(@argv)
+        options
+      end
+
+      def report_drift_rows(rows, baseline_path:) # rubocop:disable Metrics/AbcSize
+        @out.puts("Drift report against #{baseline_path}:")
+        @out.puts("")
+        groups = rows.group_by(&:status)
+        %i[over cleared reducible within].each do |status|
+          group = groups[status] || []
+          next if group.empty?
+
+          @out.puts(drift_section_header(status, group.size))
+          group.sort_by { |r| [r.bucket.file, r.bucket.rule] }.each do |row|
+            delta_str = row.delta.positive? ? "+#{row.delta}" : row.delta.to_s
+            @out.puts("  #{row.bucket.file}  [#{row.bucket.rule}]  " \
+                      "#{row.bucket.count} → #{row.actual_count}  (Δ#{delta_str})")
+          end
+          @out.puts("")
+        end
+      end
+
+      def drift_section_header(status, count)
+        case status
+        when :over then "## Over threshold (#{count}) — bucket exceeded; check the regular diagnostic output."
+        when :cleared then "## Cleared (#{count}) — `rigor baseline prune` can drop these."
+        when :reducible then "## Reducible (#{count}) — tightening opportunity; consider `regenerate` (slice 5)."
+        when :within then "## Within threshold (#{count})"
+        end
+      end
+
+      # ---- prune --------------------------------------------------
+
+      def run_prune
+        options = parse_prune_options
+        baseline = load_baseline_or_exit(options.fetch(:baseline))
+        return EXIT_USAGE if baseline == :error
+
+        configuration = Configuration.load(options.fetch(:config))
+        diagnostics = collect_diagnostics(configuration, options)
+        drift_rows = baseline.audit(diagnostics)
+        cleared = drift_rows.select { |r| r.status == :cleared }
+
+        if cleared.empty?
+          @out.puts("No cleared buckets to prune.")
+          return 0
+        end
+
+        announce_prune(cleared, options.fetch(:baseline))
+        return 0 if options.fetch(:dry_run)
+
+        pruned = baseline.without(cleared.map(&:bucket))
+        File.write(options.fetch(:baseline), pruned.to_yaml)
+        @err.puts("rigor: pruned #{cleared.size} bucket(s); baseline now has #{pruned.size} entries.")
+        0
+      end
+
+      def parse_prune_options
+        options = {
+          config: nil,
+          baseline: DEFAULT_BASELINE_PATH,
+          dry_run: false
+        }
+        parser = OptionParser.new do |opts|
+          opts.banner = "Usage: rigor baseline prune [options]"
+          opts.on("--config=PATH", "Path to the Rigor configuration file") { |v| options[:config] = v }
+          opts.on("--baseline=PATH", "Path to the baseline file (default: #{DEFAULT_BASELINE_PATH})") do |v|
+            options[:baseline] = v
+          end
+          opts.on("--dry-run", "Show what would be dropped without writing the file") { options[:dry_run] = true }
+        end
+        parser.parse!(@argv)
+        options
+      end
+
+      def announce_prune(cleared, baseline_path)
+        @out.puts("#{cleared.size} bucket(s) to prune from #{baseline_path}:")
+        cleared.sort_by { |r| [r.bucket.file, r.bucket.rule] }.each do |row|
+          @out.puts("  - #{row.bucket.file}  [#{row.bucket.rule}]  (was: #{row.bucket.count})")
+        end
+      end
+
+      # ---- shared helpers ----------------------------------------
+
+      def load_baseline_or_exit(path)
+        unless File.exist?(path)
+          @err.puts("rigor: baseline file not found: #{path}")
+          return :error
+        end
+        Analysis::Baseline.load(path)
+      rescue Analysis::Baseline::LoadError => e
+        @err.puts("rigor: baseline load failed: #{e.message}")
+        :error
+      end
+
+      def help
+        <<~HELP
+          Usage: rigor baseline <subcommand> [options]
+
+          Subcommands:
+            generate    Write a fresh baseline file from a `rigor check` run.
+            dump        Print the contents of an existing baseline.
+            drift       Compare baseline vs current diagnostics (reduction / regression hints).
+            prune       Drop cleared buckets (`actual == 0`) from the baseline.
+
+          Run `rigor baseline <subcommand> --help` for subcommand options.
+        HELP
+      end
+    end
+  end
+end

data/lib/rigor/cli/triage_command.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "optionparser"
+
+require_relative "../configuration"
+require_relative "../analysis/runner"
+require_relative "../cache/store"
+require_relative "../triage"
+require_relative "triage_renderer"
+
+module Rigor
+  class CLI
+    # ADR-23 — executes `rigor triage`.
+    #
+    # Runs the same analysis as `rigor check`, then summarises the
+    # diagnostic stream (rule distribution, per-file hotspots,
+    # heuristic hints) instead of printing the raw per-line list.
+    # Read-only and advisory (WD4): never edits config, never
+    # writes a baseline. Always exits 0 — it is an inspection
+    # command, not a gate (`rigor check` remains the gate).
+    class TriageCommand
+      USAGE = "Usage: rigor triage [options] [paths]"
+      DEFAULT_SECTIONS = %i[distribution hotspots hints].freeze
+
+      def initialize(argv:, out:, err:)
+        @argv = argv
+        @out = out
+        @err = err
+      end
+
+      # @return [Integer] CLI exit status (always 0).
+      def run
+        options = parse_options
+        configuration = Configuration.load(options.fetch(:config))
+        diagnostics = analyze(configuration)
+
+        report = Triage.analyze(diagnostics, top: options.fetch(:top),
+                                             hints: options.fetch(:sections).include?(:hints))
+        renderer = TriageRenderer.new(report, sections: options.fetch(:sections))
+        @out.puts(options.fetch(:format) == "json" ? renderer.json : renderer.text)
+        0
+      end
+
+      private
+
+      def parse_options
+        options = { config: nil, format: "text", top: 10, sections: DEFAULT_SECTIONS }
+        OptionParser.new do |opts|
+          opts.banner = USAGE
+          opts.on("--config=PATH", "Path to the Rigor configuration file") { |v| options[:config] = v }
+          opts.on("--format=FORMAT", "Output format: text (default) or json") { |v| options[:format] = v }
+          opts.on("--top=N", Integer, "Hotspot-file count (default 10)") { |v| options[:top] = v }
+          opts.on("--hints-only", "Print only the heuristic-hints section") { options[:sections] = %i[hints] }
+          opts.on("--no-hints", "Print distribution + hotspots only") do
+            options[:sections] = %i[distribution hotspots]
+          end
+        end.parse!(@argv)
+        validate!(options)
+        options
+      end
+
+      def validate!(options)
+        return if %w[text json].include?(options.fetch(:format))
+
+        raise OptionParser::InvalidArgument, "unsupported format: #{options.fetch(:format)}"
+      end
+
+      # Sequential, cache-backed, no run-stats: triage only needs
+      # the diagnostic stream, and sequential keeps the rule
+      # distribution deterministic (the fork pool's cross-file
+      # divergence would skew the histogram).
+      def analyze(configuration)
+        runner = Analysis::Runner.new(
+          configuration: configuration,
+          cache_store: Cache::Store.new(root: configuration.cache_path),
+          collect_stats: false,
+          workers: 0
+        )
+        runner.run(@argv.empty? ? configuration.paths : @argv).diagnostics
+      end
+    end
+  end
+end

data/lib/rigor/cli/triage_renderer.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "json"
+
+require_relative "../triage"
+
+module Rigor
+  class CLI
+    # ADR-23 — renders a {Rigor::Triage::Report} as the `rigor
+    # triage` text report or as `--format json`.
+    class TriageRenderer
+      BAR_WIDTH = 24
+
+      def initialize(report, sections:)
+        @report = report
+        @sections = sections # subset of %i[distribution hotspots hints]
+      end
+
+      def json
+        JSON.pretty_generate(Triage.report_to_h(@report))
+      end
+
+      def text
+        blocks = []
+        blocks << distribution_block if @sections.include?(:distribution)
+        blocks << hotspots_block     if @sections.include?(:hotspots)
+        blocks << hints_block        if @sections.include?(:hints)
+        "#{blocks.join("\n\n")}\n"
+      end
+
+      private
+
+      def distribution_block
+        s = @report.summary
+        max = @report.distribution.map(&:count).max || 1
+        lines = ["Diagnostic distribution — #{s.total} total " \
+                 "(#{s.error} error / #{s.warning} warning#{" / #{s.info} info" if s.info.positive?})"]
+        @report.distribution.each do |row|
+          lines << format("  %<rule>-32s %<count>5d  %<bar>s",
+                          rule: row.rule, count: row.count, bar: bar(row.count, max))
+        end
+        lines.join("\n")
+      end
+
+      def hotspots_block
+        return "Hotspot files\n  (none)" if @report.hotspots.empty?
+
+        lines = ["Hotspot files"]
+        @report.hotspots.each do |spot|
+          by_rule = spot.by_rule.map { |rule, count| "#{rule}×#{count}" }.join("  ")
+          lines << format("  %<file>-40s %<count>4d  %<rules>s",
+                          file: spot.file, count: spot.count, rules: by_rule)
+        end
+        lines.join("\n")
+      end
+
+      def hints_block
+        return "Hints\n  (no heuristic hints)" if @report.hints.empty?
+
+        lines = ["Hints — heuristics, verify before acting"]
+        @report.hints.each do |hint|
+          lines << ""
+          lines << "  [#{hint.confidence} #{hint.id}]  #{hint.diagnostic_count} diagnostic(s)"
+          lines << "    #{hint.summary}"
+          lines << "    → #{hint.action}"
+        end
+        lines.join("\n")
+      end
+
+      def bar(count, max)
+        filled = max.zero? ? 0 : (count * BAR_WIDTH / max)
+        filled = 1 if filled.zero? && count.positive?
+        "█" * filled
+      end
+    end
+  end
+end

data/lib/rigor/cli.rb

@@ -26,7 +26,9 @@ module Rigor
       "explain" => :run_explain,
       "diff" => :run_diff,
       "sig-gen" => :run_sig_gen,
-      "lsp" => :run_lsp
+      "lsp" => :run_lsp,
+      "baseline" => :run_baseline,
+      "triage" => :run_triage
     }.freeze
 
     def self.start(argv = ARGV, out: $stdout, err: $stderr)
@@ -71,6 +73,7 @@ module Rigor
     def run_check
       require_relative "analysis/runner"
       require_relative "analysis/buffer_binding"
+      require_relative "analysis/baseline"
       require_relative "cache/store"
 
       options = parse_check_options
@@ -86,6 +89,7 @@ module Rigor
         buffer: buffer, cache_root: cache_root
       )
       result = runner.run(@argv.empty? ? configuration.paths : @argv)
+      result = apply_baseline_filter(result, configuration, options)
 
       write_result(result, options.fetch(:format))
       write_run_stats(result.stats) if result.stats
@@ -93,6 +97,51 @@ module Rigor
       result.success? ? 0 : 1
     end
 
+    # ADR-22 — apply the baseline filter as the LAST step of
+    # the diagnostic pipeline (after `# rigor:disable`,
+    # `severity_profile`, etc. — WD6). Resolution order
+    # follows WD2 (b):
+    #
+    #   1. --no-baseline on the CLI → no baseline.
+    #   2. --baseline=PATH on the CLI → load that path.
+    #   3. .rigor.yml's `baseline: <path>` → load that path.
+    #   4. otherwise → no baseline.
+    #
+    # When the path resolves and loads successfully, the filter
+    # replaces `result.diagnostics` with the surfaced set and
+    # writes a one-line summary to stderr (WD7) when any
+    # diagnostics were silenced. Load failures emit a warning
+    # to stderr and fall through to "no baseline" (graceful
+    # degradation).
+    def apply_baseline_filter(result, configuration, options)
+      path = resolve_baseline_path(configuration, options)
+      return result if path.nil?
+
+      baseline = Analysis::Baseline.load(path)
+      return result if baseline.nil?
+
+      surfaced, silenced_count = baseline.filter(result.diagnostics)
+      report_baseline_summary(silenced_count, path) if silenced_count.positive?
+      Analysis::Result.new(diagnostics: surfaced, stats: result.stats)
+    rescue Analysis::Baseline::LoadError => e
+      @err.puts("rigor: baseline load failed: #{e.message} (continuing without baseline)")
+      result
+    end
+
+    # WD2 (b) — resolve effective baseline path.
+    def resolve_baseline_path(configuration, options)
+      cli_value = options.fetch(:baseline)
+      case cli_value
+      when false then nil # --no-baseline
+      when :unset then configuration.baseline_path # fall through to config
+      else cli_value # --baseline=PATH
+      end
+    end
+
+    def report_baseline_summary(silenced_count, baseline_path)
+      @err.puts("rigor: #{silenced_count} diagnostic(s) silenced by baseline #{baseline_path}")
+    end
+
     def build_check_runner(configuration:, options:, buffer:, cache_root:)
       cache_store = options.fetch(:no_cache) ? nil : Cache::Store.new(root: cache_root)
       Analysis::Runner.new(
@@ -180,9 +229,14 @@ module Rigor
         # Both must appear together; the runner uses the pair
         # to bind an in-flight buffer file to its logical path.
         tmp_file: nil,
-        instead_of: nil
+        instead_of: nil,
+        # ADR-22 — baseline filter. `:unset` means "fall through
+        # to `.rigor.yml`'s `baseline:` key"; a String overrides
+        # the config; `false` (from `--no-baseline`) suppresses
+        # any baseline that the config might name.
+        baseline: :unset
       }
-      parser = OptionParser.new do |opts|
+      parser = OptionParser.new do |opts| # rubocop:disable Metrics/BlockLength
         opts.banner = "Usage: rigor check [options] [paths]"
         opts.on("--config=PATH", "Path to the Rigor configuration file") { |value| options[:config] = value }
         opts.on("--format=FORMAT", "Output format: text or json") { |value| options[:format] = value }
@@ -206,6 +260,14 @@ module Rigor
                 "Editor mode: the logical project path the buffer represents (paired with --tmp-file)") do |value|
           options[:instead_of] = value
         end
+        opts.on("--baseline=PATH",
+                "ADR-22: load baseline from PATH (overrides .rigor.yml `baseline:`)") do |value|
+          options[:baseline] = value
+        end
+        opts.on("--no-baseline",
+                "ADR-22: ignore any configured baseline for this run") do
+          options[:baseline] = false
+        end
       end
       parser.parse!(@argv)
       options
@@ -397,6 +459,18 @@ module Rigor
       LspCommand.new(argv: @argv, out: @out, err: @err).run
     end
 
+    def run_baseline
+      require_relative "cli/baseline_command"
+
+      BaselineCommand.new(argv: @argv, out: @out, err: @err).run
+    end
+
+    def run_triage
+      require_relative "cli/triage_command"
+
+      CLI::TriageCommand.new(argv: @argv, out: @out, err: @err).run
+    end
+
     def write_result(result, format)
       case format
       when "json"
@@ -438,6 +512,7 @@ module Rigor
           diff       Compare current diagnostics to a saved baseline JSON
           sig-gen    Emit RBS skeletons inferred from .rb sources (ADR-14)
           lsp        Run the Rigor Language Server (LSP) over stdio
+          triage     Summarise diagnostics: distribution, hotspots, hints (ADR-23)
           version    Print the Rigor version
           help       Print this help
       HELP