rigortype 0.1.15 → 0.1.17

data/lib/rigor/cli/plugins_command.rb

@@ -9,6 +9,7 @@ require_relative "../plugin/services"
 require_relative "../reflection"
 require_relative "../type/combinator"
 require_relative "plugins_renderer"
+require_relative "command"
 
 module Rigor
   class CLI
@@ -32,7 +33,15 @@ module Rigor
     #   `trait_registries:` / `external_files:` /
     #   `type_node_resolvers:` / `hkt_registrations:` /
     #   `hkt_definitions:` / `protocol_contracts:` /
-    #   `source_rbs_synthesizer:`).
+    #   `source_rbs_synthesizer:`);
+    # - the ADR-37 narrow extension protocols read off the plugin
+    #   class — `node_rule` node types, `dynamic_return` receivers,
+    #   `type_specifier` methods.
+    #
+    # `--capabilities` switches to a focused catalogue of just the
+    # narrow-protocol gate values + produced/consumed facts (ADR-37
+    # § "Machine-readable capability catalogue") — the AI-legibility
+    # surface that lets an agent enumerate what every plugin does.
     #
     # Output formats: `text` (default, human-readable table) and
     # `json` (for tooling — SKILLs, CI gates, editor integrations).
@@ -52,15 +61,9 @@ module Rigor
     #   the RBS environment without conflict (requires constructing
     #   the Environment, which is heavier than the loader-only
     #   pass this slice does).
-    class PluginsCommand
+    class PluginsCommand < Command # rubocop:disable Metrics/ClassLength
       USAGE = "Usage: rigor plugins [options]"
 
-      def initialize(argv:, out: $stdout, err: $stderr)
-        @argv = argv
-        @out = out
-        @err = err
-      end
-
       # @return [Integer] CLI exit status.
       def run
         options = parse_options
@@ -69,7 +72,7 @@ module Rigor
         rows = build_rows(configuration)
 
         renderer = PluginsRenderer.new(rows: rows, configuration_path: config_path)
-        @out.puts(options.fetch(:format) == "json" ? renderer.json : renderer.text)
+        @out.puts(render(renderer, options))
 
         any_load_errors = rows.any? { |row| row.fetch(:status) == :load_error }
         return 1 if any_load_errors && options.fetch(:strict)
@@ -79,13 +82,32 @@ module Rigor
 
       private
 
+      # Picks the renderer view. `--capabilities` switches to the
+      # focused extension-protocol catalogue (ADR-37 § "Machine-readable
+      # capability catalogue") — per plugin, only the gate values that
+      # tell a reader (or an AI agent) exactly what the plugin
+      # contributes: the node-rule node types, the dynamic-return
+      # receivers, the type-specifier methods, and the produced /
+      # consumed facts. The default view stays the full activation report.
+      def render(renderer, options)
+        json = options.fetch(:format) == "json"
+        if options.fetch(:capabilities)
+          json ? renderer.capabilities_json : renderer.capabilities_text
+        else
+          json ? renderer.json : renderer.text
+        end
+      end
+
       def parse_options
-        options = { config: nil, format: "text", strict: false }
+        options = { config: nil, format: "text", strict: false, capabilities: false }
         OptionParser.new do |opts|
           opts.banner = USAGE
           opts.on("--config=PATH", "Path to the Rigor configuration file") { |v| options[:config] = v }
           opts.on("--format=FORMAT", "Output format: text (default) or json") { |v| options[:format] = v }
           opts.on("--strict", "Exit 1 if any plugin failed to load (CI gate)") { options[:strict] = true }
+          opts.on("--capabilities", "Emit the per-plugin extension-protocol catalogue (ADR-37)") do
+            options[:capabilities] = true
+          end
         end.parse!(@argv)
         validate!(options)
         options
@@ -165,9 +187,25 @@ module Rigor
         manifest = plugin.manifest
         identity_fields(gem_name, manifest, config)
           .merge(extension_fields(plugin, manifest))
+          .merge(narrow_protocol_fields(plugin))
           .merge(load_error: nil)
       end
 
+      # ADR-37 narrow extension protocols. Unlike the 10 declarative
+      # manifest fields, these are class-level DSLs (`node_rule` /
+      # `dynamic_return` / `type_specifier`), so they are read off the
+      # plugin class rather than the manifest. The gate values — node
+      # types, receiver class names, specified method names — are the
+      # greppable, enumerable surface the capability catalogue exposes.
+      def narrow_protocol_fields(plugin)
+        klass = plugin.class
+        {
+          node_rule_types: klass.node_rules.map { |r| r[:node_type].name }.uniq,
+          dynamic_return_receivers: klass.dynamic_returns.flat_map { |r| r[:receivers] }.uniq,
+          type_specifier_methods: klass.type_specifiers.flat_map { |r| r[:methods] }.map(&:to_s).uniq
+        }
+      end
+
       def identity_fields(gem_name, manifest, config)
         {
           gem: gem_name,
@@ -225,6 +263,9 @@ module Rigor
           hkt_definitions: 0,
           protocol_contracts: 0,
           source_rbs_synthesizer: false,
+          node_rule_types: [],
+          dynamic_return_receivers: [],
+          type_specifier_methods: [],
           load_error: error&.message || "plugin did not register or could not be matched to a registered class"
         }
       end
