rigortype 0.1.11 → 0.1.13

data/lib/rigor/cli/plugins_renderer.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Rigor
+  class CLI
+    # Renderer for `rigor plugins`. Produces a human-readable
+    # text table and a JSON representation from the same row
+    # shape (the Hash documented on
+    # {Rigor::CLI::PluginsCommand#loaded_row}).
+    #
+    # The two formats carry the same content; JSON is meant for
+    # tooling (SKILLs, CI, editor integrations) while text is
+    # for interactive inspection. Rows are printed in the order
+    # the loader resolved them.
+    class PluginsRenderer
+      def initialize(rows:, configuration_path:)
+        @rows = rows
+        @configuration_path = configuration_path
+      end
+
+      def text
+        lines = []
+        lines << header
+        lines << ""
+        @rows.each_with_index do |row, index|
+          lines.concat(row_lines(row))
+          lines << "" unless index == @rows.size - 1
+        end
+        lines << ""
+        lines << footer
+        lines.join("\n")
+      end
+
+      def json
+        JSON.pretty_generate(
+          {
+            "configuration" => @configuration_path,
+            "plugins" => @rows.map { |row| row_json(row) },
+            "summary" => summary
+          }
+        )
+      end
+
+      private
+
+      def header
+        loaded = @rows.count { |r| r[:status] == :loaded }
+        errored = @rows.count { |r| r[:status] == :load_error }
+        config = @configuration_path || "(no .rigor.yml found; using defaults)"
+        "Plugin activation report\n  " \
+          "configuration: #{config}\n  " \
+          "loaded: #{loaded}    load-error: #{errored}"
+      end
+
+      def footer
+        errored = @rows.select { |r| r[:status] == :load_error }
+        if errored.empty?
+          "All configured plugins loaded successfully."
+        else
+          "#{errored.size} plugin(s) failed to load — see above. " \
+            "Run with --strict to make this a CI gate."
+        end
+      end
+
+      def row_lines(row)
+        marker = row[:status] == :loaded ? "OK " : "ERR"
+        head = if row[:status] == :loaded
+                 "  [#{marker}] #{row[:id]}  v#{row[:version]}  (#{row[:gem]})"
+               else
+                 "  [#{marker}] #{row[:gem]}"
+               end
+        lines = [head]
+        lines << "        #{row[:description]}" if row[:description]
+
+        if row[:status] == :load_error
+          lines << "        load error: #{row[:load_error]}"
+          lines << "        config: #{row[:config].inspect}" if row[:config] && !row[:config].empty?
+          return lines
+        end
+
+        lines.concat(loaded_detail_lines(row))
+        lines
+      end
+
+      def loaded_detail_lines(row)
+        lines = []
+        lines.concat(signature_paths_lines(row[:signature_paths])) if row[:signature_paths].any?
+        lines.concat(receiver_and_fact_lines(row))
+        lines.concat(macro_substrate_lines(row))
+        lines.concat(extra_surface_lines(row))
+        lines << "        config: #{row[:config].inspect}" if row[:config] && !row[:config].empty?
+        lines
+      end
+
+      def receiver_and_fact_lines(row)
+        lines = []
+        lines << "        open_receivers: #{row[:open_receivers].join(', ')}" if row[:open_receivers].any?
+        lines << "        owns_receivers: #{row[:owns_receivers].join(', ')}" if row[:owns_receivers].any?
+        lines << "        produces: #{row[:produces].join(', ')}" if row[:produces].any?
+        lines << "        consumes: #{row[:consumes].join(', ')}" if row[:consumes].any?
+        lines
+      end
+
+      def extra_surface_lines(row)
+        lines = []
+        lines << "        protocol_contracts: #{row[:protocol_contracts]}" if row[:protocol_contracts].positive?
+        lines << "        source_rbs_synthesizer: yes" if row[:source_rbs_synthesizer]
+        lines << "        type_node_resolvers: #{row[:type_node_resolvers]}" if row[:type_node_resolvers].positive?
+        if row[:hkt_registrations].positive? || row[:hkt_definitions].positive?
+          lines << "        hkt: #{row[:hkt_registrations]} registration(s), #{row[:hkt_definitions]} definition(s)"
+        end
+        lines
+      end
+
+      def signature_paths_lines(paths)
+        lines = ["        signature_paths:"]
+        paths.each do |entry|
+          marker = entry[:exists] ? "" : " (MISSING)"
+          lines << "          #{entry[:path]}  (#{entry[:rbs_files]} .rbs file(s))#{marker}"
+        end
+        lines
+      end
+
+      def macro_substrate_lines(row)
+        parts = []
+        parts << "block_as_methods=#{row[:block_as_methods]}" if row[:block_as_methods].positive?
+        parts << "heredoc_templates=#{row[:heredoc_templates]}" if row[:heredoc_templates].positive?
+        parts << "trait_registries=#{row[:trait_registries]}" if row[:trait_registries].positive?
+        parts << "external_files=#{row[:external_files]}" if row[:external_files].positive?
+        return [] if parts.empty?
+
+        ["        macro substrate: #{parts.join(', ')}"]
+      end
+
+      def row_json(row)
+        {
+          "gem" => row[:gem],
+          "status" => row[:status].to_s,
+          "id" => row[:id],
+          "version" => row[:version],
+          "description" => row[:description],
+          "config" => row[:config],
+          "signature_paths" => row[:signature_paths].map do |sp|
+            { "path" => sp[:path], "exists" => sp[:exists], "rbs_files" => sp[:rbs_files] }
+          end,
+          "open_receivers" => row[:open_receivers],
+          "owns_receivers" => row[:owns_receivers],
+          "produces" => row[:produces],
+          "consumes" => row[:consumes],
+          "block_as_methods" => row[:block_as_methods],
+          "heredoc_templates" => row[:heredoc_templates],
+          "trait_registries" => row[:trait_registries],
+          "external_files" => row[:external_files],
+          "type_node_resolvers" => row[:type_node_resolvers],
+          "hkt_registrations" => row[:hkt_registrations],
+          "hkt_definitions" => row[:hkt_definitions],
+          "protocol_contracts" => row[:protocol_contracts],
+          "source_rbs_synthesizer" => row[:source_rbs_synthesizer],
+          "load_error" => row[:load_error]
+        }
+      end
+
+      def summary
+        {
+          "total" => @rows.size,
+          "loaded" => @rows.count { |r| r[:status] == :loaded },
+          "load_error" => @rows.count { |r| r[:status] == :load_error }
+        }
+      end
+    end
+  end
+end

