rigortype 0.2.7 → 0.2.8

data/lib/rigor/language_server/server.rb

@@ -5,14 +5,11 @@ require_relative "buffer_table"
 
 module Rigor
   module LanguageServer
-    # LSP server lifecycle state machine + JSON-RPC method dispatcher.
-    # State machine: `:uninitialized` → `:initialized` → `:shutdown`
-    # → `:exited`. {#dispatch} routes (method, params) to the matching
-    # handler and returns the response payload (`nil` for notifications);
-    # out-of-state requests return `InvalidRequest` (-32002) /
-    # `MethodNotFound` (-32601). Full v1 capability surface (document
-    # sync, publishDiagnostics, hover, completion, sig-help, folding,
-    # selection, and watched-file invalidation) is implemented.
+    # LSP server lifecycle state machine + JSON-RPC method dispatcher. State machine: `:uninitialized` →
+    # `:initialized` → `:shutdown` → `:exited`. {#dispatch} routes (method, params) to the matching handler and
+    # returns the response payload (`nil` for notifications); out-of-state requests return `InvalidRequest`
+    # (-32002) / `MethodNotFound` (-32601). Full v1 capability surface (document sync, publishDiagnostics,
+    # hover, completion, sig-help, folding, selection, and watched-file invalidation) is implemented.
     class Server # rubocop:disable Metrics/ClassLength
       # JSON-RPC error codes per LSP spec § "Response Message".
       ERROR_PARSE_ERROR      = -32_700
@@ -24,16 +21,13 @@ module Rigor
       ERROR_SERVER_NOT_INITIALIZED = -32_002
       ERROR_INVALID_REQUEST_AFTER_SHUTDOWN = -32_600
 
-      # `TextDocumentSyncKind::Full = 1`. Slice 10 (deferred)
-      # promotes to `Incremental = 2`.
+      # `TextDocumentSyncKind::Full = 1`. Slice 10 (deferred) promotes to `Incremental = 2`.
       TEXT_DOCUMENT_SYNC_FULL = 1
 
-      # Methods callable BEFORE `initialize`. Per LSP spec § 3 only
-      # `initialize` and `exit` are allowed pre-initialization; every
-      # other request returns `ServerNotInitialized`. We also accept
-      # `shutdown` so a sequence like `initialize → shutdown → exit`
-      # (the conformance harness) round-trips even when the client
-      # skips real work.
+      # Methods callable BEFORE `initialize`. Per LSP spec § 3 only `initialize` and `exit` are allowed
+      # pre-initialization; every other request returns `ServerNotInitialized`. We also accept `shutdown` so a
+      # sequence like `initialize → shutdown → exit` (the conformance harness) round-trips even when the
+      # client skips real work.
       PRE_INITIALIZE_METHODS = %w[initialize shutdown exit].freeze
 
       attr_reader :state, :exit_code, :buffer_table, :publisher,
@@ -45,13 +39,11 @@ module Rigor
       #   resolves `textDocument/completion`. Nil → `MethodNotFound`.
       # @param signature_help_provider [Rigor::LanguageServer::SignatureHelpProvider, nil]
       #   resolves `textDocument/signatureHelp`. Nil → `MethodNotFound`.
