rigortype 0.1.7 → 0.1.9

data/lib/rigor/cli/baseline_command.rb

@@ -9,22 +9,22 @@ 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`.
+    # ADR-22 — `rigor baseline {generate,regenerate,dump,drift,
+    # prune}` subcommands, backed by `Rigor::Analysis::Baseline`.
     #
     #   rigor baseline generate              # default: rule-ID rows
     #   rigor baseline generate --match-mode message
     #   rigor baseline generate --force      # overwrite existing
     #   rigor baseline generate --output=PATH
+    #   rigor baseline regenerate            # slice 5: unconditional rewrite
+    #   rigor baseline dump
+    #   rigor baseline drift
+    #   rigor baseline prune
     class BaselineCommand # rubocop:disable Metrics/ClassLength
       EXIT_USAGE = 64
       DEFAULT_BASELINE_PATH = ".rigor-baseline.yml"
 
-      SUBCOMMANDS = %w[generate dump drift prune].freeze
+      SUBCOMMANDS = %w[generate regenerate dump drift prune].freeze
 
       def initialize(argv:, out: $stdout, err: $stderr)
         @argv = argv
@@ -39,6 +39,7 @@ module Rigor
           @out.puts(help)
           0
         when "generate" then run_generate
+        when "regenerate" then run_regenerate
         when "dump" then run_dump
         when "drift" then run_drift
         when "prune" then run_prune
@@ -59,21 +60,36 @@ module Rigor
         path = options.fetch(:output)
 
         if File.exist?(path) && !options.fetch(:force)
-          @err.puts("rigor: #{path} already exists. Re-run with --force to overwrite.")
+          @err.puts("rigor: #{path} already exists. Re-run with --force to " \
+                    "overwrite, or use `rigor baseline regenerate`.")
           return EXIT_USAGE
         end
 
+        write_baseline(options, verb: "wrote baseline to")
+      end
+
+      # ADR-22 slice 5 — `regenerate` is `generate --force`: the
+      # end-of-quality-improvement-session refresh after landing
+      # baseline-reducing fixes. It rewrites the file
+      # unconditionally (no existence guard, no `--force` flag),
+      # so `rigor baseline regenerate` reads cleanly as "make the
+      # baseline match reality again".
+      def run_regenerate
+        options = parse_generate_options(subcommand: "regenerate")
+        write_baseline(options, verb: "regenerated baseline")
+      end
+
+      def write_baseline(options, verb:)
+        path = options.fetch(:output)
         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); " \
+          "rigor: #{verb} #{path} " \
+          "(#{baseline.size} bucket(s) covering #{diagnostics.size} diagnostic(s); " \
           "match-mode: #{options.fetch(:match_mode)})"
         )
         if configuration.baseline_path.nil?
@@ -85,7 +101,7 @@ module Rigor
         0
       end
 
-      def parse_generate_options
+      def parse_generate_options(subcommand: "generate")
         options = {
           config: nil,
           output: DEFAULT_BASELINE_PATH,
@@ -93,7 +109,7 @@ module Rigor
           force: false
         }
         parser = OptionParser.new do |opts|
-          opts.banner = "Usage: rigor baseline generate [options]"
+          opts.banner = "Usage: rigor baseline #{subcommand} [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
@@ -102,7 +118,10 @@ module Rigor
                   "Row form: rule (default) or message") do |v|
             options[:match_mode] = v
           end
-          opts.on("--force", "Overwrite an existing baseline file") { options[:force] = true }
+          # `regenerate` always overwrites — no `--force` to offer.
+          if subcommand == "generate"
+            opts.on("--force", "Overwrite an existing baseline file") { options[:force] = true }
+          end
         end
         parser.parse!(@argv)
         options
@@ -290,7 +309,7 @@ module Rigor
         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 :reducible then "## Reducible (#{count}) — tightening opportunity; run `rigor baseline regenerate`."
         when :within then "## Within threshold (#{count})"
         end
       end
@@ -365,6 +384,7 @@ module Rigor
 
           Subcommands:
             generate    Write a fresh baseline file from a `rigor check` run.