data/lib/rigor/cli/skill_command.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module Rigor
+  class CLI
+    # `rigor skill` — discover and print the SKILL.md files
+    # bundled with the `rigortype` gem.
+    #
+    # Rigor ships a small set of Agent Skills under `skills/` that
+    # walk an AI coding agent through onboarding (`rigor-project-init`),
+    # baseline reduction (`rigor-baseline-reduce`), and authoring a
+    # plugin (`rigor-plugin-author`). When Rigor is installed via
+    # `mise` / `gem install` / etc. the SKILL files live inside the
+    # gem checkout — the project being analysed has no copy, so an
+    # AI agent has no a priori way to find them.
+    #
+    # This command exposes the bundled skills via three subcommands:
+    #
+    # - `rigor skill list`         — table of name + absolute path.
+    # - `rigor skill print <name>` — short header (paths + how to use)
+    #                                followed by the SKILL.md body. This
+    #                                is the form AI agents should call;
+    #                                the inline body plus the header's
+    #                                absolute paths together let the
+    #                                agent act with or without a file
+    #                                reading tool.
+    # - `rigor skill path <name>`  — one-line absolute path, suitable
+    #                                as input to a Read tool.
+    #
+    # `rigor skill` with no subcommand is an alias for `list`.
+    class SkillCommand
+      USAGE = <<~USAGE
+        Usage: rigor skill <subcommand> [args]
+
+        Subcommands:
+          list                  List bundled skills (default when no subcommand given)
+          print <name>          Print the SKILL.md body for <name> to stdout, with a header
+          path  <name>          Print the absolute path of the SKILL.md file for <name>
+
+        Examples:
+          rigor skill list
+          rigor skill print rigor-project-init
+          rigor skill path  rigor-baseline-reduce
+      USAGE
+
+      # The bundled skills live at `<gem_root>/skills/`. From
+      # `lib/rigor/cli/skill_command.rb` that is three directories up.
+      SKILLS_ROOT = File.expand_path("../../../skills", __dir__)
+
+      def initialize(argv:, out: $stdout, err: $stderr)
+        @argv = argv
+        @out = out
+        @err = err
+      end
+
+      # @return [Integer] CLI exit status.
+      def run
+        subcommand = @argv.shift || "list"
+
+        case subcommand
+        when "list" then run_list
+        when "print" then run_print
+        when "path" then run_path
+        when "-h", "--help", "help"
+          print_usage(@out)
+          0
+        else
+          @err.puts("Unknown subcommand: #{subcommand}")
+          print_usage(@err)
+          Rigor::CLI::EXIT_USAGE
+        end
+      end
+
+      private
+
+      def run_list
+        skills = discover_skills
+        if skills.empty?
+          @err.puts("No bundled skills found under #{SKILLS_ROOT}")
+          return 1
+        end
+
+        width = skills.map { |s| s.fetch(:name).length }.max
+        skills.each do |skill|
+          @out.puts(format("%-#{width}s  %s", skill.fetch(:name), skill.fetch(:path)))
+        end
+        0
+      end
+
+      def run_print
+        name = @argv.shift
+        return usage_error("`print` requires a skill name") if name.nil?
+
+        skill = find_skill(name)
+        return name_error(name) if skill.nil?
+
+        @out.puts(render_print_header(skill))
+        @out.puts
+        @out.write(File.read(skill.fetch(:path)))
+        0
+      end
+
+      def run_path
+        name = @argv.shift
+        return usage_error("`path` requires a skill name") if name.nil?
+
+        skill = find_skill(name)
+        return name_error(name) if skill.nil?
+
+        @out.puts(skill.fetch(:path))
+        0
+      end
+
+      # The header that precedes the SKILL.md body when an agent
+      # runs `rigor skill print <name>`. Kept as `# `-prefixed
+      # comment lines so the combined output remains parseable as
+      # markdown — anything below `---` (the SKILL frontmatter
+      # marker) is unchanged.
+      def render_print_header(skill)
+        references_dir = File.join(File.dirname(skill.fetch(:path)), "references")
+        ref_line = if File.directory?(references_dir)
+                     "# References: #{references_dir}/  (read referenced `references/NN-*.md` files from here)"
+                   else
+                     "# References: (none)"
+                   end
+        <<~HEADER.chomp
+          # Rigor skill: #{skill.fetch(:name)}
+          # Source:     #{skill.fetch(:path)}
+          #{ref_line}
+          #
+          # The body below is the canonical SKILL definition shipped with
+          # rigortype #{Rigor::VERSION}. Follow its instructions.
+        HEADER
+      end
+
+      def discover_skills
+        return [] unless File.directory?(SKILLS_ROOT)
+
+        Dir.children(SKILLS_ROOT).sort.filter_map do |name|
+          skill_md = File.join(SKILLS_ROOT, name, "SKILL.md")
+          next unless File.file?(skill_md)
+
+          { name: name, path: skill_md }
+        end
+      end
+
+      def find_skill(name)
+        discover_skills.find { |s| s.fetch(:name) == name }
+      end
+
+      def name_error(name)
+        @err.puts("Unknown skill: #{name}")
+        @err.puts("Available skills:")
+        discover_skills.each { |s| @err.puts("  #{s.fetch(:name)}") }
+        1
+      end
+
+      def usage_error(message)
+        @err.puts(message)
+        print_usage(@err)
+        Rigor::CLI::EXIT_USAGE
+      end
+
+      def print_usage(io)
+        io.puts(USAGE)
+      end
+    end
+  end
+end

