rigortype 0.2.6 → 0.2.8

data/plugins/rigor-statesman/lib/rigor/plugin/statesman.rb

@@ -6,29 +6,24 @@ require "rigor/source/literals"
 
 module Rigor
   module Plugin
-    # Example plugin: validates state-machine references.
-    # Demonstrates the **two-pass DSL analysis** pattern many
-    # plugins reuse:
+    # Example plugin: validates state-machine references. Demonstrates the **two-pass DSL analysis**
+    # pattern many plugins reuse:
     #
-    #   1. **Collect pass.** Walk the file once to gather every
-    #      state name declared inside a `state_machine do ... end`
-    #      block (`state :draft`, `state :submitted`, ...).
-    #   2. **Validate pass.** Walk the file again, validating each
-    #      `transition_to(:sym)` and `event :sym` reference against
-    #      the collected state set. Levenshtein distance ≤ 3 drives
-    #      the did-you-mean suggestions.
+    #   1. **Collect pass.** Walk the file once to gather every state name declared inside a
+    #      `state_machine do ... end` block (`state :draft`, `state :submitted`, ...).
+    #   2. **Validate pass.** Walk the file again, validating each `transition_to(:sym)` and `event :sym`
+    #      reference against the collected state set. Levenshtein distance ≤ 3 drives the did-you-mean
+    #      suggestions.
     #
-    # Useful for `aasm` / `statesman` / hand-rolled DSLs and any
-    # framework where declarations and uses live in the same
-    # file. The same skeleton lifts to GraphQL types,
-    # ActiveModel validations, route declarations — anywhere a
-    # declarative DSL produces a closed namespace and the rest
-    # of the file references that namespace by literal symbol.
+    # Useful for `aasm` / `statesman` / hand-rolled DSLs and any framework where declarations and uses
+    # live in the same file. The same skeleton lifts to GraphQL types, ActiveModel validations, route
+    # declarations — anywhere a declarative DSL produces a closed namespace and the rest of the file
+    # references that namespace by literal symbol.
     #
     # ## Configuration
     #
-    # Defaults match the `Statesman::Machine` API; override via
-    # `.rigor.yml` if your DSL uses different names:
+    # Defaults match the `Statesman::Machine` API; override via `.rigor.yml` if your DSL uses different
+    # names:
     #
     #     plugins:
     #       - gem: rigor-statesman
@@ -63,13 +58,11 @@ module Rigor
         @transition_method = config.fetch("transition_method").to_sym
       end
 
-      # ADR-37 — the two-pass shape made explicit. The collect pass
-      # (pass 1) runs once per file as the node-rule file context: it
-      # MUST complete before validation because a `transition_to` may
-      # precede the `state` that declares its target, so it cannot be a
-      # per-node rule in the engine's single forward walk. The validate
-      # pass (pass 2) is then a per-`CallNode` rule over the
-      # engine-owned walk — no hand-rolled traversal.
+      # ADR-37 — the two-pass shape made explicit. The collect pass (pass 1) runs once per file as the
+      # node-rule file context: it MUST complete before validation because a `transition_to` may precede
+      # the `state` that declares its target, so it cannot be a per-node rule in the engine's single
+      # forward walk. The validate pass (pass 2) is then a per-`CallNode` rule over the engine-owned walk
+      # — no hand-rolled traversal.
       node_file_context do |root, _scope|
         collect_states(root)
       end
@@ -86,10 +79,9 @@ module Rigor
 
       private
 
-      # Pass 1 — every `state :foo` declaration inside a
-      # `<dsl_method> do ... end` block on the file. Returns a
-      # frozen Set of state name Symbols. Walks via the engine's
-      # shared `Source::NodeWalker` rather than a hand-rolled traversal.
+      # Pass 1 — every `state :foo` declaration inside a `<dsl_method> do ... end` block on the file.
+      # Returns a frozen Set of state name Symbols. Walks via the engine's shared `Source::NodeWalker`
+      # rather than a hand-rolled traversal.
       def collect_states(root)
         states = Set.new
         Source::NodeWalker.each(root) do |node|

data/plugins/rigor-statesman/lib/rigor-statesman.rb

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

data/plugins/rigor-typescript-utility-types/lib/rigor/plugin/typescript_utility_types.rb

@@ -4,36 +4,27 @@ require "rigor/plugin"
 
 module Rigor
   module Plugin
-    # Example plugin: ships the TypeScript-canonical utility-type
-    # aliases (`Pick<T, K>`, `Omit<T, K>`, `Partial<T>`,
-    # `Required<T>`, `Readonly<T>`) as opt-in vocabulary that
-    # resolves to the Rigor-canonical shape-projection type
-    # functions introduced in ADR-13.
+    # Example plugin: ships the TypeScript-canonical utility-type aliases (`Pick<T, K>`, `Omit<T, K>`,
+    # `Partial<T>`, `Required<T>`, `Readonly<T>`) as opt-in vocabulary that resolves to the Rigor-canonical
+    # shape-projection type functions introduced in ADR-13.
     #
