rigortype 0.1.9 → 0.1.11

data/lib/rigor/inference/method_dispatcher/shape_dispatch.rb

@@ -217,6 +217,16 @@ module Rigor
           end
 
           def dispatch_nominal_size(nominal, method_name, args)
+            if nominal.class_name == "String" && args.size == 1
+              string_binary = dispatch_string_binary_from_arg(method_name, args.first)
+              return string_binary if string_binary
+            end
+
+            if nominal.class_name == "Integer" && args.size == 1
+              integer_binary = dispatch_integer_binary_from_arg(method_name, args.first)
+              return integer_binary if integer_binary
+            end
+
             return nil unless args.empty?
 
             selectors = SIZE_RETURNING_NOMINALS[nominal.class_name]
@@ -225,6 +235,38 @@ module Rigor
             Type::Combinator.non_negative_int
           end
 
+          # Arg-type-driven String binary projections for any String-typed
+          # receiver (including Nominal, Refined, and Difference fallbacks).
+          # Called before the no-arg size guard so binary operators are seen.
+          #
+          # - `String + non-empty-string` → `non-empty-string`
+          #   (arg guarantees the concatenation is non-empty)
+          # - `String * Constant[0]` → `Constant[""]`
+          #   (every string repeated 0 times is the empty string)
+          def dispatch_string_binary_from_arg(method_name, arg)
+            case method_name
+            when :+
+              return Type::Combinator.non_empty_string if Type::Combinator.non_empty_string_compatible?(arg)
+            when :*
+              if arg.is_a?(Type::Constant) && arg.value.is_a?(Integer) && arg.value.zero?
+                return Type::Combinator.constant_of("")
+              end
+            end
+            nil
+          end
+
+          # Arg-type-driven Integer binary projections for any Integer-typed
+          # receiver (including Nominal, Refined, and Difference fallbacks).
+          #
+          # - `Integer * Constant[0]` → `Constant[0]`
+          #   (any integer multiplied by 0 is 0)
+          def dispatch_integer_binary_from_arg(method_name, arg)
+            return nil unless method_name == :*
+            return nil unless arg.is_a?(Type::Constant) && arg.value.is_a?(Integer) && arg.value.zero?
+
+            Type::Combinator.constant_of(0)
+          end
+
           # `IntegerRange#to_s` precision (v0.1.1 Track 1 slice 5b).
           # When the range's lower bound is `>= 0`, every member is
           # a non-negative integer and `to_s(base)` returns a
@@ -281,7 +323,7 @@ module Rigor
             return nil unless base.is_a?(Type::Nominal)
 
             if removes_empty_witness?(difference)
-              precise = empty_removal_projection(base, method_name, args)
+              precise = empty_removal_projection(difference, method_name, args)
               return precise if precise
             end
 
@@ -305,14 +347,62 @@ module Rigor
             !!(predicate && predicate.call(difference.removed))
           end
 
-          def empty_removal_projection(base, method_name, args)
-            return nil unless args.empty?
+          # Methods on a non-empty String that preserve non-emptiness
+          # (they transform characters but never reduce the string to "").
+          NON_EMPTY_STRING_PRESERVING_UNARY = Set[:upcase, :downcase, :capitalize, :swapcase, :reverse].freeze
+          # Methods on non-zero-int that return a non-zero-int (identity ops).
+          # Negation of a non-zero integer is non-zero; `to_i`/`to_int` are
+          # identity operations on Integer.
+          NON_ZERO_INT_PRESERVING_UNARY = Set[:-@, :+@, :to_i, :to_int].freeze
+          private_constant :NON_EMPTY_STRING_PRESERVING_UNARY, :NON_ZERO_INT_PRESERVING_UNARY
 
-            if %i[size length count bytesize].include?(method_name)
-              return size_returning_for_empty_removal(base, method_name)
-            end
+          def empty_removal_projection(difference, method_name, args)
+            base = difference.base
+            return empty_removal_unary(difference, base, method_name) if args.empty?
+
+            empty_removal_binary(difference, base, method_name, args)
+          end
+
+          def empty_removal_unary(difference, base, method_name)
+            return size_returning_for_empty_removal(base, method_name) if
+              %i[size length count bytesize].include?(method_name)
+
+            predicate_result = empty_predicate_projection(base, method_name)
+            return predicate_result if predicate_result
+
+            return difference if base.class_name == "String" &&
+                                 NON_EMPTY_STRING_PRESERVING_UNARY.include?(method_name)
 