data/lib/rigor/cli.rb

@@ -32,7 +32,9 @@ module Rigor
       "baseline" => :run_baseline,
       "triage" => :run_triage,
       "coverage" => :run_coverage,
-      "playground" => :run_playground
+      "plugins" => :run_plugins,
+      "playground" => :run_playground,
+      "skill" => :run_skill
     }.freeze
 
     def self.start(argv = ARGV, out: $stdout, err: $stderr)
@@ -475,9 +477,29 @@ module Rigor
 
       File.write(path, init_template)
       @out.puts("Created #{path}")
+      print_init_next_steps(path)
       0
     end
 
+    # `rigor init`'s template ships empty `plugins:` so a fresh
+    # init has nothing to validate — but the moment the user adds
+    # any plugin entry, the activation-failure surfaces enumerated
+    # in `rigor plugins`'s docstring become real. Point them at
+    # the verification command + the canonical readiness flow so
+    # silent failures (the cwd / Gemfile / signature_paths
+    # mismatches that surfaced during the Mastodon trial) get
+    # caught the first time the user wires a plugin, not the first
+    # time `rigor check` reports false positives that should have
+    # been covered.
+    def print_init_next_steps(path)
+      @out.puts ""
+      @out.puts "Next steps:"
+      @out.puts "  1. Edit #{path} — add the `plugins:` your project needs."
+      @out.puts "  2. Run `rigor plugins` to verify every configured plugin loads."
+      @out.puts "     (`--strict` exits 1 on failure; ideal CI gate.)"
+      @out.puts "  3. Run `rigor check` to analyse your code."
+    end
+
     # Renders the starter `.rigor.yml` body. The template
     # serialises `Configuration::DEFAULTS` (so the on-disk file
     # round-trips through `Configuration.load`) and prepends a