-    # Background. `docs/type-specification/imported-built-in-types.md`
-    # § "Deferred or rejected imports" deliberately rejects
-    # TypeScript-canonical names from the Rigor core surface: the
-    # core stays RBS-canonical per ADR-0 / ADR-1, and the shape
-    # semantics live in core under `pick_of[T, K]` /
-    # `omit_of[T, K]` / `partial_of[T]` / `required_of[T]` /
-    # `readonly_of[T]` (added in ADR-13 slice 4). This plugin
-    # ships the TS spellings as an opt-in translation layer for
-    # users migrating from TypeScript / Sorbet / Flow-style RBI.
+    # Background. `docs/type-specification/imported-built-in-types.md` § "Deferred or rejected imports"
+    # deliberately rejects TypeScript-canonical names from the Rigor core surface: the core stays
+    # RBS-canonical per ADR-0 / ADR-1, and the shape semantics live in core under `pick_of[T, K]` /
+    # `omit_of[T, K]` / `partial_of[T]` / `required_of[T]` / `readonly_of[T]` (added in ADR-13 slice 4).
+    # This plugin ships the TS spellings as an opt-in translation layer for users migrating from
+    # TypeScript / Sorbet / Flow-style RBI.
     #
-    # Off by default — users add the gem to their `.rigor.yml`
-    # plugins list to enable.
+    # Off by default — users add the gem to their `.rigor.yml` plugins list to enable.
     #
     # @example .rigor.yml
     #   plugins:
     #     - gem: rigor-typescript-utility-types
     #
-    # Once loaded, an RBS::Extended payload such as
-    # `%a{rigor:v1:return: Pick[Foo, :a | :b]}` resolves through
-    # the chain: the parser builds a `Generic("Pick", …)` AST,
-    # the registry / built-in parametric builders decline, the
-    # chain consults `Resolvers::Pick`, which recursively
-    # resolves the two arguments to Rigor types and calls
-    # `Type::Combinator.pick_of` on them.
+    # Once loaded, an RBS::Extended payload such as `%a{rigor:v1:return: Pick[Foo, :a | :b]}` resolves
+    # through the chain: the parser builds a `Generic("Pick", …)` AST, the registry / built-in parametric
+    # builders decline, the chain consults `Resolvers::Pick`, which recursively resolves the two arguments
+    # to Rigor types and calls `Type::Combinator.pick_of` on them.
     #
     # ## Translation table
     #
@@ -47,22 +38,17 @@ module Rigor
     #
     # ## Deferred TypeScript utility names
     #
-    # `Parameters<F>` / `ReturnType<F>` / `InstanceType<C>` /
-    # `Awaited<P>` / `Uppercase<S>` / `Lowercase<S>` /
-    # `Capitalize<S>` / `Uncapitalize<S>` / `ThisParameterType<F>`
-    # / `OmitThisParameter<F>` / `ConstructorParameters<C>` /
-    # `NoInfer<T>` are NOT mapped today. The plugin returns `nil`
-    # from `#resolve` for those heads, leaving the parser's
-    # default Nominal-fallback to produce `Nominal[ReturnType, …]`
-    # etc. Function-type projection operators (`params_of[F]` /
-    # `return_of[F]`) and class projections (`instance_type[C]`)
-    # would unlock these — they remain deferred in core.
+    # `Parameters<F>` / `ReturnType<F>` / `InstanceType<C>` / `Awaited<P>` / `Uppercase<S>` /
+    # `Lowercase<S>` / `Capitalize<S>` / `Uncapitalize<S>` / `ThisParameterType<F>` /
+    # `OmitThisParameter<F>` / `ConstructorParameters<C>` / `NoInfer<T>` are NOT mapped today. The plugin
+    # returns `nil` from `#resolve` for those heads, leaving the parser's default Nominal-fallback to
+    # produce `Nominal[ReturnType, …]` etc. Function-type projection operators (`params_of[F]` /
+    # `return_of[F]`) and class projections (`instance_type[C]`) would unlock these — they remain
+    # deferred in core.
     class TypescriptUtilityTypes < Rigor::Plugin::Base
       module Resolvers
-        # Common helper: extract a single-arg utility-type Generic
-        # whose head matches `name`. Returns the resolved
-        # argument's `Rigor::Type` or `nil` (so the chain falls
-        # through).
+        # Common helper: extract a single-arg utility-type Generic whose head matches `name`. Returns the
+        # resolved argument's `Rigor::Type` or `nil` (so the chain falls through).
         module SingleArg
           def self.resolve(node, scope, name)
             return nil unless node.is_a?(Rigor::TypeNode::Generic)

data/plugins/rigor-typescript-utility-types/lib/rigor-typescript-utility-types.rb

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

data/sig/rigor/scope.rbs

@@ -9,6 +9,8 @@ module Rigor
     attr_reader globals: Hash[Symbol, Type::t]
     attr_reader discovery: DiscoveryIndex
     attr_reader dynamic_origins: Hash[untyped, Symbol]