-            empty_predicate_projection(base, method_name)
+            non_zero_int_unary_projection(difference, base, method_name)
+          end
+
+          def non_zero_int_unary_projection(difference, base, method_name)
+            return nil unless base.class_name == "Integer"
+            return Type::Combinator.positive_int if %i[abs magnitude].include?(method_name)
+            return difference if NON_ZERO_INT_PRESERVING_UNARY.include?(method_name)
+
+            nil
+          end
+
+          def empty_removal_binary(difference, base, method_name, args)
+            return empty_string_binary(difference, method_name, args) if base.class_name == "String"
+            return empty_integer_binary(difference, method_name, args) if base.class_name == "Integer"
+
+            nil
+          end
+
+          def empty_string_binary(difference, method_name, args)
+            return difference if method_name == :+ && args.size == 1
+            return non_empty_string_repeat(difference, args.first) if method_name == :* && args.size == 1
+
+            nil
+          end
+
+          def empty_integer_binary(difference, method_name, args)
+            return nil unless method_name == :* && args.size == 1
+            return nil unless Type::Combinator.non_zero_int_compatible?(args.first)
+
+            difference
           end
 
           def empty_predicate_projection(base, method_name)
@@ -324,6 +414,24 @@ module Rigor
             end
           end
 
+          # `non-empty-string * n` result:
+          # - `n == 0`  → `Constant[""]` (any string repeated 0 times is empty)
+          # - `n >= 1`  → `difference` (non-empty-string stays non-empty)
+          # - otherwise → nil (fall through, e.g. unknown n or non-negative-int)
+          def non_empty_string_repeat(difference, arg)
+            case arg
+            when Type::Constant
+              return nil unless arg.value.is_a?(Integer)
+
+              return Type::Combinator.constant_of("") if arg.value.zero?
+              return difference if arg.value.positive?
+            when Type::IntegerRange
+              return Type::Combinator.constant_of("") if arg.lower.zero? && arg.upper.zero?
+              return difference if arg.lower >= 1
+            end
+            nil
+          end
+
           def size_returning_for_empty_removal(base, method_name)
             return nil if base.class_name == "Integer" # Integer has no size method on Difference
 