+            regenerate  Rewrite the baseline unconditionally (post-fix refresh).
             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.

data/lib/rigor/cli/prism_colorizer.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Rigor
+  class CLI
+    # Re-lexes Ruby source with Prism and wraps each token in an
+    # ANSI colour escape, producing IRB-style syntax highlighting.
+    #
+    # Rigor ships no runtime dependencies (ADR-0), so the `irb`
+    # gem's `IRB::Color` is not available; this module reproduces
+    # the same effect from Prism's own token stream. `rigor
+    # annotate` re-parses its annotated output through here before
+    # printing.
+    module PrismColorizer
+      module_function
+
+      RESET = "\e[0m"
+
+      # token category => ANSI SGR parameters.
+      CATEGORY_SGR = {
+        comment: "90",      # bright black (faint grey)
+        keyword: "33",      # yellow
+        literal_kw: "36",   # cyan   — nil / true / false / self
+        number: "34",       # blue
+        string: "32",       # green
+        symbol: "36",       # cyan
+        constant: "1;34",   # bold blue
+        variable: "34",     # blue   — @ivar / @@cvar / $gvar
+        default: nil
+      }.freeze
+
+      LITERAL_KEYWORDS = %i[
+        KEYWORD_NIL KEYWORD_TRUE KEYWORD_FALSE KEYWORD_SELF
+        KEYWORD___FILE__ KEYWORD___LINE__ KEYWORD___ENCODING__
+      ].freeze
+
+      VARIABLE_TOKENS = %i[INSTANCE_VARIABLE CLASS_VARIABLE GLOBAL_VARIABLE].freeze
+
+      # @param source [String] Ruby source.
+      # @return [String] the source with ANSI colour escapes, or
+      #   the input unchanged when lexing surfaces an error.
+      def colorize(source)
+        result = Prism.lex(source)
+        return source unless result.errors.empty?
+
+        render(source, result.value)
+      end
+
+      def render(source, lexed)
+        out = +""
+        offset = 0
+        previous_type = nil
+        lexed.each do |entry|
+          token = entry.first
+          location = token.location
+          out << source[offset...location.start_offset]
+          break if token.type == :EOF
+
+          text = source[location.start_offset...location.end_offset]
+          out << paint(text, effective_category(token.type, previous_type))
+          offset = location.end_offset
+          previous_type = token.type
+        end
+        out << (source[offset..] || "")
+        out
+      end
+
+      # The token after a `SYMBOL_BEGIN` (`:`) carries the symbol
+      # name — and Prism lexes `:then` / `:class` etc. as a
+      # keyword token — so it is painted with the symbol colour
+      # regardless of its own token type.
+      def effective_category(token_type, previous_type)
+        return :symbol if previous_type == :SYMBOL_BEGIN
+
+        category(token_type)
+      end
+
+      def paint(text, category)
+        sgr = CATEGORY_SGR.fetch(category)
+        return text if sgr.nil? || text.empty?
+
+        # Keep a trailing newline outside the colour span so the
+        # reset sits on the token's own line (comments include it).
+        trailing = text[/\s*\z/] || ""
+        body = trailing.empty? ? text : text[0...-trailing.length]
+        return text if body.empty?
+
+        "\e[#{sgr}m#{body}#{RESET}#{trailing}"
+      end
+
+      def category(token_type)
+        name = token_type.to_s
+        return :comment if token_type == :COMMENT
+        return :literal_kw if LITERAL_KEYWORDS.include?(token_type)
+        return :keyword if name.start_with?("KEYWORD_")
+        return :number if number_token?(name)
+        return :string if name.start_with?("STRING_", "HEREDOC_") || token_type == :STRING_CONTENT
+        return :symbol if name.start_with?("SYMBOL_")
+        return :constant if token_type == :CONSTANT
+        return :variable if VARIABLE_TOKENS.include?(token_type)
+
+        :default
+      end
+
+      def number_token?(name)
+        name.start_with?("INTEGER", "FLOAT", "RATIONAL", "IMAGINARY")
+      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