+    attr_reader local_origins: Hash[Symbol, Symbol]
+    attr_reader ivar_origins: Hash[Symbol, Symbol]
     attr_reader indexed_narrowings: Hash[IndexedKey, Type::t]
     attr_reader method_chain_narrowings: Hash[ChainKey, Type::t]
     attr_reader source_path: String?
@@ -82,8 +84,12 @@ module Rigor
     def ivar: (String | Symbol name) -> Type::t?
     def cvar: (String | Symbol name) -> Type::t?
     def global: (String | Symbol name) -> Type::t?
+    def local_origin: (String | Symbol name) -> Symbol?
+    def ivar_origin: (String | Symbol name) -> Symbol?
     def with_local: (String | Symbol name, Type::t type) -> Scope
     def with_ivar: (String | Symbol name, Type::t type) -> Scope
+    def with_local_origin: (String | Symbol name, Symbol? cause) -> Scope
+    def with_ivar_origin: (String | Symbol name, Symbol? cause) -> Scope
     def with_cvar: (String | Symbol name, Type::t type) -> Scope
     def with_global: (String | Symbol name, Type::t type) -> Scope
     def declaration_sourced: () -> Set[[Symbol, Symbol]]

data/skills/rigor-ask/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: rigor-ask
 description: |
-  Rigor is a niche, fast-moving Ruby type checker; its rules, flags, and type behaviour are version-specific, so what you "remember" about it is likely wrong or stale — do NOT answer from memory or guess. For ANY question about Rigor, use this skill and investigate procedurally: run `rigor docs` (handbook + manual, bundled OFFLINE and version-matched), `rigor explain` for a diagnostic id, and for the user's own code `rigor check` / `annotate` / `type-of`, then answer only from what you read. Covers: why a line is flagged or if it's a false positive; the type model (narrowing, refinements, `Dynamic`, RBS); config keys, flags, baselines; comparisons to Sorbet, Steep, mypy, PHPStan; whether it handles Rails, RSpec, or a gem; writing an RBS signature; "what is Rigor / why use it / is it right for us?". Trigger on any Rigor mention seeking understanding — even casual, comparative, or grumbling. Skip only when Rigor isn't mentioned, or it's purely "set it up / fix / reduce it for me" (→ rigor-next-steps).
+  Answer any question about Rigor by investigating, not from memory — Rigor is niche and version-specific, so run its tools and read its bundled docs, then answer from what you saw. Use `rigor docs` (handbook + manual, offline and version-matched) and `rigor explain <rule>`; for the user's own code, `rigor check` / `annotate` / `type-of`. Covers: why a line is flagged or whether it's a false positive; the type model (narrowing, refinements, `Dynamic`, RBS); config keys, flags, baselines; comparisons to Sorbet, Steep, mypy, PHPStan; whether Rigor handles Rails, RSpec, or a given gem; how to type a method; "what is Rigor / why use it / is it right for us?". Trigger on any Rigor question seeking understanding — even casual, comparative, or grumbling. Skip only when it's purely "set it up / fix / reduce it for me" (use rigor-next-steps).
 license: MPL-2.0
 metadata:
   version: 0.2.0
@@ -36,6 +36,26 @@ This is the user's shortcut: they only ever need to remember two skills —
 into the right lookup or analysis so they never have to remember the
 command.
 
+## Prefer the live map over this skill's tables
+
+The doc-page names and command flags below are a snapshot; Rigor's pages
+and CLI move release to release, and a vendored copy of this skill (e.g.
+added via `npx skills`) lags further still. Treat the tables as
+orientation, then confirm against the **installed** Rigor, which is always
+current:
+
+```sh
+rigor docs --list              # the live doc map — what pages exist in THIS version
+rigor --help                   # the live command + flag list
+rigor skill --full rigor-ask   # the current version of this skill itself
+```
+
+Never cite a page, flag, or rule id you have not just seen in one of these
+— that is this skill's whole discipline. If `rigor` is not installed, you
+can still answer high-level "what is Rigor?" questions from the web
+<https://rigor.typedduck.fail/llms.txt>, but for anything version-specific
+install it first (see `rigor-next-steps`).
+
 ## The toolbox
 
 Everything here is read-only and needs no network.

data/skills/rigor-baseline-reduce/SKILL.md

@@ -19,6 +19,22 @@ This skill is for **users improving their own project**. It uses the
 published `rigor` executable on `PATH` and references only public CLI
 flags and config keys.
 
+## First: load the version-current copy
+
+The step-by-step commands live in this skill's `references/` files, and
+their exact flags drift between Rigor releases — so follow the copy that
+ships with the **installed** Rigor rather than any vendored or frozen copy
+of this file. Get the complete current procedure in one call:
+
+```sh
+rigor skill --full rigor-baseline-reduce   # this body + all its references/, inline
+```
+
+If you already loaded this skill *via* `rigor skill` you have the current
+copy — just proceed (read any `references/NN-*.md` from the directory the
+header names). If `rigor` is not on `PATH`, this task needs it: run
+**`rigor-next-steps`** to install Rigor first, then come back.
+
 ## Phase 0 — When to use this skill
 
 Trigger when the user says "reduce the rigor baseline", "fix some