-      # @param project_context [Rigor::LanguageServer::ProjectContext, nil]
-      #   the per-session cache of `Environment` + `Cache::Store`
-      #   the providers read on every request. When present,
-      #   `workspace/didChangeWatchedFiles` and
-      #   `workspace/didChangeConfiguration` invalidate the cache;
-      #   nil means "no project context": each request rebuilds env
-      #   from scratch (mainly for specs and backward compatibility).
+      # @param project_context [Rigor::LanguageServer::ProjectContext, nil] the per-session cache of
+      #   `Environment` + `Cache::Store` the providers read on every request. When present,
+      #   `workspace/didChangeWatchedFiles` and `workspace/didChangeConfiguration` invalidate the cache; nil
+      #   means "no project context": each request rebuilds env from scratch (mainly for specs and backward
+      #   compatibility).
       def initialize(buffer_table: BufferTable.new, publisher: nil, # rubocop:disable Metrics/ParameterLists
                      hover_provider: nil, document_symbol_provider: nil,
                      completion_provider: nil, signature_help_provider: nil,
@@ -143,10 +135,9 @@ module Rigor
         end
       end
 
-      # Per LSP spec § "Server lifecycle / initialize": the server
-      # responds with its capabilities. Each later slice extends
-      # `advertised_capabilities` with the handler it wires;
-      # clients asking for unadvertised methods get `MethodNotFound`.
+      # Per LSP spec § "Server lifecycle / initialize": the server responds with its capabilities. Each later
+      # slice extends `advertised_capabilities` with the handler it wires; clients asking for unadvertised
+      # methods get `MethodNotFound`.
       def handle_initialize(_params)
         @state = :initialized
         {
@@ -169,20 +160,17 @@ module Rigor
         caps[:documentSymbolProvider] = true if @document_symbol_provider
         if @completion_provider
           caps[:completionProvider] = {
-            # `.` for method completion; `:` for constant-path
-            # completion (slice 6). The server detects which form
-            # by looking one character back when `:` triggers.
+            # `.` for method completion; `:` for constant-path completion (slice 6). The server detects which
+            # form by looking one character back when `:` triggers.
             triggerCharacters: [".", ":"],
-            # v1 eager — full payload returned on first request.
-            # Resolve becomes relevant if large enumerations
-            # (Object descendants) become noticeable.
+            # v1 eager — full payload returned on first request. Resolve becomes relevant if large
+            # enumerations (Object descendants) become noticeable.
             resolveProvider: false
           }
         end
         if @signature_help_provider
           caps[:signatureHelpProvider] = {
-            # `(` opens the argument list; `,` advances to the
-            # next argument. Editors retrigger on both.
+            # `(` opens the argument list; `,` advances to the next argument. Editors retrigger on both.
             triggerCharacters: ["(", ","]
           }
         end
@@ -191,17 +179,15 @@ module Rigor
         caps
       end
 
-      # `initialized` is a notification — no response body. Slice 7
-      # will hook this to register `workspace/didChangeWatchedFiles`
-      # if the client advertised the capability.
+      # `initialized` is a notification — no response body. Slice 7 will hook this to register
+      # `workspace/didChangeWatchedFiles` if the client advertised the capability.
       def handle_initialized
         nil
       end
 
       def handle_shutdown
         @state = :shutdown
-        # Drop any in-flight debounced publishes so they don't
-        # fire after the client has stopped listening.
+        # Drop any in-flight debounced publishes so they don't fire after the client has stopped listening.
         @publisher&.cancel_pending
         nil
       end
@@ -212,10 +198,9 @@ module Rigor
         nil
       end
 
-      # textDocument/didOpen notification. Per LSP spec § the
-      # `textDocument` payload carries `uri`, `languageId`,
-      # `version`, and the full initial `text`. Triggers a
-      # `publishDiagnostics` push when a publisher is wired.
+      # textDocument/didOpen notification. Per LSP spec § the `textDocument` payload carries `uri`,
+      # `languageId`, `version`, and the full initial `text`. Triggers a `publishDiagnostics` push when a
+      # publisher is wired.
       def handle_did_open(params)
         doc = params.fetch(:textDocument)
         uri = doc.fetch(:uri)
@@ -228,12 +213,10 @@ module Rigor
         nil
       end
 
-      # textDocument/didChange under FULL sync. Each `contentChanges`
-      # entry carries only `{ text: }`; the LAST entry is the new
-      # full document text. Per LSP spec § "FULL sync" the array
-      # MUST be exactly one entry in practice — we still take
-      # `.last` defensively for clients that pad. Triggers
-      # `publishDiagnostics` afterwards.
+      # textDocument/didChange under FULL sync. Each `contentChanges` entry carries only `{ text: }`; the LAST
+      # entry is the new full document text. Per LSP spec § "FULL sync" the array MUST be exactly one entry in
+      # practice — we still take `.last` defensively for clients that pad. Triggers `publishDiagnostics`
+      # afterwards.
       def handle_did_change(params)
         doc = params.fetch(:textDocument)
         changes = params.fetch(:contentChanges)
@@ -249,13 +232,10 @@ module Rigor
         nil
       end
 
-      # textDocument/hover REQUEST. Slice 5 returns either a
-      # `Hover` payload (markdown contents wrapping type +
-      # erased-RBS info) or nil when no expression is at the
-      # queried position. Nil maps to `result: null` per LSP
-      # spec; clients suppress the popup. Returns
-      # `MethodNotFound` when no hover_provider is wired (slice
-      # 1-4 behaviour).
+      # textDocument/hover REQUEST. Slice 5 returns either a `Hover` payload (markdown contents wrapping type
+      # + erased-RBS info) or nil when no expression is at the queried position. Nil maps to `result: null`
+      # per LSP spec; clients suppress the popup. Returns `MethodNotFound` when no hover_provider is wired
+      # (slice 1-4 behaviour).
       def handle_hover(params)
         return method_not_found("textDocument/hover") unless @hover_provider
 
@@ -268,29 +248,25 @@ module Rigor
         )
       end
 
-      # workspace/didChangeWatchedFiles NOTIFICATION. Invalidates
-      # the ProjectContext so cached pre-pass / Environment is
-      # rebuilt on the next request. Slice 7's floor: any watched
-      # file change triggers a full context rebuild. Per-file
-      # surgical invalidation (per design doc § "Project context
-      # refresh") is a follow-up; this is the LSP-correct floor.
+      # workspace/didChangeWatchedFiles NOTIFICATION. Invalidates the ProjectContext so cached pre-pass /
+      # Environment is rebuilt on the next request. Slice 7's floor: any watched file change triggers a full
+      # context rebuild. Per-file surgical invalidation (per design doc § "Project context refresh") is a
+      # follow-up; this is the LSP-correct floor.
       def handle_did_change_watched_files(_params)
         @project_context&.invalidate!
         nil
       end
 
-      # workspace/didChangeConfiguration NOTIFICATION. The payload
-      # shape is client-specific; v1 ignores the payload and
-      # invalidates the context so the next read picks up any
-      # external config changes (.rigor.yml / Gemfile.lock / etc).
+      # workspace/didChangeConfiguration NOTIFICATION. The payload shape is client-specific; v1 ignores the
+      # payload and invalidates the context so the next read picks up any external config changes
+      # (.rigor.yml / Gemfile.lock / etc).
       def handle_did_change_configuration(_params)
         @project_context&.invalidate!
         nil
       end
 
-      # textDocument/selectionRange REQUEST. Routes to the
-      # selection-range provider when wired; `MethodNotFound`
-      # otherwise.
+      # textDocument/selectionRange REQUEST. Routes to the selection-range provider when wired;
+      # `MethodNotFound` otherwise.
       def handle_selection_range(params)
         return method_not_found("textDocument/selectionRange") unless @selection_range_provider
 
@@ -299,8 +275,7 @@ module Rigor
         @selection_range_provider.provide(doc.fetch(:uri), positions)
       end
 
-      # textDocument/foldingRange REQUEST. Routes to the
-      # folding-range provider when wired; `MethodNotFound`
+      # textDocument/foldingRange REQUEST. Routes to the folding-range provider when wired; `MethodNotFound`
       # otherwise.
       def handle_folding_range(params)
         return method_not_found("textDocument/foldingRange") unless @folding_range_provider
@@ -309,8 +284,7 @@ module Rigor
         @folding_range_provider.provide(doc.fetch(:uri))
       end
 
-      # textDocument/signatureHelp REQUEST. Routes to the
-      # signature-help provider when wired; `MethodNotFound`
+      # textDocument/signatureHelp REQUEST. Routes to the signature-help provider when wired; `MethodNotFound`
       # otherwise.
       def handle_signature_help(params)
         return method_not_found("textDocument/signatureHelp") unless @signature_help_provider
@@ -326,8 +300,8 @@ module Rigor
         )
       end
 
