rigortype 0.2.2 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a23952ba800fa7d807c8b8acc4d1cfbb3489024d91c3c30d687ebfdb75c7d1f5
-  data.tar.gz: 1a301a820c1c0bd3c2946695ae59f8e00906d1ecebedc0fbfb1fa93da3f6a72a
+  metadata.gz: 749e0e15c9b85dcec97c9afc1b107d5ebc1a1a685cc19aa39d316a9826992d4a
+  data.tar.gz: 45bcee26284594e35b51a050ce8ac234935bee954063b50fdfe1b0c6a9bcddea
 SHA512:
-  metadata.gz: 6574512ee06d1eb87e42f697d7261eac8ecf9bba9ae4a8a4be6263fba188de5b9786babdcef7e9b2cf41ac4877010726d60f66b741af7b5295d6d3e98e5937cb
-  data.tar.gz: d1bcccf23cac521597657aadd2f1c35d7a860998dd3fc8e02a7802c2dc0e9bf23ca3c0e6c368cdb9574cc1ac1e5ff2395f9dd5f164beae13541874d617886b19
+  metadata.gz: fbf022b6e92a96e1c095cb3d887936161e836201662f051c60de5d0d78494f263228a28df509c3b937768735b5ce18162ee28657b2aaf1cd7a8b2d4851338a53
+  data.tar.gz: a49e89a07950f54fcf8f38e328b8fdb658aaf0802154df457c7b9b1370f35279c1d6d5fe3acf6a45c9e49ff2f7c09ff9f209b1f7dab68d20b283c9baa4b2760b

data/docs/manual/02-cli-reference.md

@@ -232,6 +232,18 @@ rigor triage [paths]
 `--selectors-only`, and `--no-hints` select which sections print.
 `triage` is advisory and always exits `0` — it never gates a build.
 
+By default the distribution, selectors, and hotspots sections count
+only the **actionable** diagnostics (`error` + `warning`). `info`
+diagnostics are excluded from these volume views — on a Rails project
+they are dominated by plugin *recognition trace* (`Account.find
+resolves to Account`, `users_path → GET /users`), positive "Rigor
+resolved this" records that would otherwise bury the genuine signal
+and skew the hotspot ranking toward the files with the most *working*
+code. The summary line still reports the full `info` count, and
+heuristic hints still see every diagnostic (so the `gem-without-rbs`
+notice survives). Pass `--include-info` to route `info` into the
+volume views as well.
+
 The **`selectors`** section is the by-(class, method) axis: it
 aggregates the structured `receiver_type` / `method_name` fields the
 diagnostics carry into `{receiver, method, count, files, rules}`

data/docs/manual/10-mcp-server.md

@@ -295,10 +295,17 @@ the most common error clusters.
   "hints": [
     { "id": "activesupport-core-ext", "confidence": "likely",
       "diagnostic_count": 365, "summary": "...", "action": "..." }
-  ]
+  ],
+  "include_info": false
 }
 ```
 
+By default the `distribution` / `selectors` / `hotspots` arrays count
+only the actionable diagnostics (`error` + `warning`); `info` (mostly
+plugin recognition trace) is excluded, so those counts do not sum to
+`summary.total` and `include_info` is `false`. `summary.info` still
+reports the full info count, and the hints still see every diagnostic.
+
 The `selectors` array is the by-(class, method) axis: each row is a
 dispatch target with its `count`, distinct-`files` spread, and
 per-`rule` breakdown, keyed on a normalised receiver class — so an

data/lib/rigor/analysis/diagnostic.rb

@@ -47,6 +47,9 @@ module Rigor
       def initialize(path:, line:, column:, message:, severity: :error, rule: nil, # rubocop:disable Metrics/ParameterLists
                      source_family: DEFAULT_SOURCE_FAMILY,
                      receiver_type: nil, method_name: nil, project_definition_site: nil)
+        raise ArgumentError, "line must be >= 1, got #{line}" if line < 1
+        raise ArgumentError, "column must be >= 1, got #{column}" if column < 1
+
         @path = path
         @line = line
         @column = column

data/lib/rigor/cli/skill_describe.rb

@@ -208,8 +208,14 @@ module Rigor
           ["rigor-rbs-setup", "your gems ship no community RBS yet — install it so Rigor stops typing them as Dynamic."]
         elsif state.fetch(:ci) != :wired
           ["rigor-ci-setup", "Rigor is configured but not wired into CI — lock in the regression guard."]
-        elsif state.fetch(:baseline)
-          ["rigor-baseline-reduce", "a baseline is in place — work it down rule by rule."]
+        # A present baseline is deliberately NOT a recommendation trigger.
+        # A baseline is a healthy, finished onboarding state, not a problem to
+        # work off; pushing every baselined project to "reduce it" turns a
+        # working build into a chore and tempts scattering `# rigor:disable`
+        # through the code to make a number go down — means over ends.
+        # `rigor-baseline-reduce` stays in the catalogue for the intermediate
+        # user who *chooses* to invest in it; the headline routes to genuinely
+        # additive steps instead.
         elsif state.fetch(:editor) == :unwired
           ["rigor-editor-setup",
            "you have an editor config but no Rigor LSP — wire `rigor lsp` for live diagnostics and hover types."]
