rigortype 0.1.9 → 0.1.11

data/plugins/rigor-dry-types/lib/rigor/plugin/dry_types/alias_scanner.rb

@@ -0,0 +1,341 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Rigor
+  module Plugin
+    class DryTypes < Rigor::Plugin::Base
+      # Walks project source for `module X; include Dry.Types(); end`
+      # shapes and emits a `{ "<X>::<Alias>" => "<UnderlyingClass>" }`
+      # alias table covering the dry-types canonical-shortcut names.
+      # See {DryTypes} module-docstring for the floor / ceiling
+      # scoping.
+      module AliasScanner
+        # The canonical-shortcut names dry-types exposes through
+        # `include Dry.Types()`. Mirrors `Dry::Types.type_keys`
+        # from the upstream gem.
+        CANONICAL_ALIASES = {
+          "String" => "String",
+          "Integer" => "Integer",
+          "Float" => "Float",
+          "Decimal" => "BigDecimal",
+          "Symbol" => "Symbol",
+          "Bool" => "TrueClass",
+          "True" => "TrueClass",
+          "False" => "FalseClass",
+          "Nil" => "NilClass",
+          "Date" => "Date",
+          "DateTime" => "DateTime",
+          "Time" => "Time",
+          "Hash" => "Hash",
+          "Array" => "Array",
+          "Any" => "Object"
+        }.freeze
+
+        # Slice 2 — nested-category aliases. dry-types installs
+        # four parallel coercion categories: `Coercible::*`
+        # (everything-to-target coercion), `Strict::*` (no
+        # coercion; raise if mismatch), `Params::*` (HTTP /
+        # query-string-style coercion, used by Hanami / Roda /
+        # dry-web in request handling), `JSON::*` (JSON-shape
+        # coercion). Each category exposes the same set of names
+        # as the canonical shortcuts above, plus a few additions
+        # that are category-specific (`Params::Nil`,
+        # `JSON::Symbol`). For Rigor's purposes the underlying
+        # class is the same regardless of category — coercion
+        # semantics are a runtime concern. We register every
+        # `<module>::<Category>::<Name>` mapping the upstream gem
+        # publishes so call-site references work uniformly.
+        NESTED_CATEGORIES = %w[Coercible Strict Params JSON].freeze
+        private_constant :NESTED_CATEGORIES
+
+        module_function
+
+        # @param paths [Array<String>] absolute paths to `.rb`
+        #   files the project's `paths:` resolves to.
+        # @return [Hash{String => String}] frozen
+        #   `{aliased_name => underlying_class_name}` map. Empty
+        #   when no `include Dry.Types()` declaration is found.
+        def scan(paths:)
+          results = paths.flat_map { |path| scan_file(path) }
+          modules = results.map { |r| r[:module_name] }.uniq
+          return {}.freeze if modules.empty?
+
+          base = canonical_table(modules)
+          results.each do |result|
+            result[:compositions].each do |const_name, underlying|
+              # Each result's compositions are scoped under that
+              # result's enclosing module (`Types::Email`, etc.).
+              base["#{result[:module_name]}::#{const_name}"] ||= underlying
+            end
+          end
+          base.freeze
+        end
+
+        # Populates the canonical-shortcut + nested-category
+        # table (15 + 15 × 4 = 75 entries per alias module).
+        def canonical_table(modules)
+          modules.each_with_object({}) do |module_name, acc|
+            CANONICAL_ALIASES.each do |alias_name, underlying|
+              acc["#{module_name}::#{alias_name}"] = underlying
+              NESTED_CATEGORIES.each do |category|
+                acc["#{module_name}::#{category}::#{alias_name}"] = underlying
+              end
+            end
+          end
+        end
+        private_class_method :canonical_table
+
+        def scan_file(path)
+          source = File.read(path)
+          parse_result = Prism.parse(source, filepath: path)
+          return [] unless parse_result.errors.empty?
+
+          collect_alias_modules(parse_result.value, []).map do |module_info|
+            compositions = collect_compositions(module_info[:body])
+            { module_name: module_info[:module_name], compositions: compositions }
+          end
+        rescue StandardError
+          # Missing-file / parse failures degrade to "no
+          # contribution from this file"; the plugin's
+          # user-visible surface is the published fact, and
+          # dropping unparseable files keeps the fact stable.
+          []
+        end
+        private_class_method :scan_file
+
+        # Walks a Prism AST collecting alias-module info:
+        # `{module_name:, body:}` for every `module X; include
+        # Dry.Types(); …end` shape. Tracks the enclosing module
+        # chain so a nested `module App; module Types; include
+        # Dry.Types(); end; end` publishes `"App::Types"` as the
+        # alias scope. The `body:` field is the
+        # `Prism::StatementsNode` (or nil) we re-walk later for
+        # user-authored compositions (slice 3).
+        def collect_alias_modules(node, qualified_prefix)
+          return [] unless node.is_a?(Prism::Node)
+
+          case node
+          when Prism::ModuleNode
+            name = qualified_name_for(node.constant_path)
+            new_prefix = name ? qualified_prefix + [name] : qualified_prefix
+            children = node.body ? collect_alias_modules(node.body, new_prefix) : []
+            current = if name && contains_dry_types_include?(node.body)
+                        [{ module_name: new_prefix.join("::"), body: node.body }]
+                      else
+                        []
+                      end
+            current + children
+          when Prism::ClassNode
+            # Module-level declarations win; we don't recurse into
+            # class bodies for `include Dry.Types()` because the
+            # canonical pattern is module-level.
+            []
+          else
+            node.compact_child_nodes.flat_map { |c| collect_alias_modules(c, qualified_prefix) }
+          end
+        end
+        private_class_method :collect_alias_modules
+
+        # Slice 3 — user-authored composition recognition.
+        # Walks the alias-module body for `Email =
+        # String.constrained(...)` shapes. Each
+        # `ConstantWriteNode` whose RHS is a method chain
+        # rooted on a canonical-shortcut name (`String`,
+        # `Integer`, …) — or on a nested-category form
+        # (`Strict::String` etc.) — registers the LHS under
+        # the canonical head's underlying class. Unions
+        # (`String | Integer`) and intersections are skipped
+        # (no single underlying class).
+        #
+        # Slice 4 — transitive composition resolution. After
+        # the direct (slice-3) pass collects compositions
+        # whose RHS root is canonical, a second pass walks the
+        # remaining `ConstantWriteNode`s for RHS shapes that
+        # resolve THROUGH an already-published composition —
+        # e.g. `ManagerEmail = Email` (bare reference) or
+        # `ManagerEmail = Email.constrained(min_size: 3)`
+        # (method chain rooted on a composition LHS). Cycle
+        # detection: `A = B; B = A` resolves neither (each
+        # LHS's resolution walk sees itself in the visited
+        # set and bails). Unknown references (`ManagerEmail =
+        # NotAComposition`) silently drop — the user is free
+        # to assign any constant to any other; the plugin only
+        # publishes facts when the underlying class is known.
+        def collect_compositions(body)
+          return {} if body.nil?
+
+          direct = {}
+          ref_edges = {}
+          tree_walk(body).each do |child|
+            next unless child.is_a?(Prism::ConstantWriteNode)
+
+            head = composition_head_canonical(child.value)
+            if head
+              direct[child.name.to_s] = CANONICAL_ALIASES.fetch(head)
+            else
+              ref = transitive_reference_name(child.value)
+              ref_edges[child.name.to_s] = ref if ref
+            end
+          end
+
+          resolved = direct.dup
+          ref_edges.each_key do |lhs|
+            underlying = resolve_transitive_ref(lhs, direct, ref_edges, visited: ::Set.new)
+            resolved[lhs] = underlying if underlying
+          end
+          resolved
+        end
+        private_class_method :collect_compositions
+
+        # Slice-4 helper. Returns the un-resolved RHS root
+        # constant name (not necessarily a CANONICAL_ALIASES
+        # entry) for transitive resolution. Mirrors
+        # {composition_head_canonical} but accepts any
+        # `ConstantReadNode` / `ConstantPathNode` tail rather
+        # than canonical-only. Declines on union / intersection
+        # operators for the same single-underlying-class
+        # reason.
+        def transitive_reference_name(node)
+          case node
+          when Prism::ConstantReadNode
+            node.name.to_s
+          when Prism::ConstantPathNode
+            node.name.to_s
+          when Prism::CallNode
+            return nil if %i[| &].include?(node.name)
+            return nil if node.receiver.nil?
+
+            transitive_reference_name(node.receiver)
+          end
+        end
+        private_class_method :transitive_reference_name
+
+        # Slice-4 helper. Resolves `lhs`'s RHS through the
+        # `direct` (slice-3) compositions table, chaining
+        # through `ref_edges` for transitive references.
+        # Returns the canonical underlying-class name (e.g.
+        # `"String"`) or nil when no chain ends at a direct
+        # composition. Cycles silently return nil — every step
+        # adds the current lhs to `visited` and bails on
+        # re-entry.
+        def resolve_transitive_ref(lhs, direct, ref_edges, visited:)
+          return nil if visited.include?(lhs)
+
+          visited << lhs
+          target = ref_edges[lhs]
+          return nil if target.nil?
+          return direct[target] if direct.key?(target)
+
+          resolve_transitive_ref(target, direct, ref_edges, visited: visited)
+        end
+        private_class_method :resolve_transitive_ref
+
+        # Walks an RHS expression looking for the canonical
+        # shortcut name at the root of a method chain. Returns
+        # the canonical name (`"String"` etc.) or nil.
+        #
+        # Recognised shapes (recursively on `node.receiver`):
+        #
+        # - Bare `String` / `Integer` — `Prism::ConstantReadNode`
+        #   whose name is in `CANONICAL_ALIASES`.
+        # - `Strict::String` / `Coercible::Integer` / etc. —
+        #   `Prism::ConstantPathNode` whose tail is in
+        #   `CANONICAL_ALIASES`.
+        # - `String.constrained(...)` / `.optional` /
+        #   `.default(...)` / arbitrary single-arg method —
+        #   recurse on the receiver.
+        #
+        # Declines on `String | Integer` (union, `:|`) and
+        # `String & Foo` (intersection, `:&`) so the alias
+        # table doesn't claim a single underlying class for
+        # a multi-class composition.
+        def composition_head_canonical(node)
+          case node
+          when Prism::ConstantReadNode
+            CANONICAL_ALIASES.key?(node.name.to_s) ? node.name.to_s : nil
+          when Prism::ConstantPathNode
+            tail = node.name.to_s
+            CANONICAL_ALIASES.key?(tail) ? tail : nil
+          when Prism::CallNode
+            return nil if %i[| &].include?(node.name)
+            return nil if node.receiver.nil?
+
+            composition_head_canonical(node.receiver)
+          end
+        end
+        private_class_method :composition_head_canonical
+
+        # `include Dry.Types()` at the top of the module body is the
+        # canonical alias declaration. We accept the call anywhere
+        # in the body (some projects guard it with a `if defined?`
+        # check). The argument list must be empty (or a kwargs-only
+        # `default: :nominal` style accepted by upstream; we treat
+        # both as "alias-installing").
+        def contains_dry_types_include?(body)
+          return false if body.nil?
+
+          tree_walk(body).any? do |child|
+            include_call_targeting_dry_types?(child)
+          end
+        end
+        private_class_method :contains_dry_types_include?
+
+        def tree_walk(node)
+          return [] unless node.is_a?(Prism::Node)
+
+          Enumerator.new do |y|
+            stack = [node]
+            until stack.empty?
+              current = stack.shift
+              y << current
+              stack.concat(current.compact_child_nodes) if current.is_a?(Prism::Node)
+            end
+          end
+        end
+        private_class_method :tree_walk
+
+        # Matches `include Dry.Types()` (with or without kwargs).
+        # The receiver of the include call MUST be implicit
+        # (i.e., called on `self`), and the argument MUST be a
+        # method call on the `Dry` constant naming `Types`.
+        def include_call_targeting_dry_types?(node)
+          return false unless node.is_a?(Prism::CallNode)
+          return false unless node.name == :include && node.receiver.nil?
+          return false if node.arguments.nil?
+          return false unless node.arguments.arguments.size == 1
+
+          arg = node.arguments.arguments.first
+          dry_types_call?(arg)
+        end
+        private_class_method :include_call_targeting_dry_types?
+
+        def dry_types_call?(node)
+          return false unless node.is_a?(Prism::CallNode)
+          return false unless node.name == :Types
+          return false unless node.receiver.is_a?(Prism::ConstantReadNode)
+
+          node.receiver.name == :Dry
+        end
+        private_class_method :dry_types_call?
+
+        # Resolves a `Prism::ConstantPathNode` /
+        # `Prism::ConstantReadNode` chain to its dot-separated
+        # name (e.g. `"App::Types"`). Returns nil for the
+        # dynamic-prefix shape so the scanner treats those as
+        # opaque rather than guessing.
+        def qualified_name_for(node)
+          case node
+          when Prism::ConstantReadNode then node.name.to_s
+          when Prism::ConstantPathNode
+            parent = node.parent.nil? ? nil : qualified_name_for(node.parent)
+            return nil if !node.parent.nil? && parent.nil?
+
+            parent.nil? ? node.name.to_s : "#{parent}::#{node.name}"
+          end
+        end
+        private_class_method :qualified_name_for
+      end
+    end
+  end
+end