-      # textDocument/completion REQUEST. Routes to the completion
-      # provider when wired; `MethodNotFound` otherwise.
+      # textDocument/completion REQUEST. Routes to the completion provider when wired; `MethodNotFound`
+      # otherwise.
       def handle_completion(params)
         return method_not_found("textDocument/completion") unless @completion_provider
 
@@ -342,9 +316,8 @@ module Rigor
         )
       end
 
-      # textDocument/documentSymbol REQUEST. Returns the
-      # `DocumentSymbol[]` outline for the buffer at the requested
-      # URI. Returns `MethodNotFound` when no provider is wired.
+      # textDocument/documentSymbol REQUEST. Returns the `DocumentSymbol[]` outline for the buffer at the
+      # requested URI. Returns `MethodNotFound` when no provider is wired.
       def handle_document_symbol(params)
         return method_not_found("textDocument/documentSymbol") unless @document_symbol_provider
 
@@ -352,10 +325,9 @@ module Rigor
         @document_symbol_provider.provide(doc.fetch(:uri))
       end
 
-      # textDocument/didClose. Drops the buffer table entry AND
-      # publishes an empty diagnostic set so clients clear inline
-      # markers — per LSP spec § "publishDiagnostics" the standard
-      # way to indicate "no diagnostics remain for this URI".
+      # textDocument/didClose. Drops the buffer table entry AND publishes an empty diagnostic set so clients
+      # clear inline markers — per LSP spec § "publishDiagnostics" the standard way to indicate "no
+      # diagnostics remain for this URI".
       def handle_did_close(params)
         doc = params.fetch(:textDocument)
         uri = doc.fetch(:uri)