@@ -297,7 +303,6 @@ module Rigor
           The recommendation above is from a presence-only probe — it does not run
           `rigor check`. If you have run (or now run) `rigor check`, let its findings
           refine the choice:
-          - errors present and no baseline yet → rigor-baseline-reduce
           - a `call.unresolved-toplevel` / `call.undefined-method` cluster on the
             project's own monkey-patches → rigor-monkeypatch-resolve
           - framework calls (ActiveRecord, routes, i18n …) typing as Dynamic with no

data/lib/rigor/cli/triage_command.rb

@@ -31,7 +31,8 @@ module Rigor
         diagnostics = analyze(configuration)
 
         report = Triage.analyze(diagnostics, top: options.fetch(:top),
-                                             hints: options.fetch(:sections).include?(:hints))
+                                             hints: options.fetch(:sections).include?(:hints),
+                                             include_info: options.fetch(:include_info))
         renderer = TriageRenderer.new(report, sections: options.fetch(:sections))
         @out.puts(options.fetch(:format) == "json" ? renderer.json : renderer.text)
         0
@@ -40,12 +41,17 @@ module Rigor
       private
 
       def parse_options
-        options = { config: nil, format: "text", top: 10, sections: DEFAULT_SECTIONS }
+        options = { config: nil, format: "text", top: 10, sections: DEFAULT_SECTIONS, include_info: false }
         OptionParser.new do |opts|
           opts.banner = USAGE
           Options.add_config(opts, options)
           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("--include-info",
+                  "Route info diagnostics into distribution / selectors / hotspots " \
+                  "(excluded by default — mostly plugin recognition trace)") do
+            options[:include_info] = true
+          end
           opts.on("--hints-only", "Print only the heuristic-hints section") { options[:sections] = %i[hints] }
           opts.on("--no-hints", "Print distribution + selectors + hotspots only") do
             options[:sections] = %i[distribution selectors hotspots]

data/lib/rigor/cli/triage_renderer.rb

@@ -37,6 +37,10 @@ module Rigor
         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?})"]
+        if !@report.include_info && s.info.positive?
+          lines << "  #{s.info} info diagnostic(s) hidden below " \
+                   "(mostly plugin recognition trace) — pass --include-info to route them"
+        end
         @report.distribution.each do |row|
           lines << format("  %<rule>-32s %<count>5d  %<bar>s",
                           rule: row.rule, count: row.count, bar: bar(row.count, max))

data/lib/rigor/environment/rbs_loader.rb

@@ -170,7 +170,7 @@ module Rigor
           source = missing.map { |name| "module #{name}\nend\n" }.join
           buffer = ::RBS::Buffer.new(name: SYNTHETIC_NAMESPACE_BUFFER, content: source)
           _, directives, decls = ::RBS::Parser.parse_signature(buffer)
-          env.add_source(::RBS::Source::RBS.new(buffer, directives || [], decls || []))
+          add_parsed_decls(env, buffer, directives, decls)
         rescue ::RBS::BaseError
           # Fail-soft: synthesis is an opportunistic uplift, never a
           # hard requirement. A parse failure here just leaves the env
@@ -232,11 +232,52 @@ module Rigor
           missing.uniq
         end
 