@@ -597,6 +619,12 @@ module Rigor
       CLI::CoverageCommand.new(argv: @argv, out: @out, err: @err).run
     end
 
+    def run_plugins
+      require_relative "cli/plugins_command"
+
+      CLI::PluginsCommand.new(argv: @argv, out: @out, err: @err).run
+    end
+
     def run_playground
       begin
         require "rigor/playground"
@@ -608,6 +636,12 @@ module Rigor
       Rigor::CLI::PlaygroundCommand.new(@argv[1..], @out, @err).run
     end
 
+    def run_skill
+      require_relative "cli/skill_command"
+
+      CLI::SkillCommand.new(argv: @argv, out: @out, err: @err).run
+    end
+
     def write_result(result, format)
       case format
       when "json"
@@ -653,7 +687,9 @@ module Rigor
           mcp        Run the Rigor MCP server over stdio (ADR-33)
           triage     Summarise diagnostics: distribution, hotspots, hints (ADR-23)
           coverage   Report type-precision coverage (precise vs Dynamic ratio)
+          plugins    Report activation status of every configured plugin
           playground Start the browser playground (requires rigor-playground gem)
+          skill      List or print bundled Agent Skills (rigor-project-init, ...)
           version    Print the Rigor version
           help       Print this help
       HELP

data/lib/rigor/configuration/severity_profile.rb