data/lib/rigor/language_server/signature_help_provider.rb

@@ -19,22 +19,19 @@ require_relative "../type/hash_shape"
 
 module Rigor
   module LanguageServer
-    # Answers `textDocument/signatureHelp` requests. When the user
-    # types `(` inside a method call (`obj.foo(|`) editors fire
-    # `signatureHelp` to show the method's parameter signature
-    # inline. The provider parses the buffer, locates the enclosing
-    # `CallNode`, infers the receiver's type, and returns the
+    # Answers `textDocument/signatureHelp` requests. When the user types `(` inside a method call
+    # (`obj.foo(|`) editors fire `signatureHelp` to show the method's parameter signature inline. The provider
+    # parses the buffer, locates the enclosing `CallNode`, infers the receiver's type, and returns the
     # method's first overload as a `SignatureInformation`.
     #
     # Slice C1 (this commit) ships:
-    # - Sentinel patching for `obj.foo(|` so Prism's parse
-    #   succeeds (mirrors `CompletionProvider`'s slice B4 pattern).
+    # - Sentinel patching for `obj.foo(|` so Prism's parse succeeds (mirrors `CompletionProvider`'s slice B4
+    #   pattern).
     # - First-overload signature only.
     # - Active parameter = comma count before cursor.
     #
-    # Multi-overload presentation + `documentation` field +
-    # active-parameter override per overload land in follow-up
-    # slices (queued in the design doc § "Out of scope for v2").
+    # Multi-overload presentation + `documentation` field + active-parameter override per overload land in
+    # follow-up slices (queued in the design doc § "Out of scope for v2").
     class SignatureHelpProvider
       include BufferResolution
 
@@ -75,12 +72,10 @@ module Rigor
         patch_with_arg_sentinel(original_bytes, line, character)
       end
 
-      # Mid-edit buffer at `obj.foo(|` or `obj.foo(1,|`: truncate
-      # everything from the cursor onwards and append `SENTINEL)`
-      # so the call is syntactically complete. The truncation is
-      # aggressive — signatureHelp only cares about the enclosing
-      # call's signature; downstream content (closing parens,
-      # subsequent statements) is irrelevant.
+      # Mid-edit buffer at `obj.foo(|` or `obj.foo(1,|`: truncate everything from the cursor onwards and append
+      # `SENTINEL)` so the call is syntactically complete. The truncation is aggressive — signatureHelp only
+      # cares about the enclosing call's signature; downstream content (closing parens, subsequent statements)
+      # is irrelevant.
       def patch_with_arg_sentinel(original_bytes, line, character)
         prefix_offset = byte_offset_for(original_bytes, line, character)
         return [original_bytes, [line, character]] if prefix_offset.nil?
@@ -93,11 +88,9 @@ module Rigor
         [patched, [line, character]]
       end
 