data/lib/rigor/inference/precision_scanner.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require_relative "../source/node_walker"
+require_relative "../scope"
+require_relative "scope_indexer"
+
+module Rigor
+  module Inference
+    # Measures the *type quality* of inferred expressions — not whether the
+    # engine recognises an AST node class (that is `CoverageScanner`'s job),
+    # but whether the type it produces carries useful static information.
+    #
+    # Each visited node is classified into one of eight precision tiers:
+    #
+    #   :constant         — Constant[T]: literal value known exactly
+    #   :nominal          — Nominal/Singleton: class identity known
+    #   :shaped           — Tuple/HashShape/IntegerRange/App: structure known
+    #   :refined          — Refined: narrowed by a predicate/assertion
+    #   :bot              — Bot: unreachable branch (definitively precise)
+    #   :dynamic_specific — Dynamic[X] where X is not Top: origin partial
+    #   :dynamic_top      — Dynamic[Top]: completely opaque (the "untyped" hole)
+    #   :top              — Top: universal supertype (no information)
+    #
+    # The summary exposes `precision_ratio` (constant+nominal+shaped+refined+bot
+    # over total) and `opaque_ratio` (dynamic_top+top over total).
+    #
+    # For Union types the *worst* member tier is used, since the union is only
+    # as precise as its least-precise constituent. Intersection uses the *best*
+    # member (the most specific side wins). Difference follows its base type.
+    class PrecisionScanner
+      TIERS = %i[
+        constant nominal shaped refined bot
+        dynamic_specific dynamic_top top
+      ].freeze
+
+      TIER_RANK = TIERS.each_with_index.to_h.freeze
+      private_constant :TIER_RANK
+
+      PRECISE_TIERS = %i[constant nominal shaped refined bot].to_set.freeze
+      private_constant :PRECISE_TIERS
+
+      # Per-file result. Immutable value object.
+      class FileResult < Data.define(:total, :tier_counts)
+        def precise_count
+          PRECISE_TIERS.sum { |t| tier_counts.fetch(t, 0) }
+        end
+
+        def dynamic_top_count
+          tier_counts.fetch(:dynamic_top, 0)
+        end
+
+        def dynamic_specific_count
+          tier_counts.fetch(:dynamic_specific, 0)
+        end
+
+        def dynamic_count
+          dynamic_top_count + dynamic_specific_count
+        end
+
+        def opaque_count
+          tier_counts.fetch(:dynamic_top, 0) + tier_counts.fetch(:top, 0)
+        end
+
+        def precision_ratio
+          return 1.0 if total.zero?
+
+          precise_count.fdiv(total)
+        end
+
+        def opaque_ratio
+          return 0.0 if total.zero?
+
+          opaque_count.fdiv(total)
+        end
+      end
+
+      # @param scope [Rigor::Scope] base scope for type inference.
+      def initialize(scope: nil)
+        @scope = scope || Scope.empty
+      end
+
+      # @param root [Prism::Node] the parsed AST
+      # @return [FileResult]
+      def scan(root)
+        scope_index = ScopeIndexer.index(root, default_scope: @scope)
+        tier_counts = TIERS.to_h { |t| [t, 0] }
+        total = 0
+
+        Source::NodeWalker.each(root) do |node|
+          type = scope_index[node].type_of(node)
+          tier = classify(type)
+          tier_counts[tier] += 1
+          total += 1
+        end
+
+        FileResult.new(total: total, tier_counts: tier_counts)
+      end
+
+      private
+
+      def classify(type)
+        case type
+        when Type::Bot                          then :bot
+        when Type::Top                          then :top
+        when Type::Constant                     then :constant
+        when Type::Nominal, Type::Singleton     then :nominal
+        when Type::Tuple, Type::HashShape,
+             Type::IntegerRange, Type::App      then :shaped
+        when Type::Refined                      then :refined
+        when Type::Dynamic                      then classify_dynamic(type)
+        when Type::Union                        then worst_of(type.members)
+        when Type::Intersection                 then best_of(type.members)
+        when Type::Difference                   then classify(type.base)
+        else                                         :dynamic_top
+        end
+      end
+
+      def classify_dynamic(type)
+        type.static_facet.is_a?(Type::Top) ? :dynamic_top : :dynamic_specific
+      end
+
+      def worst_of(members)
+        members.map { |m| classify(m) }.max_by { |t| TIER_RANK[t] } || :dynamic_top
+      end
+
+      def best_of(members)
+        members.map { |m| classify(m) }.min_by { |t| TIER_RANK[t] } || :dynamic_top
+      end
+    end
+  end
+end

data/lib/rigor/inference/statement_evaluator.rb

@@ -347,7 +347,20 @@ module Rigor
         # result type is precise (`Constant[:even]` instead of the
         # joined `Constant[:even] | Constant[:odd]`).
         live = live_branch_for_if(node, pred_type, post_pred)
-        return live if live
+        if live
+          live_type, _live_scope = live
+          # When the provably-live then-branch terminates and there is no
+          # else, apply the same falsey-scope narrowing as the standard
+          # early-return path below. Without this, `return if @ivar.nil?`
+          # with an ivar seeded as Constant[nil] (making nil? = Constant[true]
+          # and the then-branch "provably live") propagates the un-narrowed
+          # nil scope past the guard instead of Bot.
+          if branch_terminates?(node.statements, live_type) && node.subsequent.nil?
+            _, falsey_scope = Narrowing.predicate_scopes(node.predicate, post_pred)
+            return [live_type, falsey_scope]
+          end
+          return live
+        end
 
         truthy_scope, falsey_scope = Narrowing.predicate_scopes(node.predicate, post_pred)
         then_type, then_scope = eval_branch_or_nil(node.statements, truthy_scope)
@@ -376,7 +389,18 @@ module Rigor
         pred_type, post_pred = sub_eval(node.predicate, scope)
 
         live = live_branch_for_unless(node, pred_type, post_pred)
-        return live if live
+        if live
+          live_type, _live_scope = live
+          # Mirror of the eval_if fix: when the provably-live unless-body
+          # terminates and there is no else, apply the truthy-scope narrowing
+          # so `return unless @ivar` with a nil-seeded ivar doesn't propagate
+          # the nil scope past the guard.
+          if branch_terminates?(node.statements, live_type) && node.else_clause.nil?
+            truthy_scope, = Narrowing.predicate_scopes(node.predicate, post_pred)
+            return [live_type, truthy_scope]
+          end
+          return live
+        end
 
         truthy_scope, falsey_scope = Narrowing.predicate_scopes(node.predicate, post_pred)
         then_type, then_scope = eval_branch_or_nil(node.statements, falsey_scope)

