rigortype 0.1.0 → 0.1.2

data/lib/rigor/plugin/load_error.rb

@@ -11,12 +11,24 @@ module Rigor
     # to be isolated at the analyzer boundary; this class is the
     # carrier for that contract on the loading side.
     class LoadError < StandardError
-      attr_reader :plugin_ref, :cause_class
+      attr_reader :plugin_ref, :cause_class, :reason
 
-      def initialize(message, plugin_ref:, cause: nil)
+      # ADR-9 slice 5 introduces two new reason codes alongside the
+      # implicit "load failure" used for require / configuration /
+      # init failures:
+      #
+      #   - `:missing-producer` — a non-optional `manifest(consumes:)`
+      #     entry names a `(plugin_id, name)` no loaded plugin
+      #     produces.
+      #   - `:dependency-cycle` — the consumes graph forms a cycle.
+      #
+      # Older callers omit `reason:` and the field defaults to nil
+      # (the legacy "load failure" envelope).
+      def initialize(message, plugin_ref:, cause: nil, reason: nil)
         super(message)
         @plugin_ref = plugin_ref
         @cause_class = cause&.class
+        @reason = reason&.to_sym
       end
     end
   end

data/lib/rigor/plugin/loader.rb

@@ -63,6 +63,15 @@ module Rigor
           end
         end
 
+        # ADR-9 slice 5 — topological sort by `manifest(consumes:)`
+        # so producers run before consumers, plus early
+        # `missing-producer` validation. Cycles surface as
+        # `dependency-cycle` LoadErrors. When validation fails, the
+        # offending plugin(s) drop from the returned plugins list
+        # and the LoadError surfaces alongside any earlier failure.
+        plugins, sort_errors = topo_sort_plugins(plugins)
+        load_errors.concat(sort_errors)
+
         Registry.new(plugins: plugins, load_errors: load_errors)
       end
 
@@ -186,6 +195,113 @@ module Rigor
       rescue StandardError
         plugin_class.to_s
       end
+
+      # ADR-9 slice 5 — topological sort of plugins by their
+      # `manifest(consumes:)` declarations. Returns `[sorted_plugins,
+      # load_errors]`. Determinism: when no dependency relation
+      # forces an order, plugins are visited alphabetically by
+      # manifest id. A non-optional consume of a `(plugin_id, name)`
+      # whose producer is missing emits a `:missing-producer`
+      # LoadError and drops the consumer; cycles emit a
+      # `:dependency-cycle` LoadError naming the offending chain.
+      def topo_sort_plugins(plugins)
+        # If no plugin opts into the cross-plugin API the loader's
+        # legacy configuration-order contract is preserved
+        # unchanged. Topo sort and missing-producer validation only
+        # run when at least one plugin declares `consumes:`.
+        return [plugins, []] unless plugins.any? { |p| p.manifest.consumes.any? }
+
+        index = plugins.to_h { |plugin| [plugin.manifest.id, plugin] }
+        errors = validate_missing_producers(plugins, index)
+        sortable = plugins.reject { |p| errors.any? { |e| e.plugin_ref == p.manifest.id } }
+        config_order = plugins.each_with_index.to_h { |plugin, i| [plugin.manifest.id, i] }
+
+        sort_in_topo_order(sortable, index, errors, config_order)
+      end
+
+      def validate_missing_producers(plugins, index)
+        errors = []
+        plugins.each do |plugin|
+          plugin.manifest.consumes.each do |consume|
+            next if consume.optional
+            next if index.key?(consume.plugin_id) && producer_provides?(index[consume.plugin_id], consume.name)
+
+            errors << LoadError.new(
+              "plugin #{plugin.manifest.id.inspect} consumes " \
+              "#{consume.plugin_id.inspect}/#{consume.name} but no loaded plugin " \
+              "with that id declares `produces: [#{consume.name.inspect}]`",
+              plugin_ref: plugin.manifest.id,
+              reason: :"missing-producer"
+            )
+          end
+        end
+        errors
+      end
+
+      def producer_provides?(producer, name)
+        producer.manifest.produces.include?(name)
+      end
+
+      # Kahn's algorithm with `Configuration#plugins`-order
+      # tie-break. Edges go from producer -> consumer (producer
+      # must visit first). When two plugins are simultaneously
+      # ready, the configuration-order index decides the visit
+      # order — preserves the v0.1.0 legacy contract for plugins
+      # without dependencies.
+      def sort_in_topo_order(plugins, index, errors, config_order)
+        in_degree, forward = build_consumes_graph(plugins, index, errors)
+        ordered, cycle_errors = kahn_walk(plugins, in_degree, forward, config_order)
+        [ordered, errors + cycle_errors]
+      end
+
+      def build_consumes_graph(plugins, index, errors)
+        in_degree = Hash.new(0)
+        forward = Hash.new { |h, k| h[k] = [] }
+        plugins.each do |consumer|
+          consumer.manifest.consumes.each do |consume|
+            next unless index.key?(consume.plugin_id)
+            next if errors.any? { |e| e.plugin_ref == consume.plugin_id }
+
+            forward[consume.plugin_id] << consumer.manifest.id
+            in_degree[consumer.manifest.id] += 1
+          end
+        end
+        [in_degree, forward]
+      end
+
+      def kahn_walk(plugins, in_degree, forward, config_order)
+        order = ->(plugin) { config_order.fetch(plugin.manifest.id, Float::INFINITY) }
+        ready = plugins.select { |p| in_degree[p.manifest.id].zero? }.sort_by(&order)
+        result = kahn_collect(plugins, in_degree, forward, ready, order)
+
+        return [result, []] if result.size == plugins.size
+
+        cycled = plugins - result
+        [result, [dependency_cycle_error(cycled)]]
+      end
+
+      def kahn_collect(plugins, in_degree, forward, ready, order)
+        result = []
+        until ready.empty?
+          plugin = ready.shift
+          result << plugin
+          forward[plugin.manifest.id].each do |consumer_id|
+            in_degree[consumer_id] -= 1
+            ready << plugins.find { |p| p.manifest.id == consumer_id } if in_degree[consumer_id].zero?
+          end
+          ready.sort_by!(&order)
+        end
+        result
+      end
+
+      def dependency_cycle_error(cycled)
+        ids = cycled.map { |p| p.manifest.id }.sort
+        LoadError.new(
+          "plugin dependency cycle through `manifest(consumes:)`: #{ids.inspect}",
+          plugin_ref: ids.first,
+          reason: :"dependency-cycle"
+        )
+      end
     end
   end
 end