-      # Walks the AST for the smallest CallNode whose `arguments`
-      # location encloses the cursor offset. Prism doesn't expose
-      # parent pointers, so NodeLocator's leaf-returning shape
-      # isn't enough; we re-walk. For LSP usage this is cheap —
-      # the buffer is parsed once per request.
+      # Walks the AST for the smallest CallNode whose `arguments` location encloses the cursor offset. Prism
+      # doesn't expose parent pointers, so NodeLocator's leaf-returning shape isn't enough; we re-walk. For
+      # LSP usage this is cheap — the buffer is parsed once per request.
       def enclosing_call_for_offset(root, cursor_offset)
         result = nil
         walk = lambda do |n|
@@ -137,23 +130,18 @@ module Rigor
         end
         {
           signatures: signatures,
-          # `activeSignature` is the index editors highlight by
-          # default. Slice C2 picks the first overload uniformly;
-          # a future slice could choose the overload that best
-          # matches the current argument shape.
+          # `activeSignature` is the index editors highlight by default. Slice C2 picks the first overload
+          # uniformly; a future slice could choose the overload that best matches the current argument shape.
           activeSignature: 0,
           activeParameter: active_param
         }
       end
 
-      # Builds the LSP `ParameterInformation[]` for a method type's
-      # parameter list. Each entry's `label` is a STRING form
-      # (e.g. `"::int width"`, `"?::string pad_string"`); LSP's
-      # offset-tuple form (`[start, end]`) for in-signature
-      # highlighting is queued. Order matches `activeParameter`'s
-      # index expectation: required positionals, then optionals,
-      # then rest, then trailing, then required keywords, then
-      # optional keywords, then rest keywords.
+      # Builds the LSP `ParameterInformation[]` for a method type's parameter list. Each entry's `label` is a
+      # STRING form (e.g. `"::int width"`, `"?::string pad_string"`); LSP's offset-tuple form
+      # (`[start, end]`) for in-signature highlighting is queued. Order matches `activeParameter`'s index
+      # expectation: required positionals, then optionals, then rest, then trailing, then required keywords,
+      # then optional keywords, then rest keywords.
       def parameter_information(method_type) # rubocop:disable Metrics/AbcSize
         func = method_type.type
         return [] unless func.respond_to?(:required_positionals)
@@ -172,12 +160,9 @@ module Rigor
         param.name ? "#{param.type} #{param.name}" : param.type.to_s
       end
 
-      # Identical contract to HoverRenderer#rbs_documentation —
-      # surfaces the method's RBS comment text or nil. Kept inline
-      # rather than extracted to a shared mixin because the two
-      # call sites are small and the shape may diverge (signatureHelp
-      # might want per-parameter docs split out; hover wants the
-      # full paragraph).
+      # Identical contract to HoverRenderer#rbs_documentation — surfaces the method's RBS comment text or nil.
+      # Kept inline rather than extracted to a shared mixin because the two call sites are small and the shape
+      # may diverge (signatureHelp might want per-parameter docs split out; hover wants the full paragraph).
       def rbs_documentation(definition)
         comments = definition.respond_to?(:comments) ? definition.comments : nil
         return nil if comments.nil? || comments.empty?
@@ -200,9 +185,8 @@ module Rigor
         end
       end
 
-      # Mirrors CompletionProvider's receiver-type mapping. Tuple →
-      # Array, HashShape → Hash, Refined / Difference unwrap to
-      # their base (handled in `lookup_method` above for clarity).
+      # Mirrors CompletionProvider's receiver-type mapping. Tuple → Array, HashShape → Hash, Refined /
+      # Difference unwrap to their base (handled in `lookup_method` above for clarity).
       def nominal_class_name(type)
         case type
         when Type::Nominal then type.class_name
@@ -217,10 +201,9 @@ module Rigor
         Inference::ScopeIndexer.index(root, default_scope: scope)
       end
 
-      # Counts commas in the buffer between the call's opening `(`
-      # and the cursor position. Cursor on the first argument → 0;
-      # after one comma → 1; etc. Bounded by the call's arguments
-      # location so commas in nested expressions don't bleed in.
+      # Counts commas in the buffer between the call's opening `(` and the cursor position. Cursor on the
+      # first argument → 0; after one comma → 1; etc. Bounded by the call's arguments location so commas in
+      # nested expressions don't bleed in.
       def active_parameter_index(call_node, bytes, line, character)
         return 0 if call_node.arguments.nil?
 