@@ -21,13 +21,15 @@ module Rigor
     HANDLERS = {
       "check" => :run_check,
       "init" => :run_init,
+      "annotate" => :run_annotate,
       "type-of" => :run_type_of,
       "type-scan" => :run_type_scan,
       "explain" => :run_explain,
       "diff" => :run_diff,
       "sig-gen" => :run_sig_gen,
       "lsp" => :run_lsp,
-      "baseline" => :run_baseline
+      "baseline" => :run_baseline,
+      "triage" => :run_triage
     }.freeze
 
     def self.start(argv = ARGV, out: $stdout, err: $stderr)
@@ -87,13 +89,56 @@ module Rigor
         configuration: configuration, options: options,
         buffer: buffer, cache_root: cache_root
       )
-      result = runner.run(@argv.empty? ? configuration.paths : @argv)
-      result = apply_baseline_filter(result, configuration, options)
+      raw_result = runner.run(@argv.empty? ? configuration.paths : @argv)
+      result = apply_baseline_filter(raw_result, configuration, options)
 
       write_result(result, options.fetch(:format))
       write_run_stats(result.stats) if result.stats
       write_cache_stats(cache_root, runner.cache_store) if options.fetch(:cache_stats)
-      result.success? ? 0 : 1
+
+      exit_code = result.success? ? 0 : 1
+      exit_code = 1 if baseline_strict_violation?(raw_result.diagnostics, configuration, options)
+      exit_code
+    end
+
+    # ADR-22 slice 5 — the `--baseline-strict` CI gate. When the
+    # flag is set, ANY baseline drift fails the run — not only
+    # excess drift (a bucket over threshold, which already fails
+    # via the surfaced diagnostics) but also DEFICIT drift
+    # (`actual < count`: the baseline has grown looser than the
+    # code and should be regenerated). A no-op, with a stderr
+    # note, when no baseline is active — the flag never
+    # implicitly loads a baseline the config did not name (WD2).
+    def baseline_strict_violation?(raw_diagnostics, configuration, options)
+      return false unless options.fetch(:baseline_strict)
+
+      path = resolve_baseline_path(configuration, options)
+      if path.nil?
+        @err.puts("rigor: --baseline-strict given but no baseline is active; nothing to gate.")
+        return false
+      end
+
+      baseline = Analysis::Baseline.load(path)
+      return false if baseline.nil? || baseline.empty?
+
+      drifted = baseline.audit(raw_diagnostics).reject { |row| row.status == :within }
+      return false if drifted.empty?
+
+      report_strict_drift(drifted, path)
+      true
+    rescue Analysis::Baseline::LoadError => e
+      @err.puts("rigor: baseline load failed: #{e.message} (--baseline-strict gate skipped)")
+      false
+    end
+
+    def report_strict_drift(rows, path)
+      @err.puts("rigor: --baseline-strict — #{rows.size} bucket(s) drifted from #{path}:")
+      rows.sort_by { |r| [r.bucket.file, r.bucket.rule] }.each do |row|
+        delta = row.delta.positive? ? "+#{row.delta}" : row.delta.to_s
+        @err.puts("  #{row.bucket.file}  [#{row.bucket.rule}]  " \
+                  "#{row.bucket.count} → #{row.actual_count}  (Δ#{delta}, #{row.status})")
+      end
+      @err.puts("rigor: run `rigor baseline regenerate` to refresh the baseline.")
     end
 
     # ADR-22 — apply the baseline filter as the LAST step of
@@ -233,7 +278,10 @@ module Rigor
         # 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
+        baseline: :unset,
+        # ADR-22 slice 5 — `--baseline-strict` CI gate: fail the
+        # run on any baseline drift, in either direction.
+        baseline_strict: false
       }
       parser = OptionParser.new do |opts| # rubocop:disable Metrics/BlockLength
         opts.banner = "Usage: rigor check [options] [paths]"
@@ -267,6 +315,10 @@ module Rigor
                 "ADR-22: ignore any configured baseline for this run") do
           options[:baseline] = false
         end