data/plugins/rigor-dry-types/lib/rigor/plugin/dry_types.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require "rigor/plugin"
+
+require_relative "dry_types/alias_scanner"
+
+module Rigor
+  module Plugin
+    # rigor-dry-types — Tier A foundation per
+    # [ADR-12](../../../../../docs/adr/12-dry-rb-packaging.md).
+    #
+    # Recognises the canonical dry-types alias-module declaration:
+    #
+    #     module Types
+    #       include Dry.Types()
+    #     end
+    #
+    # and publishes the resulting `{aliased_name => underlying_class}`
+    # table as the `:dry_type_aliases` cross-plugin fact (ADR-9).
+    # Other dry-rb adapter plugins consume this fact:
+    #
+    # - `rigor-dry-struct` reads it so `attribute :city, Types::String`
+    #   can promote `address.city` from `Dynamic[T]` to `Nominal[String]`
+    #   (gated on the slice-6 precision-promotion work + ADR-13
+    #   resolver chain).
+    # - `rigor-dry-validation` / `rigor-dry-schema` read it for
+    #   per-key type recognition in `schema { … }` / `params { … }`
+    #   blocks (separate plugin slice).
+    #
+    # ## Floor / ceiling (slice 1)
+    #
+    # Slice 1 ships the **floor**:
+    #
+    # - Recognises `module X; include Dry.Types(); end` for any
+    #   constant module name `X` (commonly `Types`, sometimes
+    #   `MyTypes` / `AppTypes`).
+    # - Maps the **basic** dry-types constants: `String`, `Integer`,
+    #   `Float`, `Decimal`, `Symbol`, `Bool`, `True`, `False`, `Nil`,
+    #   `Date`, `DateTime`, `Time`, `Hash`, `Array`, `Any`.
+    # - Publishes the table as `{ "<Module>::<Alias>" =>
+    #   "<UnderlyingClass>" }` so consumers can match on the
+    #   qualified constant name they see in source.
+    #
+    # The **ceiling** (slice 2+):
+    #
+    # - Recognises nested namespaces (`Types::Coercible::Integer`,
+    #   `Types::Strict::Symbol`, `Types::Params::Bool`,
+    #   `Types::JSON::Date`) — each is a separate dry-types
+    #   "category" with its own coercion semantics.
+    # - Recognises user-authored compositions
+    #   (`Types::String.constrained(min_size: 1)`,
+    #   `Email = Types::String.constrained(format: …)`) so the
+    #   alias surface extends beyond the canonical names.
+    # - Emits `dry-types.unknown-alias` / `dry-types.alias-shadow`
+    #   diagnostics when downstream code references a name that
+    #   wasn't published.
+    #
+    # ## Why no `diagnostics_for_file` at the floor?
+    #
+    # The plugin's user-visible value at slice 1 is the published
+    # fact — every downstream uplift (precision promotion in
+    # `address.city`, schema-key recognition in `rigor-dry-validation`)
+    # consumes the fact rather than the plugin itself emitting
+    # diagnostics. The diagnostics surface lands when the
+    # `dry-types.*` rule family becomes load-bearing for
+    # demand-driven cases.
+    class DryTypes < Rigor::Plugin::Base
+      manifest(
+        id: "dry-types",
+        version: "0.1.0",
+        description: "Recognises `module X; include Dry.Types(); end` and publishes the alias table.",
+        produces: [:dry_type_aliases]
+      )
+
+      # Walks every project file once during `prepare(services)` to
+      # build the alias table, then publishes via the ADR-9 fact
+      # store. The walk is bounded by the configured `paths:`
+      # surface; each file's parse error degrades to "no
+      # contribution" without polluting the user-visible
+      # diagnostic stream.
+      def prepare(services)
+        aliases = AliasScanner.scan(paths: scannable_paths(services))
+        return if aliases.empty?
+
+        services.fact_store.publish(
+          plugin_id: manifest.id,
+          name: :dry_type_aliases,
+          value: aliases
+        )
+      end
+
+      def init(_services)
+        @scannable_paths = nil
+      end
+
+      private
+
+      # Resolves the project's `paths:` to a flat list of `.rb`
+      # files the scanner walks. Mirrors `Analysis::Runner`'s
+      # `expand_paths` floor; we don't need the runner's full
+      # exclude/sort surface because the alias table is a
+      # union — any duplicate scan is a no-op.
+      def scannable_paths(services)
+        @scannable_paths ||= services.configuration.paths.flat_map do |entry|
+          if File.directory?(entry)
+            Dir.glob(File.join(entry, "**", "*.rb"), sort: true)
+          elsif File.file?(entry) && entry.end_with?(".rb")
+            [entry]
+          else
+            []
+          end
+        end.uniq.freeze
+      end
+    end
+
+    Rigor::Plugin.register(DryTypes)
+  end
+end