data/lib/rigor/language_server/synchronized_writer.rb

@@ -2,14 +2,11 @@
 
 module Rigor
   module LanguageServer
-    # Wraps the LSP gem's `Io::Writer` with a Mutex so concurrent
-    # writes (the dispatch loop's response writes + the Debouncer's
-    # async `publishDiagnostics` writes) don't interleave on the
-    # shared STDOUT.
+    # Wraps the LSP gem's `Io::Writer` with a Mutex so concurrent writes (the dispatch loop's response writes +
+    # the Debouncer's async `publishDiagnostics` writes) don't interleave on the shared STDOUT.
     #
-    # Pass-through proxy: `#write(message)` is the only call site
-    # the rest of the LSP uses; `#close` is forwarded for
-    # completeness.
+    # Pass-through proxy: `#write(message)` is the only call site the rest of the LSP uses; `#close` is
+    # forwarded for completeness.
     class SynchronizedWriter
       def initialize(inner)
         @inner = inner

data/lib/rigor/language_server/uri.rb

@@ -2,15 +2,12 @@
 
 module Rigor
   module LanguageServer
-    # LSP DocumentUri ↔ filesystem path conversions. v1 supports
-    # only `file://` URIs; other schemes (e.g. `untitled:`) return
-    # nil from `#to_path` so the caller can short-circuit.
+    # LSP DocumentUri ↔ filesystem path conversions. v1 supports only `file://` URIs; other schemes (e.g.
+    # `untitled:`) return nil from `#to_path` so the caller can short-circuit.
     #
-    # Windows drive-letter handling: `file:///C:/path` → `C:/path`.
-    # The leading slash after the scheme is dropped on Windows; on
-    # POSIX it stays. v1 ships POSIX behaviour; Windows specifics
-    # land when Windows CI is wired (see design doc § "Open
-    # questions").
+    # Windows drive-letter handling: `file:///C:/path` → `C:/path`. The leading slash after the scheme is
+    # dropped on Windows; on POSIX it stays. v1 ships POSIX behaviour; Windows specifics land when Windows CI is
+    # wired (see design doc § "Open questions").
     module Uri
       module_function
 
@@ -22,11 +19,9 @@ module Rigor
       def to_path(uri)
         return nil unless uri.is_a?(String) && uri.start_with?(FILE_SCHEME)
 
-        # Percent-decode at the BYTE level so multi-byte UTF-8
-        # escapes (`%E6%97%A5` → `日`) reassemble correctly. Each
-        # `%xx` decodes to one raw byte; the result is a byte string
-        # we re-interpret as UTF-8. `delete_prefix` always returns
-        # a String (vs `byteslice` whose RBS return is `String?`).
+        # Percent-decode at the BYTE level so multi-byte UTF-8 escapes (`%E6%97%A5` → `日`) reassemble
+        # correctly. Each `%xx` decodes to one raw byte; the result is a byte string we re-interpret as UTF-8.
+        # `delete_prefix` always returns a String (vs `byteslice` whose RBS return is `String?`).
         uri.delete_prefix(FILE_SCHEME).b
            .gsub(/%([0-9A-Fa-f]{2})/) { ::Regexp.last_match(1).hex.chr }
            .force_encoding(Encoding::UTF_8)

data/lib/rigor/language_server.rb

@@ -1,12 +1,10 @@
 # frozen_string_literal: true
 
 module Rigor
-  # The Language Server subsystem. See
-  # `docs/design/20260517-language-server.md` for the design.
-  # The full v1 capability surface (document sync, publishDiagnostics,
-  # hover, completion, sig-help, folding, selection, and watched-file
-  # invalidation) is implemented. This module is the namespace and
-  # require entry point for the subsystem.
+  # The Language Server subsystem. See `docs/design/20260517-language-server.md` for the design. The full v1
+  # capability surface (document sync, publishDiagnostics, hover, completion, sig-help, folding, selection, and
+  # watched-file invalidation) is implemented. This module is the namespace and require entry point for the
+  # subsystem.
   module LanguageServer
   end
 end