@@ -39,6 +39,7 @@ module Rigor
       PROFILES = {
         lenient: {
           "call.undefined-method" => :error,
+          "call.unresolved-toplevel" => :off,
           "call.wrong-arity" => :error,
           "call.argument-type-mismatch" => :warning,
           "call.possible-nil-receiver" => :warning,
@@ -54,6 +55,7 @@ module Rigor
         }.freeze,
         balanced: {
           "call.undefined-method" => :error,
+          "call.unresolved-toplevel" => :warning,
           "call.wrong-arity" => :error,
           "call.argument-type-mismatch" => :error,
           "call.possible-nil-receiver" => :error,
@@ -69,6 +71,7 @@ module Rigor
         }.freeze,
         strict: {
           "call.undefined-method" => :error,
+          "call.unresolved-toplevel" => :error,
           "call.wrong-arity" => :error,
           "call.argument-type-mismatch" => :error,
           "call.possible-nil-receiver" => :error,

data/lib/rigor/inference/block_parameter_binder.rb

@@ -106,6 +106,8 @@ module Rigor
         params_node = params_root.parameters
         return {} if params_node.nil?
 
+        apply_auto_splat(params_node)
+
         bindings = {}
         bind_positionals(params_node, bindings, 0)
         bind_rest(params_node, bindings)
@@ -115,6 +117,39 @@ module Rigor
         bindings
       end
 
+      # Ruby blocks (NOT lambdas) auto-splat a single yielded
+      # Tuple-shaped value when the block declares more than one
+      # required positional parameter:
+      #
+      #   { a: 1 }.each { |k, v| ... }
+      #
+      # yields `[key, value]` as a single arg, but the two-param
+      # block sees `k = key, v = value`. RBS / IteratorDispatch
+      # encode this as the block taking ONE `[K, V]` Tuple
+      # parameter; without this fix-up the binder would assign
+      # `k = Tuple[K, V]` and `v = Dynamic[Top]`, and any call
+      # on `k.<method-not-on-Tuple>` would false-fire.
+      #
+      # The rule fires only when (a) the receiver yields exactly
+      # one value (`expected_param_types.size == 1`), (b) the
+      # block declares more than one positional slot, and (c)
+      # that single expected element is a Tuple. Multi-arg yields
+      # (e.g. `each_with_index`'s `(element, index)` pair) are
+      # NOT auto-splatted — matching Ruby semantics where a
+      # multi-arg yield to a `|a, b, c|` block fills the extra
+      # slot with nil rather than splatting any element.
+      def apply_auto_splat(params_node)
+        return unless @expected_param_types.size == 1
+
+        pos_count = params_node.requireds.size + params_node.optionals.size + params_node.posts.size
+        return unless pos_count > 1
+
+        first = @expected_param_types[0]
+        return unless first.is_a?(Type::Tuple)
+
+        @expected_param_types = first.elements
+      end
+
       def bind_positionals(params_node, bindings, cursor)
         cursor = bind_required_positionals(params_node, bindings, cursor)
         cursor = bind_optional_positionals(params_node, bindings, cursor)

data/lib/rigor/inference/expression_typer.rb

@@ -6,6 +6,7 @@ require_relative "../type"
 require_relative "../ast"
 require_relative "block_parameter_binder"
 require_relative "fallback"
+require_relative "indexed_narrowing"
 require_relative "macro_block_self_type"
 require_relative "method_dispatcher"
 require_relative "narrowing"
@@ -1133,6 +1134,69 @@ module Rigor
         type_of(body.last)
       end
 
+      # Indexed-collection narrowing — `receiver[key]` after a
+      # prior `receiver[key] ||= default` reads the post-`||=`
+      # type when the receiver and key are stable enough to
+      # address. Sits ahead of `MethodDispatcher.dispatch` so
+      # the standard `Hash#[]` / `Array#[]` answer (which would
+      # fold to `Constant[nil]` for an empty `HashShape{}` or
+      # `Tuple[]`) does not override the narrowing. See
+      # {Inference::IndexedNarrowing}.
+      def indexed_narrowing_for(node)
+        IndexedNarrowing.lookup_for_call(node, scope) || method_chain_narrowing_for(node)
+      end
+
+      # Stable single-hop chain narrowing — `receiver.method`
+      # after an `is_a?` / `kind_of?` / `instance_of?` predicate
+      # established the narrowing on the dominated edge. The
+      # call MUST be no-arg + no-block + rooted at a local-var /
+      # ivar read; everything else falls through to the
+      # standard dispatcher. ROADMAP § Future cycles —
+      # "Method-call receiver narrowing across stable
+      # receivers" — Law-of-Demeter-justified single-hop scope.
+      def method_chain_narrowing_for(node)
+        return nil unless node.is_a?(Prism::CallNode)
+        return nil unless node.block.nil?
+        return nil unless node.arguments.nil? || node.arguments.arguments.empty?
+
+        case node.receiver
+        when Prism::LocalVariableReadNode
+          scope.method_chain_narrowing(:local, node.receiver.name, node.name)
+        when Prism::InstanceVariableReadNode
+          scope.method_chain_narrowing(:ivar, node.receiver.name, node.name)
+        end
+      end
+
+      # v0.0.3 A — implicit-self calls prefer a same-named
+      # top-level `def` over RBS dispatch. Without this,
+      # a helper like `def select(...)` defined inside an
+      # `RSpec.describe ... do ... end` block mis-routes
+      # through `Enumerable#select` / `Object#select` and
+      # the caller observes `Array[Elem]` instead of the
+      # helper's actual return type. The check fires only
+      # for `node.receiver.nil?` (true implicit self), so
+      # explicit-receiver dispatch is unaffected.
+      def try_local_def_dispatch(node, receiver, arg_types)
+        local_def = node.receiver.nil? ? scope.top_level_def_for(node.name) : nil
+        return nil unless local_def
+
+        local_inference = infer_top_level_user_method(local_def, receiver, arg_types)
+        return local_inference if local_inference && adoptable_self_call_result?(local_inference)
+
+        # The local def matches by name but the inference was
+        # disqualified — either the parameter shape is too complex
+        # for the first-iteration binder (kwargs / optionals /
+        # rest), or ADR-24 slice 1's conservative gate declined
+        # the resolved return type inside a class body (see
+        # `adoptable_self_call_result?`). `Dynamic[Top]` is the
+        # safest answer: RBS dispatch would be wrong (the method
+        # is user-defined and shadows whatever ancestor method the
+        # dispatch would find), and `Dynamic[Top]` propagates
+        # correctly through downstream call chains without
+        # surfacing misleading false-positive diagnostics.
+        dynamic_top
+      end
+
       # Slice 2 routes call expressions through `MethodDispatcher`. The
       # receiver and every argument are typed first, then the dispatcher is
       # asked for a result type. A nil result triggers the fail-soft fallback
@@ -1140,40 +1204,15 @@ module Rigor
       # their own fallbacks for unrecognised receivers/args, so the tracer
       # captures both the immediate dispatch miss and the deeper cause).
       def call_type_for(node)
+        narrowed = indexed_narrowing_for(node)
+        return narrowed if narrowed
+
         receiver = call_receiver_type_for(node)
         arg_types = call_arg_types(node)
         block_type = block_return_type_for(node, receiver, arg_types)
 
-        # v0.0.3 A — implicit-self calls prefer a same-named
-        # top-level `def` over RBS dispatch. Without this,
-        # a helper like `def select(...)` defined inside an
-        # `RSpec.describe ... do ... end` block mis-routes
-        # through `Enumerable#select` / `Object#select` and
-        # the caller observes `Array[Elem]` instead of the
-        # helper's actual return type. The check fires only
-        # for `node.receiver.nil?` (true implicit self), so
-        # explicit-receiver dispatch is unaffected.
-        local_def = node.receiver.nil? ? scope.top_level_def_for(node.name) : nil
-        if local_def
-          local_inference = infer_top_level_user_method(local_def, receiver, arg_types)
-          return local_inference if local_inference && adoptable_self_call_result?(local_inference)
-
-          # The local def matches by name but the inference
-          # was disqualified — either the parameter shape is
-          # too complex for the first-iteration binder
-          # (kwargs / optionals / rest), or ADR-24 slice 1's
-          # conservative gate declined the resolved return
-          # type inside a class body (see
-          # `adoptable_self_call_result?`).
-          # Returning `Dynamic[Top]` is the safest answer:
-          # we know RBS dispatch would be wrong (the
-          # method is user-defined and shadows whatever
-          # ancestor method the dispatch would find), and
-          # `Dynamic[Top]` propagates correctly through
-          # downstream call chains without surfacing
-          # misleading false-positive diagnostics.
-          return dynamic_top
-        end
+        local_def_result = try_local_def_dispatch(node, receiver, arg_types)
+        return local_def_result if local_def_result
 
         # v0.0.6 phase 2 — per-element block fold for Tuple
         # receivers. When `[a, b, c].map { |x| f(x) }` and the