+        # Normalises a `class_decls` entry's representative declaration
+        # across the gemspec's supported RBS range (`rbs >= 3.0, < 5.0`).
+        # RBS 4.x exposes it as `entry.primary_decl` (the AST declaration
+        # directly); RBS 3.x exposes `entry.primary` (a wrapper whose
+        # `#decl` is the AST declaration). Returns the AST declaration, or
+        # nil when neither accessor is present. Without this guard,
+        # `class_decl_paths` crashed under RBS 3.x with
+        # `undefined method 'primary_decl'`.
+        def primary_decl_for(entry)
+          if entry.respond_to?(:primary_decl)
+            entry.primary_decl
+          elsif entry.respond_to?(:primary)
+            primary = entry.primary
+            primary.respond_to?(:decl) ? primary.decl : primary
+          end
+        end
+
+        # Appends freshly-parsed declarations to an `RBS::Environment`
+        # across the gemspec's supported RBS range (`rbs >= 3.0, < 5.0`).
+        # RBS 4.x wraps the declarations in an `RBS::Source::RBS` and
+        # takes them through `env.add_source`; RBS 3.x has neither
+        # `RBS::Source` nor `add_source` and instead registers them with
+        # `env.add_signature(buffer:, directives:, decls:)` (a bare
+        # `env << decl` is NOT enough — it skips the `signatures` table
+        # that `resolve_type_names` rebuilds from, so the synthesized
+        # declarations silently vanish on resolve). Without this guard
+        # the synthesis paths (`synthesize_missing_namespaces`,
+        # `append_stub_declarations`, `add_virtual_rbs`) crashed under
+        # RBS 3.x with `uninitialized constant RBS::Source`.
+        def add_parsed_decls(env, buffer, directives, decls)
+          decls ||= []
+          directives ||= []
+          if env.respond_to?(:add_source)
+            env.add_source(::RBS::Source::RBS.new(buffer, directives, decls))
+          elsif env.respond_to?(:add_signature)
+            env.add_signature(buffer: buffer, directives: directives, decls: decls)
+          else
+            decls.each { |decl| env << decl }
+          end
+        end
+
         # True when a `class_decls` entry was declared in one of the
         # project's own signature files (by declaration location), so
         # the sweep skips the bundled stdlib / vendored universe.
         def project_entry?(entry, project_files)
-          decl = entry.respond_to?(:primary_decl) ? entry.primary_decl : nil
+          decl = primary_decl_for(entry)
           location = decl&.location
           buffer_name = location&.buffer&.name
           return false unless buffer_name
@@ -262,7 +303,7 @@ module Rigor
           end.join
           buffer = ::RBS::Buffer.new(name: SYNTHETIC_STUB_BUFFER, content: source)
           _, directives, decls = ::RBS::Parser.parse_signature(buffer)
-          base_env.add_source(::RBS::Source::RBS.new(buffer, directives || [], decls || []))
+          add_parsed_decls(base_env, buffer, directives, decls)
         rescue ::RBS::BaseError
           nil
         end
@@ -284,8 +325,7 @@ module Rigor
 
             buffer = ::RBS::Buffer.new(name: filename.to_s, content: content.to_s)
             _, directives, decls = ::RBS::Parser.parse_signature(buffer)
-            source = ::RBS::Source::RBS.new(buffer, directives || [], decls || [])
-            env.add_source(source)
+            add_parsed_decls(env, buffer, directives, decls)
           rescue ::RBS::BaseError
             # WD6 fail-soft: a single broken virtual RBS contribution
             # does not pull the whole env down. The plugin layer
@@ -589,7 +629,7 @@ module Rigor
 
         result = {}
         env.class_decls.each do |rbs_name, entry|
-          decl = entry.primary_decl
+          decl = self.class.primary_decl_for(entry)
           next if decl.nil?
 
           location = decl.location
@@ -911,12 +951,17 @@ module Rigor
       end
 
       # Collects the AST declaration nodes behind a `class_decls`
-      # entry. RBS 4's `ModuleEntry` / `ClassEntry` expose `each_decl`;
-      # the older single-`decl` shape is handled defensively so the
-      # loader survives an rbs-gem minor bump.
+      # entry across the supported RBS range (`rbs >= 3.0, < 5.0`).
+      # RBS 4's `ModuleEntry` / `ClassEntry` expose `each_decl` yielding
+      # bare AST declarations; RBS 3.x exposes `decls`, an array of
+      # `MultiEntry::D` wrappers whose `#decl` is the AST declaration.
+      # The single-`decl` shape is handled defensively so the loader
+      # survives an rbs-gem minor bump.
       def entry_declarations(entry)
         if entry.respond_to?(:each_decl)
           [].tap { |acc| entry.each_decl { |decl| acc << decl } }
+        elsif entry.respond_to?(:decls)
+          entry.decls.map { |d| d.respond_to?(:decl) ? d.decl : d }
         elsif entry.respond_to?(:decl)
           [entry.decl]
         else

data/lib/rigor/triage/catalogue.rb

@@ -87,12 +87,27 @@ module Rigor
       GENUINE_BUG_MAX_COUNT = 5    # rule total ≤ N → "likely genuine bug"
       private_constant :SYSTEMIC_THRESHOLD, :MONKEY_PATCH_MIN_FILES, :GENUINE_BUG_MAX_COUNT
 