+        opts.on("--baseline-strict",
+                "ADR-22: fail the run on any baseline drift (CI gate)") do
+          options[:baseline_strict] = true
+        end
       end
       parser.parse!(@argv)
       options
@@ -422,6 +474,12 @@ module Rigor
       YAML
     end
 
+    def run_annotate
+      require_relative "cli/annotate_command"
+
+      AnnotateCommand.new(argv: @argv, out: @out, err: @err).run
+    end
+
     def run_type_of
       require_relative "cli/type_of_command"
 
@@ -464,6 +522,12 @@ module Rigor
       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"
@@ -499,12 +563,14 @@ module Rigor
         Commands:
           check      Analyze Ruby source files
           init       Create a starter .rigor.yml
+          annotate   Print FILE with each line's last-expression type
           type-of    Print the inferred type at FILE:LINE:COL
           type-scan  Report Scope#type_of coverage across PATHs
           explain    Print the description of one or all CheckRules
           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

data/lib/rigor/environment.rb

@@ -252,7 +252,15 @@ module Rigor
           project_root: root,
           auto_detect: rbs_collection_auto_detect
         ).map(&:to_s)
-        loader_signature_paths = resolved_paths + gem_sig_paths + collection_paths
+        # ADR-25 — RBS signature directories contributed by loaded
+        # plugins via their manifest `signature_paths:`. Resolved
+        # to absolute dirs by `Plugin::Base#signature_paths`;
+        # additive, ranked below the user's explicit
+        # `signature_paths:` and above the opportunistic bundle /
+        # collection discovery. A duplicate-declaration conflict
+        # degrades through the same O7 failure-memo path.
+        plugin_sig_paths = plugin_registry ? plugin_registry.signature_paths.map(&:to_s) : []
+        loader_signature_paths = resolved_paths + plugin_sig_paths + gem_sig_paths + collection_paths
         merged_libraries = (DEFAULT_LIBRARIES + libraries.map(&:to_s)).uniq
         loader = RbsLoader.new(
           libraries: merged_libraries,

data/lib/rigor/inference/builtins/method_catalog.rb

@@ -57,7 +57,8 @@ module Rigor
           return nil unless klass
 
           bucket_key = kind == :singleton ? "singleton_methods" : "instance_methods"
-          klass.dig(bucket_key, selector.to_s)
+          klass.dig(bucket_key, selector.to_s) ||
+            resolve_alias_entry(klass, selector, bucket_key)
         end
 
         def reset!
@@ -66,6 +67,21 @@ module Rigor
 
         private
 
+        def resolve_alias_entry(klass, selector, bucket_key)
+          return nil unless bucket_key == "instance_methods"
+
+          aliases = klass["aliases"]
+          return nil unless aliases
+
+          alias_entry = aliases[selector.to_s]
+          return nil unless alias_entry
+
+          target = alias_entry["old"]
+          return nil unless target
+
+          klass.dig(bucket_key, target)
+        end
+
         def blocked?(class_name, selector)
           # Bang-suffixed selectors are mutating by Ruby convention
           # (`upcase!`, `concat`, etc. are listed explicitly below;

data/lib/rigor/inference/builtins/time_catalog.rb

@@ -55,7 +55,16 @@ module Rigor
             # as `time_localtime`: `time_modify(time)` then a
             # `time_set_vtm` write and `TZMODE_SET_UTC`. Both
             # selectors share the cfunc, so both must be blocked.
-            :gmtime, :utc
+            :gmtime, :utc,
+            # `getlocal` is not a mutator — it returns a fresh Time —
+            # but the fresh Time is pinned to the *analysis machine's*
+            # timezone. Folding it through a `Constant[Time]` carrier
+            # (which only ever holds a UTC literal from `Time.utc`)
+            # would bake a host-dependent wall clock / `utc_offset`
+            # into the inferred type. Blocked so the fold stays
+            # machine-independent; the RBS tier answers `Nominal[Time]`.
+            # `getutc` / `getgm` stay foldable — their result is UTC.
+            :getlocal
           ]
         }
       )