@@ -299,6 +340,7 @@ module Rigor
             external_files: 0, type_node_resolvers: 0,
             hkt_registrations: 0, hkt_definitions: 0,
             protocol_contracts: 0, source_rbs_synthesizer: false,
+            node_rule_types: [], dynamic_return_receivers: [], type_specifier_methods: [],
             load_error: error.message
           }
         end

data/lib/rigor/cli/plugins_renderer.rb

@@ -13,7 +13,7 @@ module Rigor
     # tooling (SKILLs, CI, editor integrations) while text is
     # for interactive inspection. Rows are printed in the order
     # the loader resolved them.
-    class PluginsRenderer
+    class PluginsRenderer # rubocop:disable Metrics/ClassLength
       def initialize(rows:, configuration_path:)
         @rows = rows
         @configuration_path = configuration_path
@@ -42,8 +42,74 @@ module Rigor
         )
       end
 
+      # ADR-37 § "Machine-readable capability catalogue" — the focused
+      # per-plugin extension-protocol dump. Only loaded plugins appear
+      # (a plugin that failed to load contributes no capabilities), and
+      # each carries only the gate values an agent enumerates to learn
+      # what the plugin does: node-rule node types, dynamic-return
+      # receivers, type-specifier methods, and produced / consumed facts.
+      def capabilities_json
+        JSON.pretty_generate(
+          {
+            "configuration" => @configuration_path,
+            "capabilities" => loaded_rows.map { |row| capabilities_json_for(row) }
+          }
+        )
+      end
+
+      def capabilities_text
+        lines = ["Plugin capability catalogue (ADR-37 narrow extension protocols)", ""]
+        loaded = loaded_rows
+        if loaded.empty?
+          lines << "  (no plugins loaded)"
+        else
+          loaded.each_with_index do |row, index|
+            lines.concat(capability_lines(row))
+            lines << "" unless index == loaded.size - 1
+          end
+        end
+        lines.join("\n")
+      end
+
       private
 
+      def loaded_rows
+        @rows.select { |r| r[:status] == :loaded }
+      end
+
+      def capability_lines(row)
+        lines = ["  #{row[:id]}  v#{row[:version]}  (#{row[:gem]})"]
+        capability_surfaces(row).each { |surface| lines << "        #{surface}" }
+        lines << "        (no narrow extension protocols declared)" if lines.size == 1
+        lines
+      end
+
+      # The non-empty capability surfaces for a plugin, each as a
+      # `label: a, b, c` string. Data-driven so the catalogue stays a
+      # single source of truth shared between the text and JSON views.
+      def capability_surfaces(row)
+        [
+          ["node_rule", row[:node_rule_types]],
+          ["dynamic_return receivers", row[:dynamic_return_receivers]],
+          ["type_specifier methods", row[:type_specifier_methods]],
+          ["produces", row[:produces]],
+          ["consumes", row[:consumes]]
+        ].filter_map { |label, values| "#{label}: #{values.join(', ')}" if values.any? }
+      end
+
+      def capabilities_json_for(row)
+        {
+          "id" => row[:id],
+          "gem" => row[:gem],
+          "version" => row[:version],
+          "node_rule_types" => row[:node_rule_types],
+          "dynamic_return_receivers" => row[:dynamic_return_receivers],
+          "type_specifier_methods" => row[:type_specifier_methods],
+          "produces" => row[:produces],
+          "consumes" => row[:consumes]
+        }
+      end
+
       def header
         loaded = @rows.count { |r| r[:status] == :loaded }
         errored = @rows.count { |r| r[:status] == :load_error }
@@ -99,6 +165,22 @@ module Rigor
         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.concat(narrow_protocol_lines(row))
+        lines
+      end
+
+      # ADR-37 narrow extension protocols (node_rule / dynamic_return /
+      # type_specifier). Surfaced in the full report alongside the
+      # declarative surfaces; `--capabilities` is the focused view.
+      def narrow_protocol_lines(row)
+        lines = []
+        lines << "        node_rule: #{row[:node_rule_types].join(', ')}" if row[:node_rule_types].any?
+        if row[:dynamic_return_receivers].any?
+          lines << "        dynamic_return receivers: #{row[:dynamic_return_receivers].join(', ')}"
+        end
+        if row[:type_specifier_methods].any?
+          lines << "        type_specifier methods: #{row[:type_specifier_methods].join(', ')}"
+        end
         lines
       end
 