+      # WD6 (ADR-23): H5 (systemic cluster) and H6 (genuine bugs) are
+      # the only count-based, severity-agnostic recognisers, so they
+      # alone risk reading plugin recognition trace (`:info`
+      # `*.model-call` / `*.helper`, …) as a "systemic cluster" or a
+      # "genuine bug" — frightening working code. They are guarded
+      # against `:info` unless `include_info` restores the pre-v0.2.3
+      # behaviour. Every other recogniser keys on an error/warning rule
+      # (H1/H2/H2K/H4/H7) or intentionally reads an info notice
+      # (H3 — the `gem-without-rbs` `rbs.coverage.missing-gem`), so the
+      # full pool is correct for them.
+      INFO_GUARDED = %i[h5_systemic_cluster h6_genuine_bugs].freeze
+      private_constant :INFO_GUARDED
+
       # @param diagnostics [Array<Analysis::Diagnostic>]
+      # @param include_info [Boolean] let H5/H6 see `:info` diagnostics
       # @return [Array<Hint>]
-      def recognise(diagnostics)
+      def recognise(diagnostics, include_info: false)
         claimed = {}.compare_by_identity
         recognisers.filter_map do |recogniser|
           pool = diagnostics.reject { |d| claimed[d] }
+          pool = pool.reject { |d| d.severity == :info } if INFO_GUARDED.include?(recogniser) && !include_info
           hint, matched = send(recogniser, pool)
           next unless hint
 

data/lib/rigor/triage.rb

@@ -26,21 +26,40 @@ module Rigor
     # receiver); `files` is the distinct-file count (a systemic vs.
     # localised signal); `rules` is the per-rule breakdown.
     Selector = Data.define(:receiver, :method_name, :count, :files, :rules)
-    Report = Data.define(:summary, :distribution, :selectors, :hotspots, :hints)
+    Report = Data.define(:summary, :distribution, :selectors, :hotspots, :hints, :include_info)
 
     module_function
 
+    # WD6 (ADR-23): the volume views — distribution / selectors /
+    # hotspots — route only the *actionable* diagnostics (error +
+    # warning) by default. Plugin-emitted `:info` diagnostics are
+    # overwhelmingly recognition trace (`plugin.activerecord.model-call`,
+    # `plugin.rails-routes.helper`, …) — positive "Rigor resolved this
+    # call" records, not problems — and on a real Rails app they swamp
+    # the genuine error/warning signal (the field trip: 257 of 267
+    # diagnostics were such trace) and invert the hotspot ranking
+    # towards the files with the *most working* code. The summary still
+    # reports the full info count, and `include_info: true` (the
+    # `--include-info` flag) restores the pre-v0.2.3 behaviour. Hints
+    # always see the full stream so the `gem-without-rbs` notice (an
+    # info-severity `rbs.coverage.missing-gem`) survives; the
+    # count-based H5/H6 recognisers guard against info themselves so
+    # recognition trace never reads as a bug.
+    #
     # @param diagnostics [Array<Analysis::Diagnostic>]
     # @param top [Integer] hotspot-file cap
     # @param hints [Boolean] run the heuristic catalogue
+    # @param include_info [Boolean] route info into the volume views
     # @return [Report]
-    def analyze(diagnostics, top: 10, hints: true)
+    def analyze(diagnostics, top: 10, hints: true, include_info: false)
+      routed = include_info ? diagnostics : diagnostics.reject { |d| d.severity == :info }
       Report.new(
         summary: build_summary(diagnostics),
-        distribution: build_distribution(diagnostics),
-        selectors: build_selectors(diagnostics),
-        hotspots: build_hotspots(diagnostics, top),
-        hints: hints ? Catalogue.recognise(diagnostics) : []
+        distribution: build_distribution(routed),
+        selectors: build_selectors(routed),
+        hotspots: build_hotspots(routed, top),
+        hints: hints ? Catalogue.recognise(diagnostics, include_info: include_info) : [],
+        include_info: include_info
       )
     end
 
@@ -150,7 +169,11 @@ module Rigor
         "hotspots" => report.hotspots.map do |h|
           { "file" => h.file, "count" => h.count, "by_rule" => h.by_rule }
         end,
-        "hints" => report.hints.map(&:to_h)
+        "hints" => report.hints.map(&:to_h),
+        # WD6: false means distribution / selectors / hotspots above
+        # exclude `:info` (their counts will not sum to summary.total);
+        # the summary's `info` field still reports the full count.
+        "include_info" => report.include_info
       }
     end
   end

data/lib/rigor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rigor
-  VERSION = "0.2.2"
+  VERSION = "0.2.4"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rigortype
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.4
 platform: ruby
 authors:
 - Rigor contributors