data/lib/rigor/plugin/manifest.rb

@@ -11,7 +11,7 @@ module Rigor
     # The fields are pinned by ADR-2 § "Registration, Configuration,
     # and Caching"; the v0.1.0 plugin contract surface treats this
     # struct as the public manifest shape.
-    class Manifest
+    class Manifest # rubocop:disable Metrics/ClassLength
       # Same regex {Rigor::Cache::Store::VALID_PRODUCER_ID} uses,
       # so plugin ids round-trip through cache producer ids and
       # `plugin.<id>.<rule>` diagnostic identifiers without escape.
@@ -23,23 +23,51 @@ module Rigor
       # the v0.1.0 protocol slices need them.
       VALID_VALUE_KINDS = %i[string boolean integer array hash any].freeze
 
-      attr_reader :id, :version, :description, :protocols, :config_schema
+      # ADR-9 slice 4 — declared cross-plugin fact dependencies.
+      # `produces:` lists the names this plugin publishes through
+      # its `#prepare(services)` hook. `consumes:` lists the
+      # `(plugin_id, name)` pairs this plugin reads from
+      # `services.fact_store`. The loader uses both for
+      # topological sort + missing-producer detection (slice 5);
+      # slice 4 carries the declarations on the manifest but the
+      # loader does not yet enforce them.
+      Consumption = Data.define(:plugin_id, :name, :optional) do
+        def initialize(plugin_id:, name:, optional: false)
+          super(plugin_id: plugin_id.to_s, name: name.to_sym, optional: optional ? true : false)
+        end
+      end
 
-      def initialize(id:, version:, description: nil, protocols: [], config_schema: {})
+      attr_reader :id, :version, :description, :protocols, :config_schema, :produces, :consumes
+
+      def initialize( # rubocop:disable Metrics/ParameterLists
+        id:, version:,
+        description: nil, protocols: [], config_schema: {},
+        produces: [], consumes: []
+      )
         validate_id!(id)
         validate_version!(version)
         validate_protocols!(protocols)
         validate_config_schema!(config_schema)
+        validate_produces!(produces)
+
+        assign_fields(id, version, description, protocols, config_schema, produces, consumes)
+        freeze
+      end
+
+      private
 