@@ -157,6 +239,9 @@ module Rigor
           "hkt_definitions" => row[:hkt_definitions],
           "protocol_contracts" => row[:protocol_contracts],
           "source_rbs_synthesizer" => row[:source_rbs_synthesizer],
+          "node_rule_types" => row[:node_rule_types],
+          "dynamic_return_receivers" => row[:dynamic_return_receivers],
+          "type_specifier_methods" => row[:type_specifier_methods],
           "load_error" => row[:load_error]
         }
       end

data/lib/rigor/cli/renderable.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "optionparser"
+
+module Rigor
+  class CLI
+    # Output-format dispatch shared by the `--format text|json` renderers.
+    #
+    # Each renderer included this and then implemented `render_text` /
+    # `render_json`; the `render(data, format:)` entry point — route by
+    # the format string, raise one consistent `OptionParser::InvalidArgument`
+    # on anything else — was copied verbatim into every one. Centralising
+    # it keeps the unsupported-format wording and the text/json contract
+    # in a single place as new renderers and formats are added.
+    module Renderable
+      def render(data, format:)
+        case format
+        when "text" then render_text(data)
+        when "json" then render_json(data)
+        else
+          raise OptionParser::InvalidArgument, "unsupported format: #{format}"
+        end
+      end
+    end
+  end
+end

data/lib/rigor/cli/sig_gen_command.rb

@@ -4,6 +4,7 @@ require "optionparser"
 
 require_relative "../configuration"
 require_relative "../sig_gen"
+require_relative "command"
 
 module Rigor
   class CLI
@@ -34,19 +35,13 @@ module Rigor
     # `--params=observed-strict` stays reserved-but-inert until
     # the capability-role catalog ships (rejected with a usage
     # error so the surface stays stable).
-    class SigGenCommand
+    class SigGenCommand < Command
       USAGE = "Usage: rigor sig-gen [options] [paths]"
 
       VALID_MODES = %w[print diff write].freeze
       VALID_PARAM_POLICIES = %w[untyped observed observed-strict].freeze
       VALID_FORMATS = %w[text json].freeze
 
-      def initialize(argv:, out:, err:)
-        @argv = argv
-        @out = out
-        @err = err
-      end
-
       # @return [Integer] CLI exit status.
       def run
         options = parse_options

data/lib/rigor/cli/skill_command.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "command"
+
 require "optparse"
 
 module Rigor
@@ -29,7 +31,7 @@ module Rigor
     #                                as input to a Read tool.
     #
     # `rigor skill` with no subcommand is an alias for `list`.
-    class SkillCommand
+    class SkillCommand < Command
       USAGE = <<~USAGE
         Usage: rigor skill <subcommand> [args]
 
@@ -48,12 +50,6 @@ module Rigor
       # `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"

data/lib/rigor/cli/triage_command.rb

@@ -7,6 +7,7 @@ require_relative "../analysis/runner"
 require_relative "../cache/store"
 require_relative "../triage"
 require_relative "triage_renderer"
+require_relative "command"
 
 module Rigor
   class CLI
@@ -18,16 +19,10 @@ module Rigor
     # 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
+    class TriageCommand < Command
       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

data/lib/rigor/cli/type_of_command.rb

@@ -11,6 +11,8 @@ require_relative "../source/node_locator"
 require_relative "../inference/fallback_tracer"
 require_relative "../inference/scope_indexer"
 require_relative "type_of_renderer"
+require_relative "command"
+require_relative "options"
 
 module Rigor
   class CLI
@@ -25,21 +27,15 @@ module Rigor
     # dispatching and lets us evolve the type-of UX (extra flags, watch mode,
     # streaming output) without bloating the CLI shell. Output formatting is
     # delegated to {TypeOfRenderer}.
-    class TypeOfCommand
+    class TypeOfCommand < Command
       USAGE = "Usage: rigor type-of [options] FILE:LINE:COL"
 
       Result = Data.define(:file, :line, :column, :node, :type, :tracer)
 
-      def initialize(argv:, out:, err:)
-        @argv = argv
-        @out = out
-        @err = err
-      end
-
       # @return [Integer] CLI exit status.
       def run
         options = parse_options
-        buffer = resolve_buffer_binding(options)
+        buffer = Options.resolve_buffer_binding(options, err: @err)
         return CLI::EXIT_USAGE if buffer == :usage_error
 
         target = parse_position_argument(@argv)
@@ -58,42 +54,13 @@ module Rigor
           opts.on("--format=FORMAT", "Output format: text or json") { |value| options[:format] = value }
           opts.on("--trace", "Record fail-soft fallbacks via FallbackTracer") { options[:trace] = true }
           opts.on("--config=PATH", "Path to the Rigor configuration file") { |value| options[:config] = value }