data/lib/rigor/mcp/loop.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+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).
+    class Loop
+      def initialize(input:, output:, server:)
+        @input = input
+        @output = output
+        @server = server
+      end
+
+      def run
+        @input.each_line do |raw|
+          line = raw.chomp
+          next if line.empty?
+
+          begin
+            request = JSON.parse(line)
+          rescue JSON::ParserError => e
+            write_response({ "jsonrpc" => "2.0", "id" => nil,
+                             "error" => { "code" => -32_700, "message" => "Parse error: #{e.message}" } })
+            next
+          end
+
+          response = @server.handle(request)
+          write_response(response) if response
+        end
+      end
+
+      private
+
+      def write_response(response)
+        @output.puts(JSON.generate(response))
+        @output.flush
+      end
+    end
+  end
+end

data/lib/rigor/mcp/server.rb

@@ -0,0 +1,263 @@
+# frozen_string_literal: true
+
+require "json"
+require "stringio"
+
+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).
+    class Server # rubocop:disable Metrics/ClassLength
+      PROTOCOL_VERSION = "2024-11-05"
+
+      TOOLS = [
+        {
+          name: "rigor_check",
+          description: "Analyze Ruby files for type errors, undefined methods, arity mismatches, " \
+                       "and nil-receiver risks. Returns a JSON diagnostic report.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              paths: {
+                type: "array",
+                items: { type: "string" },
+                description: "Files or directories to analyze (required)"
+              },
+              config: { type: "string", description: "Path to .rigor.yml (optional)" }
+            },
+            required: ["paths"]
+          }
+        },
+        {
+          name: "rigor_type_of",
+          description: "Get the inferred type of the expression at a specific location in a Ruby file.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              file: { type: "string",  description: "Path to the Ruby file" },
+              line: { type: "integer", description: "1-based line number" },
+              col: { type: "integer", description: "1-based column number" },
+              config: { type: "string", description: "Path to .rigor.yml (optional)" }
+            },
+            required: %w[file line col]
+          }
+        },
+        {
+          name: "rigor_triage",
+          description: "Summarize a project's diagnostics: rule distribution, per-file hotspots, " \
+                       "and heuristic hints for the most common error clusters. Returns JSON. " \
+                       "Useful for understanding the shape of a diagnostic set before deciding what to fix.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              paths: {
+                type: "array",
+                items: { type: "string" },
+                description: "Files or directories to analyze (defaults to configured paths)"
+              },
+              top: { type: "integer", description: "Number of hotspot files to include (default: 10)" },
+              config: { type: "string", description: "Path to .rigor.yml (optional)" }
+            }
+          }
+        },
+        {
+          name: "rigor_annotate",
+          description: "Return the given Ruby source file with each line's last-expression type " \
+                       "appended as a comment. Useful for understanding how Rigor infers types " \
+                       "through a file.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              file: { type: "string", description: "Path to the Ruby file to annotate" },
+              config: { type: "string", description: "Path to .rigor.yml (optional)" }
+            },
+            required: ["file"]
+          }
+        },
+        {
+          name: "rigor_sig_gen",
+          description: "Generate RBS skeleton signatures inferred from Ruby source files. " \
+                       "Returns a JSON report of candidates with their classifications " \
+                       "(new-file, new-method, tighter-return, equivalent, skipped).",
+          inputSchema: {
+            type: "object",
+            properties: {
+              paths: {
+                type: "array",
+                items: { type: "string" },
+                description: "Files or directories to generate signatures for (defaults to configured paths)"
+              },
+              params: {
+                type: "string",
+                enum: %w[untyped observed],
+                description: "Parameter policy: untyped (default) or observed " \
+                             "(harvests call-site argument types from spec/)"
+              },
+              config: { type: "string", description: "Path to .rigor.yml (optional)" }
+            }
+          }
+        },
+        {
+          name: "rigor_explain",
+          description: "Look up the description of one or all Rigor diagnostic rules. " \
+                       "Returns JSON. Without a rule argument, returns the full catalog.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              rule: {
+                type: "string",
+                description: "Rule ID, legacy alias, or family prefix (call, flow, assert, dump, def). " \
+                             "Omit to list every rule."
+              }
+            }
+          }
+        },
+        {
+          name: "rigor_coverage",
+          description: "Report type-precision coverage: the ratio of expressions Rigor types as " \
+                       "Constant / Nominal / shaped / refined (precise) vs Dynamic or top (opaque). " \
+                       "Returns JSON. Useful for measuring the impact of adding new fold rules.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              paths: {
+                type: "array",
+                items: { type: "string" },
+                description: "Files or directories to scan (required)"
+              },
+              config: { type: "string", description: "Path to .rigor.yml (optional)" }
+            },
+            required: ["paths"]
+          }
+        }
+      ].freeze
+
+      def initialize(config_path: nil, err: $stderr)
+        @config_path = config_path
+        @err = err
+      end
+
+      # 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"]
+
+        # Notifications carry no `id` and require no response.
+        return nil if id.nil?
+
+        case method_name
+        when "initialize"  then handle_initialize(id)
+        when "ping"        then success(id, {})
+        when "tools/list"  then success(id, { tools: TOOLS })
+        when "tools/call"
+          call_tool(id,
+                    request.dig("params", "name"),
+                    request.dig("params", "arguments") || {})
+        else
+          error(id, -32_601, "Method not found: #{method_name.inspect}")
+        end
+      end
+
+      private
+
+      def handle_initialize(id)
+        require_relative "../version"
+        success(id, {
+                  protocolVersion: PROTOCOL_VERSION,
+                  capabilities: { tools: { listChanged: false } },
+                  serverInfo: { name: "rigor", version: Rigor::VERSION }
+                })
+      end
+
+      def call_tool(id, name, args)
+        argv = build_argv(name, args)
+        return error(id, -32_602, "Unknown tool: #{name.inspect}") unless argv
+
+        out_io = StringIO.new
+        err_io = StringIO.new
+        require_relative "../cli"
+        exit_code = CLI.new(argv, out: out_io, err: err_io).run
+
+        is_error = exit_code == CLI::EXIT_USAGE
+        text = out_io.string
+        text = err_io.string if text.empty? && is_error
+
+        success(id, { content: [{ type: "text", text: text }], isError: is_error })
+      rescue StandardError => e
+        @err.puts("rigor mcp: #{e.class}: #{e.message}")
+        @err.puts(e.backtrace.first(5).join("\n")) if e.backtrace
+        success(id, {
+                  content: [{ type: "text", text: "Internal error: #{e.message}" }],
+                  isError: true
+                })
+      end
+
+      def build_argv(name, args) # rubocop:disable Metrics/MethodLength,Metrics/CyclomaticComplexity,Metrics/AbcSize,Metrics/PerceivedComplexity
+        effective_config = args["config"] || @config_path
+
+        case name
+        when "rigor_check"
+          argv = ["check", "--format=json", "--no-stats"]
+          argv << "--config=#{effective_config}" if effective_config
+          argv += Array(args["paths"])
+          argv
+
+        when "rigor_type_of"
+          return nil unless args["file"] && args["line"] && args["col"]
+
+          argv = ["type-of", "--format=json"]
+          argv << "--config=#{effective_config}" if effective_config
+          argv << "#{args['file']}:#{args['line']}:#{args['col']}"
+          argv
+
+        when "rigor_triage"
+          argv = ["triage", "--format=json"]
+          argv << "--config=#{effective_config}" if effective_config
+          argv << "--top=#{args['top']}" if args["top"]
+          argv += Array(args["paths"])
+          argv
+
+        when "rigor_annotate"
+          return nil unless args["file"]
+
+          argv = ["annotate", "--no-color"]
+          argv << "--config=#{effective_config}" if effective_config
+          argv << args["file"]
+          argv
+
+        when "rigor_sig_gen"
+          argv = ["sig-gen", "--print", "--format=json"]
+          argv << "--config=#{effective_config}" if effective_config
+          argv << "--params=#{args['params']}" if args["params"]
+          argv += Array(args["paths"])
+          argv
+
+        when "rigor_explain"
+          argv = ["explain", "--format=json"]
+          argv << args["rule"] if args["rule"]
+          argv
+
+        when "rigor_coverage"
+          argv = ["coverage", "--format=json"]
+          argv << "--config=#{effective_config}" if effective_config
+          argv += Array(args["paths"])
+          argv
+        end
+      end
+
+      def success(id, result)
+        { "jsonrpc" => "2.0", "id" => id, "result" => result }
+      end
+
+      def error(id, code, message)
+        { "jsonrpc" => "2.0", "id" => id, "error" => { "code" => code, "message" => message } }
+      end
+    end
+  end
+end

data/lib/rigor/mcp.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Rigor
+  # 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.
+  module MCP
+  end
+end
+
+require_relative "mcp/server"
+require_relative "mcp/loop"