+      def assign_fields(id, version, description, protocols, config_schema, produces, consumes) # rubocop:disable Metrics/ParameterLists
         @id = id.dup.freeze
         @version = version.dup.freeze
         @description = description.nil? ? nil : description.to_s.dup.freeze
         @protocols = protocols.map(&:to_sym).freeze
         @config_schema = config_schema.to_h { |k, v| [k.to_s.dup.freeze, v.to_sym] }.freeze
-
-        freeze
+        @produces = produces.map(&:to_sym).freeze
+        @consumes = coerce_consumes(consumes)
       end
 
+      public
+
       # Validates the user-supplied plugin config block against this
       # manifest's `config_schema`. Returns an array of human-readable
       # error strings (empty when the config is valid). Slice 1 checks
@@ -69,7 +97,9 @@ module Rigor
           "version" => version,
           "description" => description,
           "protocols" => protocols.map(&:to_s),
-          "config_schema" => config_schema.to_h { |k, v| [k, v.to_s] }
+          "config_schema" => config_schema.to_h { |k, v| [k, v.to_s] },
+          "produces" => produces.map(&:to_s),
+          "consumes" => consumes.map { |c| consumption_hash(c) }
         }
       end
 
@@ -129,6 +159,45 @@ module Rigor
         else false
         end
       end
+
+      def validate_produces!(produces)
+        return if produces.is_a?(Array) && produces.all? { |p| p.is_a?(Symbol) || p.is_a?(String) }
+
+        raise ArgumentError, "plugin manifest produces must be an Array of Symbol/String, got #{produces.inspect}"
+      end
+
+      def coerce_consumes(consumes)
+        unless consumes.is_a?(Array)
+          raise ArgumentError, "plugin manifest consumes must be an Array, got #{consumes.inspect}"
+        end
+
+        consumes.map { |entry| coerce_consumption(entry) }.freeze
+      end
+
+      def coerce_consumption(entry)
+        case entry
+        when Consumption then entry
+        when Hash then build_consumption_from_hash(entry)
+        else raise ArgumentError,
+                   "plugin manifest consumes entry must be a Hash or Consumption, got #{entry.inspect}"
+        end
+      end
+
+      def consumption_hash(consumption)
+        { "plugin_id" => consumption.plugin_id, "name" => consumption.name.to_s, "optional" => consumption.optional }
+      end
+
+      def build_consumption_from_hash(entry)
+        plugin_id = entry[:plugin_id] || entry["plugin_id"]
+        name = entry[:name] || entry["name"]
+        optional = entry.key?(:optional) ? entry[:optional] : entry["optional"]
+        if plugin_id.nil? || name.nil?
+          raise ArgumentError,
+                "plugin manifest consumes entry missing plugin_id/name: #{entry.inspect}"
+        end
+
+        Consumption.new(plugin_id: plugin_id, name: name, optional: optional || false)
+      end
     end
   end
 end

data/lib/rigor/plugin/services.rb

@@ -31,15 +31,27 @@ module Rigor
     # raw `File.read` so reads stay within the trusted scope and
     # feed cache invalidation; ADR-2 § "Plugin Trust and I/O
     # Policy" documents the trust model the boundary enforces.
+    #
+    # ADR-9 slice 2 adds `fact_store`: the per-run cross-plugin
+    # `Plugin::FactStore`. Producer plugins publish their facts
+    # in `#prepare(services)` (slice 3); consumer plugins read in
+    # `#diagnostics_for_file` via `services.fact_store.read(...)`.
+    # A fresh `FactStore` instance is constructed per Services
+    # when none is supplied — the runner threads its own instance
+    # in once slice 3 wires `#prepare` invocation.
     class Services
-      attr_reader :reflection, :type, :configuration, :cache_store, :trust_policy
+      attr_reader :reflection, :type, :configuration, :cache_store, :trust_policy, :fact_store
 
-      def initialize(reflection:, type:, configuration:, cache_store: nil, trust_policy: nil)
+      def initialize( # rubocop:disable Metrics/ParameterLists
+        reflection:, type:, configuration:,
+        cache_store: nil, trust_policy: nil, fact_store: nil
+      )
         @reflection = reflection
         @type = type
         @configuration = configuration
         @cache_store = cache_store
         @trust_policy = trust_policy || default_trust_policy
+        @fact_store = fact_store || FactStore.new
         freeze
       end
 

data/lib/rigor/plugin/trust_policy.rb