data/plugins/rigor-dry-types/lib/rigor-dry-types.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# Gem entry point. Required by Rigor's plugin loader when
+# `.rigor.yml` lists `rigor-dry-types` under `plugins:`. The
+# loader expects this `require` to side-effect a call to
+# `Rigor::Plugin.register`, which the body of
+# `lib/rigor/plugin/dry_types.rb` performs at load time.
+require_relative "rigor/plugin/dry_types"

data/plugins/rigor-dry-validation/lib/rigor/plugin/dry_validation/contract_scanner.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Rigor
+  module Plugin
+    class DryValidation < Rigor::Plugin::Base
+      # Walks project source for `class T < Dry::Validation::Contract`
+      # subclasses and returns the contract class FQN set.
+      #
+      # Recognition tightness: the superclass match accepts EITHER
+      # the fully-qualified `Dry::Validation::Contract` (3-segment
+      # path) OR the lexical-nested `Validation::Contract`
+      # (2-segment path, when the class body lives inside
+      # `module Dry`). The bare `< Contract` form (1-segment)
+      # is NOT recognised — too ambiguous; users who deeply nest
+      # under `Dry::Validation` should use the explicit form.
+      # Unrelated `< MyApp::Validation::Contract` shapes with the
+      # same tail do NOT register.
+      module ContractScanner
+        CONTRACT_FULL_PATH = %w[Dry Validation Contract].freeze
+        CONTRACT_LEXICAL_DRY_PATH = %w[Validation Contract].freeze
+        private_constant :CONTRACT_FULL_PATH, :CONTRACT_LEXICAL_DRY_PATH
+
+        module_function
+
+        # @param paths [Array<String>] absolute paths to `.rb`
+        #   files the project's `paths:` resolves to.
+        # @return [Array<String>] frozen, sorted list of
+        #   recognized contract class FQNs (e.g.
+        #   `["App::NewUserContract", "Types::EmailContract"]`).
+        def scan(paths:)
+          contracts = []
+          paths.each { |path| contracts.concat(scan_file(path)) }
+          contracts.uniq.sort.freeze
+        end
+
+        def scan_file(path)
+          source = File.read(path)
+          parse_result = Prism.parse(source, filepath: path)
+          return [] unless parse_result.errors.empty?
+
+          collect_contracts(parse_result.value, [])
+        rescue StandardError
+          []
+        end
+        private_class_method :scan_file
+
+        def collect_contracts(node, qualified_prefix)
+          return [] if node.nil?
+
+          case node
+          when Prism::ClassNode then collect_class_node(node, qualified_prefix)
+          when Prism::ModuleNode then collect_module_node(node, qualified_prefix)
+          else
+            node.compact_child_nodes.flat_map { |c| collect_contracts(c, qualified_prefix) }
+          end
+        end
+        private_class_method :collect_contracts
+
+        def collect_class_node(node, qualified_prefix)
+          inner_name = constant_name_for(node.constant_path)
+          return [] if inner_name.nil?
+
+          new_prefix = qualified_prefix + [inner_name]
+          inner = collect_contracts(node.body, new_prefix)
+          inner += [new_prefix.join("::")] if contract_subclass?(node)
+          inner
+        end
+        private_class_method :collect_class_node
+
+        def collect_module_node(node, qualified_prefix)
+          inner_name = constant_name_for(node.constant_path)
+          return [] if inner_name.nil?
+
+          collect_contracts(node.body, qualified_prefix + [inner_name])
+        end
+        private_class_method :collect_module_node
+
+        # Matches superclasses whose constant chain is EXACTLY
+        # `Dry::Validation::Contract` (full path) OR EXACTLY
+        # `Validation::Contract` (lexical-Dry path). Other shapes
+        # — including same-tail-but-different-root chains and
+        # the ambiguous bare `Contract` — do not match.
+        def contract_subclass?(class_node)
+          superclass = class_node.superclass
+          return false if superclass.nil?
+
+          path = constant_path_segments(superclass)
+          [CONTRACT_FULL_PATH, CONTRACT_LEXICAL_DRY_PATH].include?(path)
+        end
+        private_class_method :contract_subclass?
+
+        def constant_path_segments(node)
+          case node
+          when Prism::ConstantReadNode then [node.name.to_s]
+          when Prism::ConstantPathNode
+            segments = []
+            current = node
+            while current.is_a?(Prism::ConstantPathNode)
+              segments.unshift(current.name.to_s)
+              current = current.parent
+            end
+            segments.unshift(current.name.to_s) if current.is_a?(Prism::ConstantReadNode)
+            segments
+          else
+            []
+          end
+        end
+        private_class_method :constant_path_segments
+
+        def constant_name_for(node)
+          segments = constant_path_segments(node)
+          segments.empty? ? nil : segments.join("::")
+        end
+        private_class_method :constant_name_for
+      end
+    end
+  end
+end