-          opts.on("--tmp-file=PATH",
-                  "Editor mode: read source bytes from PATH instead of --instead-of (paired)") do |value|
-            options[:tmp_file] = value
-          end
-          opts.on("--instead-of=PATH",
-                  "Editor mode: the logical project path the buffer represents (paired with --tmp-file)") do |value|
-            options[:instead_of] = value
-          end
+          Options.add_editor_mode(opts, options)
         end
         parser.parse!(@argv)
 
         options
       end
 
-      # Mirrors `Rigor::CLI#resolve_buffer_binding` (the `check`
-      # path). Returns nil / BufferBinding / :usage_error. The
-      # symbol return path lets the caller translate to
-      # `CLI::EXIT_USAGE` without raising.
-      def resolve_buffer_binding(options)
-        tmp = options[:tmp_file]
-        instead = options[:instead_of]
-        return nil if tmp.nil? && instead.nil?
-
-        if tmp.nil? || instead.nil?
-          @err.puts("--tmp-file and --instead-of must appear together")
-          return :usage_error
-        end
-
-        unless File.file?(tmp)
-          @err.puts("--tmp-file #{tmp.inspect}: no such file or not readable")
-          return :usage_error
-        end
-
-        Rigor::Analysis::BufferBinding.new(logical_path: instead, physical_path: tmp)
-      end
-
       def execute(target:, options:, buffer: nil)
         file, line, column = target
         # Under editor mode the logical `file` may not exist on disk

data/lib/rigor/cli/type_of_renderer.rb

@@ -3,6 +3,8 @@
 require "json"
 require "optionparser"
 
+require_relative "renderable"
+
 module Rigor
   class CLI
     # Renders a `TypeOfCommand::Result` as either human-readable text or a
@@ -12,19 +14,12 @@ module Rigor
     # output formats (sexp, lsp-style hover payloads, color decoration) can
     # plug in without disturbing argument parsing or the inference call site.
     class TypeOfRenderer
+      include Renderable
+
       def initialize(out:)
         @out = out
       end
 
-      def render(result, format:)
-        case format
-        when "text" then render_text(result)
-        when "json" then render_json(result)
-        else
-          raise OptionParser::InvalidArgument, "unsupported format: #{format}"
-        end
-      end
-
       private
 
       def render_text(result)

data/lib/rigor/cli/type_scan_command.rb

@@ -9,6 +9,7 @@ require_relative "../inference/coverage_scanner"
 require_relative "../scope"
 require_relative "type_scan_renderer"
 require_relative "type_scan_report"
+require_relative "command"
 
 module Rigor
   class CLI
@@ -19,21 +20,15 @@ module Rigor
     # the inference engine's directly recognized classes. It is the project's
     # primary CI gate for tracking how much of an input source the engine can
     # name without falling back to `Dynamic[Top]`.
-    class TypeScanCommand
+    class TypeScanCommand < Command
       USAGE = "Usage: rigor type-scan [options] PATH..."
 
       LocatedEvent = Data.define(:file, :event)
 
-      def initialize(argv:, out:, err:)
-        @argv = argv
-        @out = out
-        @err = err
-      end
-
       # @return [Integer] CLI exit status.
       def run
         options = parse_options
-        paths = collect_paths(@argv)
+        paths = collect_paths(@argv, command_name: "type-scan")
         return CLI::EXIT_USAGE if paths.nil?
         return usage_error if paths.empty?
 
@@ -67,21 +62,6 @@ module Rigor
         options
       end
 
-      def collect_paths(args)
-        paths = []
-        args.each do |arg|
-          if File.directory?(arg)
-            paths.concat(Dir.glob(File.join(arg, "**/*.rb")))
-          elsif File.file?(arg)
-            paths << arg
-          else
-            @err.puts("type-scan: not a file or directory: #{arg}")
-            return nil
-          end
-        end
-        paths.uniq
-      end
-
       def usage_error
         @err.puts("type-scan: at least one path is required")
         @err.puts(USAGE)

data/lib/rigor/cli/type_scan_renderer.rb

@@ -3,6 +3,8 @@
 require "json"
 require "optionparser"
 
+require_relative "renderable"
+
 module Rigor
   class CLI
     # Renders a `TypeScanCommand::Report` as either a terminal-friendly text
@@ -11,19 +13,12 @@ module Rigor
     # the two formats stay in lockstep; that pairing is why this class is a
     # bit longer than the default class-length budget.
     class TypeScanRenderer
+      include Renderable
+
       def initialize(out:)
         @out = out
       end
 
-      def render(report, format:)
-        case format
-        when "text" then render_text(report)
-        when "json" then render_json(report)
-        else
-          raise OptionParser::InvalidArgument, "unsupported format: #{format}"
-        end
-      end
-
       private
 
       def render_text(report)