@@ -32,15 +32,18 @@ module Rigor
     #   `Gemfile.lock`, and each trusted gem's
     #   `Gem::Specification#full_gem_path`. The user extends this
     #   with `.rigor.yml`'s `plugins_io.allowed_paths:`.
-    # - `network_policy`: `:disabled` in slice 2; the only value
-    #   accepted today. Plugin {IoBoundary#open_url} always raises
-    #   while the policy is `:disabled`.
+    # - `network_policy`: one of {VALID_NETWORK_POLICIES}.
+    #   `:disabled` (default) makes {IoBoundary#open_url} always
+    #   raise. `:allowlist` (v0.1.2) consults `allowed_url_hosts`
+    #   on every fetch — the hostname must be on the list and
+    #   the URL scheme MUST be `https`. The list of allowed hosts
+    #   is exact-match (no wildcards in v0.1.2).
     class TrustPolicy
-      VALID_NETWORK_POLICIES = %i[disabled].freeze
+      VALID_NETWORK_POLICIES = %i[disabled allowlist].freeze
 
-      attr_reader :trusted_gems, :allowed_read_roots, :network_policy
+      attr_reader :trusted_gems, :allowed_read_roots, :network_policy, :allowed_url_hosts
 
-      def initialize(trusted_gems: [], allowed_read_roots: [], network_policy: :disabled)
+      def initialize(trusted_gems: [], allowed_read_roots: [], network_policy: :disabled, allowed_url_hosts: [])
         validate_network_policy!(network_policy)
 
         @trusted_gems = trusted_gems.map { |g| g.to_s.dup.freeze }.uniq.sort.freeze
@@ -50,6 +53,7 @@ module Rigor
                               .sort
                               .freeze
         @network_policy = network_policy
+        @allowed_url_hosts = allowed_url_hosts.map { |h| h.to_s.downcase.dup.freeze }.uniq.sort.freeze
         freeze
       end
 
@@ -67,6 +71,24 @@ module Rigor
         @network_policy != :disabled
       end
 
+      # @param url [String, URI]
+      # @return [Boolean] true when the URL scheme is `https` and
+      #   the parsed hostname is in `allowed_url_hosts`. Always
+      #   `false` while `network_policy` is `:disabled`.
+      def allow_url?(url)
+        return false if @network_policy == :disabled
+        return false if @allowed_url_hosts.empty?
+
+        require "uri"
+        uri = url.is_a?(URI::Generic) ? url : URI.parse(url.to_s)
+        return false unless uri.is_a?(URI::HTTPS)
+        return false if uri.host.nil?
+
+        @allowed_url_hosts.include?(uri.host.downcase)
+      rescue URI::InvalidURIError
+        false
+      end
+
       def gem_trusted?(name)
         @trusted_gems.include?(name.to_s)
       end
@@ -75,7 +97,8 @@ module Rigor
         {
           "trusted_gems" => trusted_gems,
           "allowed_read_roots" => allowed_read_roots,
-          "network_policy" => network_policy.to_s
+          "network_policy" => network_policy.to_s,
+          "allowed_url_hosts" => allowed_url_hosts
         }
       end
 

data/lib/rigor/plugin.rb

@@ -4,6 +4,7 @@ require_relative "plugin/manifest"
 require_relative "plugin/access_denied_error"
 require_relative "plugin/trust_policy"
 require_relative "plugin/io_boundary"
+require_relative "plugin/fact_store"
 require_relative "plugin/services"
 require_relative "plugin/base"
 require_relative "plugin/registry"

data/lib/rigor/scope.rb

@@ -20,7 +20,7 @@ module Rigor
                 :ivars, :cvars, :globals,
                 :class_ivars, :class_cvars, :program_globals,
                 :discovered_classes, :in_source_constants, :discovered_methods,
-                :discovered_def_nodes
+                :discovered_def_nodes, :discovered_method_visibilities
 
     EMPTY_DECLARED_TYPES = {}.compare_by_identity.freeze
     EMPTY_VAR_BINDINGS = {}.freeze
@@ -47,7 +47,8 @@ module Rigor
       discovered_classes: EMPTY_VAR_BINDINGS,
       in_source_constants: EMPTY_VAR_BINDINGS,
       discovered_methods: EMPTY_CLASS_BINDINGS,
-      discovered_def_nodes: EMPTY_CLASS_BINDINGS
+      discovered_def_nodes: EMPTY_CLASS_BINDINGS,
+      discovered_method_visibilities: EMPTY_CLASS_BINDINGS
     )
       @environment = environment
       @locals = locals