data/lib/rigor/mcp/loop.rb

@@ -4,9 +4,8 @@ require "json"
 
 module Rigor
   module MCP
-    # Reads newline-delimited JSON-RPC 2.0 messages from `input`,
-    # dispatches each to `server`, and writes responses to `output`.
-    # Runs until input reaches EOF (the client closes the connection).
+    # Reads newline-delimited JSON-RPC 2.0 messages from `input`, dispatches each to `server`, and writes responses to
+    # `output`. Runs until input reaches EOF (the client closes the connection).
     class Loop
       def initialize(input:, output:, server:)
         @input = input

data/lib/rigor/mcp/server.rb

@@ -7,11 +7,9 @@ module Rigor
   module MCP
     # JSON-RPC 2.0 dispatcher for the MCP server.
     #
-    # Each public `handle` call takes a parsed request hash and returns
-    # a response hash (or nil for notifications that require no reply).
-    # Tool implementations delegate to `CLI.new(argv, out:, err:).run`
-    # with StringIO capture — every tool stays in sync with its CLI
-    # counterpart automatically (ADR-33 WD4).
+    # Each public `handle` call takes a parsed request hash and returns a response hash (or nil for notifications that
+    # require no reply). Tool implementations delegate to `CLI.new(argv, out:, err:).run` with StringIO capture — every
+    # tool stays in sync with its CLI counterpart automatically (ADR-33 WD4).
     class Server # rubocop:disable Metrics/ClassLength
       PROTOCOL_VERSION = "2024-11-05"
 
@@ -142,8 +140,7 @@ module Rigor
         @err = err
       end
 
-      # Dispatches a parsed JSON-RPC request hash.
-      # Returns nil for notifications (requests without an `id`).
+      # Dispatches a parsed JSON-RPC request hash. Returns nil for notifications (requests without an `id`).
       def handle(request)
         id = request["id"]
         method_name = request["method"]

data/lib/rigor/mcp.rb

@@ -1,13 +1,10 @@
 # frozen_string_literal: true
 
 module Rigor
-  # The MCP (Model Context Protocol) server subsystem.
-  # See `docs/adr/33-mcp-server.md` for the design.
+  # The MCP (Model Context Protocol) server subsystem. See `docs/adr/33-mcp-server.md` for the design.
   #
-  # Entry point: `rigor mcp --transport stdio`.
-  # The server exposes Rigor's analysis tools (check, type-of, triage,
-  # annotate, sig-gen, explain, coverage) as MCP tool calls over a
-  # newline-delimited JSON-RPC 2.0 stdio stream.
+  # Entry point: `rigor mcp --transport stdio`. The server exposes Rigor's analysis tools (check, type-of, triage,
+  # annotate, sig-gen, explain, coverage) as MCP tool calls over a newline-delimited JSON-RPC 2.0 stdio stream.
   module MCP
   end
 end

data/lib/rigor/plugin/access_denied_error.rb

@@ -2,15 +2,12 @@
 
 module Rigor
   module Plugin
-    # Raised when a plugin's I/O attempt fails the active
-    # {TrustPolicy}. Surfaced through {IoBoundary} so the analyzer
-    # can convert the exception into a `:plugin_loader` diagnostic
-    # without crashing `rigor check`.
+    # Raised when a plugin's I/O attempt fails the active {TrustPolicy}. Surfaced through {IoBoundary} so the
+    # analyzer can convert the exception into a `:plugin_loader` diagnostic without crashing `rigor check`.
     #
-    # The policy is documented in [ADR-2 § "Plugin Trust and I/O
-    # Policy"](../../../docs/adr/2-extension-api.md). Slice 2's
-    # surface lists `:read_outside_scope` and `:network_disabled`
-    # as the two reason codes; future slices may extend the set.
+    # The policy is documented in [ADR-2 § "Plugin Trust and I/O Policy"](../../../docs/adr/2-extension-api.md).
+    # Slice 2's surface lists `:read_outside_scope` and `:network_disabled` as the two reason codes; future slices
+    # may extend the set.
     class AccessDeniedError < StandardError
       attr_reader :reason, :resource