data/plugins/rigor-dry-validation/lib/rigor/plugin/dry_validation.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require "rigor/plugin"
+
+require_relative "dry_validation/contract_scanner"
+
+module Rigor
+  module Plugin
+    # rigor-dry-validation — Tier A per
+    # [ADR-12](../../../../../docs/adr/12-dry-rb-packaging.md) and the
+    # slicing plan in
+    # [docs/design/20260517-dry-validation-slicing.md](../../../../../docs/design/20260517-dry-validation-slicing.md).
+    #
+    # Slice 1 floor:
+    #
+    # - Walks the project for `class T < Dry::Validation::Contract`
+    #   subclasses and publishes the resulting set of contract
+    #   class FQNs as the `:dry_validation_contracts` ADR-9
+    #   cross-plugin fact.
+    # - Ships an RBS overlay (`sig/dry_validation.rbs`) typing
+    #   `Dry::Validation::Contract#call` (returns Result) and
+    #   `Dry::Validation::Result#{success?, failure?, to_h}`. Users
+    #   add the path to their `.rigor.yml`'s `signature_paths:` so
+    #   `contract.call(input).to_h` infers cleanly. See the README
+    #   for the wiring step.
+    #
+    # Slice 2 (deferred, per design note):
+    #
+    # - Integrate with `:dry_schema_table` (published by
+    #   `rigor-dry-schema`) so the `params { ... }` block inside a
+    #   Contract contributes a typed `result.to_h` shape per the
+    #   schema. Until this lands, `result.to_h` types as
+    #   `Hash[Symbol, untyped]` (the generic RBS overlay shape).
+    #
+    # Slice 3 (deferred): `json { ... }` adapter parity with
+    # `params { ... }`. Same shape as slice 2.
+    #
+    # No ADR-3 amendment is needed for the validation surface
+    # itself; `Dry::Validation::Result` is a generic class, not a
+    # sum type (the `success?` / `failure?` predicates narrow via
+    # existing bool flow facts).
+    class DryValidation < Rigor::Plugin::Base
+      manifest(
+        id: "dry-validation",
+        version: "0.1.0",
+        description: "Recognises `class T < Dry::Validation::Contract` subclasses and " \
+                     "publishes the contract FQN set.",
+        produces: [:dry_validation_contracts]
+      )
+
+      def prepare(services)
+        contracts = ContractScanner.scan(paths: scannable_paths(services))
+        return if contracts.empty?
+
+        services.fact_store.publish(
+          plugin_id: manifest.id,
+          name: :dry_validation_contracts,
+          value: contracts
+        )
+      end
+
+      def init(_services)
+        @scannable_paths = nil
+      end
+
+      private
+
+      def scannable_paths(services)
+        @scannable_paths ||= services.configuration.paths.flat_map do |entry|
+          if File.directory?(entry)
+            Dir.glob(File.join(entry, "**", "*.rb"), sort: true)
+          elsif File.file?(entry) && entry.end_with?(".rb")
+            [entry]
+          else
+            []
+          end
+        end.uniq.freeze
+      end
+    end
+
+    Rigor::Plugin.register(DryValidation)
+  end
+end

data/plugins/rigor-dry-validation/lib/rigor-dry-validation.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# Gem entry point. Required by Rigor's plugin loader when
+# `.rigor.yml` lists `rigor-dry-validation` under `plugins:`.
+# Side-effects a `Rigor::Plugin.register` call via the
+# `lib/rigor/plugin/dry_validation.rb` class body.
+require_relative "rigor/plugin/dry_validation"