@@ -64,6 +65,7 @@ module Rigor
       @in_source_constants = in_source_constants
       @discovered_methods = discovered_methods
       @discovered_def_nodes = discovered_def_nodes
+      @discovered_method_visibilities = discovered_method_visibilities
       freeze
     end
 
@@ -268,6 +270,26 @@ module Rigor
       rebuild(discovered_def_nodes: table)
     end
 
+    # v0.1.2 — per-class table mapping `method_name (Symbol) →
+    # :public | :private | :protected`. Populated by
+    # `ScopeIndexer` for every `def` it sees inside a class
+    # body, with the visibility taken from the surrounding
+    # `private` / `protected` / `public` modifier state plus
+    # any post-hoc `private :name, ...` named-argument calls.
+    # Consumed by the `def.method-visibility-mismatch` rule
+    # so explicit-non-self calls to a private method surface
+    # a diagnostic.
+    def discovered_method_visibility(class_name, method_name)
+      table = @discovered_method_visibilities[class_name.to_s]
+      return nil unless table
+
+      table[method_name.to_sym]
+    end
+
+    def with_discovered_method_visibilities(table)
+      rebuild(discovered_method_visibilities: table)
+    end
+
     def facts_for(target: nil, bucket: nil)
       fact_store.facts_for(target: target, bucket: bucket)
     end
@@ -334,7 +356,8 @@ module Rigor
       declared_types: @declared_types, ivars: @ivars, cvars: @cvars, globals: @globals,
       class_ivars: @class_ivars, class_cvars: @class_cvars, program_globals: @program_globals,
       discovered_classes: @discovered_classes, in_source_constants: @in_source_constants,
-      discovered_methods: @discovered_methods, discovered_def_nodes: @discovered_def_nodes
+      discovered_methods: @discovered_methods, discovered_def_nodes: @discovered_def_nodes,
+      discovered_method_visibilities: @discovered_method_visibilities
     )
       self.class.new(
         environment: environment, locals: locals,
@@ -346,7 +369,8 @@ module Rigor
         discovered_classes: discovered_classes,
         in_source_constants: in_source_constants,
         discovered_methods: discovered_methods,
-        discovered_def_nodes: discovered_def_nodes
+        discovered_def_nodes: discovered_def_nodes,
+        discovered_method_visibilities: discovered_method_visibilities
       )
     end
 
@@ -371,7 +395,8 @@ module Rigor
         discovered_classes: discovered_classes,
         in_source_constants: in_source_constants,
         discovered_methods: discovered_methods,
-        discovered_def_nodes: discovered_def_nodes
+        discovered_def_nodes: discovered_def_nodes,
+        discovered_method_visibilities: discovered_method_visibilities
       )
     end
   end

data/lib/rigor/trinary.rb

@@ -58,7 +58,7 @@ module Rigor
       case value
       when :yes then self.class.no
       when :no then self.class.yes
-      when :maybe then self.class.maybe
+      else self.class.maybe
       end
     end
 

data/lib/rigor/type/integer_range.rb

@@ -66,12 +66,16 @@ module Rigor
       # `:neg_infinity` directly with an `Integer`.
       def lower
         m = min
-        m.is_a?(Symbol) ? -Float::INFINITY : m
+        return m if m.is_a?(Integer)
+
+        -Float::INFINITY
       end
 
       def upper
         m = max
-        m.is_a?(Symbol) ? Float::INFINITY : m
+        return m if m.is_a?(Integer)
+
+        Float::INFINITY
       end
 
       ALIAS_NAMES = {

data/lib/rigor/version.rb

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

data/sig/rigor/environment.rbs

@@ -6,11 +6,12 @@ module Rigor
 
     attr_reader class_registry: ClassRegistry
     attr_reader rbs_loader: RbsLoader?
+    attr_reader plugin_registry: untyped?
 
     def self.default: () -> Environment
-    def self.for_project: (?root: String, ?libraries: Array[String], ?signature_paths: Array[String | _ToPath]?) -> Environment
+    def self.for_project: (?root: String, ?libraries: Array[String], ?signature_paths: Array[String | _ToPath]?, ?cache_store: untyped?, ?plugin_registry: untyped?) -> Environment
 
-    def initialize: (?class_registry: ClassRegistry, ?rbs_loader: RbsLoader?) -> void
+    def initialize: (?class_registry: ClassRegistry, ?rbs_loader: RbsLoader?, ?plugin_registry: untyped?) -> void
     def nominal_for_name: (String | Symbol name) -> Type::Nominal?
     def singleton_for_name: (String | Symbol name) -> Type::Singleton?
     def constant_for_name: (String | Symbol name) -> Type::t?

data/sig/rigor/scope.rbs

@@ -15,6 +15,7 @@ module Rigor
     attr_reader in_source_constants: Hash[String, Type::t]
     attr_reader discovered_methods: Hash[String, Hash[Symbol, Symbol]]
     attr_reader discovered_def_nodes: Hash[String, Hash[Symbol, untyped]]
+    attr_reader discovered_method_visibilities: Hash[String, Hash[Symbol, Symbol]]
 
     def self.empty: (?environment: Environment) -> Scope
 
@@ -39,6 +40,8 @@ module Rigor
     def with_discovered_def_nodes: (Hash[String, Hash[Symbol, untyped]] table) -> Scope
     def user_def_for: (String | Symbol class_name, String | Symbol method_name) -> untyped?
     def top_level_def_for: (String | Symbol method_name) -> untyped?
+    def with_discovered_method_visibilities: (Hash[String, Hash[Symbol, Symbol]] table) -> Scope
+    def discovered_method_visibility: (String | Symbol class_name, String | Symbol method_name) -> Symbol?
     def with_fact: (Analysis::FactStore::Fact fact) -> Scope
     def with_self_type: (Type::t? type) -> Scope
     def with_declared_types: (Hash[untyped, Type::t] table) -> Scope

data/sig/rigor.rbs

@@ -64,8 +64,14 @@ module Rigor
     class Runner
       RUBY_GLOB: String
       DEFAULT_CACHE_ROOT: String
-      attr_reader cache_store: Rigor::Cache::Store?
-      def initialize: (configuration: Configuration, ?explain: bool, ?cache_store: Rigor::Cache::Store?) -> void
+      # `Rigor::Cache::Store` itself is not yet sig-covered (the
+      # cache namespace is in `UNSIGNED_NAMESPACES` per
+      # `spec/rigor/public_api_drift_spec.rb`), so reference it as
+      # `untyped` until the full Cache::Store sig lands. Steep
+      # otherwise raises `RBS::UnknownTypeName` for the named type.
+      attr_reader cache_store: untyped
+      attr_reader plugin_registry: untyped
+      def initialize: (configuration: Configuration, ?explain: bool, ?cache_store: untyped, ?plugin_requirer: untyped) -> void
       def run: (?Array[String] paths) -> Result
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rigortype
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Rigor contributors
@@ -184,13 +184,18 @@ files:
 - exe/rigor
 - lib/rigor.rb
 - lib/rigor/analysis/check_rules.rb
+- lib/rigor/analysis/check_rules/always_truthy_condition_collector.rb
+- lib/rigor/analysis/check_rules/dead_assignment_collector.rb
+- lib/rigor/analysis/check_rules/ivar_write_collector.rb
 - lib/rigor/analysis/diagnostic.rb
 - lib/rigor/analysis/fact_store.rb
 - lib/rigor/analysis/result.rb
+- lib/rigor/analysis/rule_catalog.rb
 - lib/rigor/analysis/runner.rb
 - lib/rigor/ast.rb
 - lib/rigor/ast/type_node.rb
 - lib/rigor/builtins/imported_refinements.rb
+- lib/rigor/builtins/regex_refinement.rb
 - lib/rigor/cache/descriptor.rb
 - lib/rigor/cache/rbs_class_ancestor_table.rb
 - lib/rigor/cache/rbs_class_type_param_names.rb
@@ -202,6 +207,8 @@ files:
 - lib/rigor/cache/rbs_known_class_names.rb
 - lib/rigor/cache/store.rb
 - lib/rigor/cli.rb
+- lib/rigor/cli/diff_command.rb
+- lib/rigor/cli/explain_command.rb
 - lib/rigor/cli/type_of_command.rb
 - lib/rigor/cli/type_of_renderer.rb
 - lib/rigor/cli/type_scan_command.rb
@@ -265,6 +272,7 @@ files:
 - lib/rigor/plugin.rb
 - lib/rigor/plugin/access_denied_error.rb
 - lib/rigor/plugin/base.rb
+- lib/rigor/plugin/fact_store.rb
 - lib/rigor/plugin/io_boundary.rb
 - lib/rigor/plugin/load_error.rb
 - lib/rigor/plugin/loader.rb