rigortype 0.1.8 → 0.1.10

data/lib/rigor/cli/baseline_command.rb

@@ -9,22 +9,22 @@ require_relative "../configuration"
 
 module Rigor
   class CLI
-    # ADR-22 Slice 1 — `rigor baseline {generate}` subcommands.
-    # Backed by `Rigor::Analysis::Baseline`. Future slices
-    # extend the subcommand surface with `dump`, `drift`,
-    # `prune`, `regenerate`.
-    #
-    # Initial subcommand: `generate`.
+    # ADR-22 — `rigor baseline {generate,regenerate,dump,drift,
+    # prune}` subcommands, backed by `Rigor::Analysis::Baseline`.
     #
     #   rigor baseline generate              # default: rule-ID rows
     #   rigor baseline generate --match-mode message
     #   rigor baseline generate --force      # overwrite existing
     #   rigor baseline generate --output=PATH
+    #   rigor baseline regenerate            # slice 5: unconditional rewrite
+    #   rigor baseline dump
+    #   rigor baseline drift
+    #   rigor baseline prune
     class BaselineCommand # rubocop:disable Metrics/ClassLength
       EXIT_USAGE = 64
       DEFAULT_BASELINE_PATH = ".rigor-baseline.yml"
 
-      SUBCOMMANDS = %w[generate dump drift prune].freeze
+      SUBCOMMANDS = %w[generate regenerate dump drift prune].freeze
 
       def initialize(argv:, out: $stdout, err: $stderr)
         @argv = argv
@@ -39,6 +39,7 @@ module Rigor
           @out.puts(help)
           0
         when "generate" then run_generate
+        when "regenerate" then run_regenerate
         when "dump" then run_dump
         when "drift" then run_drift
         when "prune" then run_prune
@@ -59,21 +60,36 @@ module Rigor
         path = options.fetch(:output)
 
         if File.exist?(path) && !options.fetch(:force)
-          @err.puts("rigor: #{path} already exists. Re-run with --force to overwrite.")
+          @err.puts("rigor: #{path} already exists. Re-run with --force to " \
+                    "overwrite, or use `rigor baseline regenerate`.")
           return EXIT_USAGE
         end
 
+        write_baseline(options, verb: "wrote baseline to")
+      end
+
+      # ADR-22 slice 5 — `regenerate` is `generate --force`: the
+      # end-of-quality-improvement-session refresh after landing
+      # baseline-reducing fixes. It rewrites the file
+      # unconditionally (no existence guard, no `--force` flag),
+      # so `rigor baseline regenerate` reads cleanly as "make the
+      # baseline match reality again".
+      def run_regenerate
+        options = parse_generate_options(subcommand: "regenerate")
+        write_baseline(options, verb: "regenerated baseline")
+      end
+
+      def write_baseline(options, verb:)
+        path = options.fetch(:output)
         configuration = Configuration.load(options.fetch(:config))
         diagnostics = collect_diagnostics(configuration, options)
 
         baseline = Analysis::Baseline.from_diagnostics(diagnostics, match_mode: options.fetch(:match_mode))
         File.write(path, baseline.to_yaml)
 
-        bucket_count = baseline.size
-        diagnostic_count = diagnostics.size
         @err.puts(
-          "rigor: wrote baseline to #{path} " \
-          "(#{bucket_count} bucket(s) covering #{diagnostic_count} diagnostic(s); " \
+          "rigor: #{verb} #{path} " \
+          "(#{baseline.size} bucket(s) covering #{diagnostics.size} diagnostic(s); " \
           "match-mode: #{options.fetch(:match_mode)})"
         )
         if configuration.baseline_path.nil?
@@ -85,7 +101,7 @@ module Rigor
         0
       end
 
-      def parse_generate_options
+      def parse_generate_options(subcommand: "generate")
         options = {
           config: nil,
           output: DEFAULT_BASELINE_PATH,
@@ -93,7 +109,7 @@ module Rigor
           force: false
         }
         parser = OptionParser.new do |opts|
-          opts.banner = "Usage: rigor baseline generate [options]"
+          opts.banner = "Usage: rigor baseline #{subcommand} [options]"
           opts.on("--config=PATH", "Path to the Rigor configuration file") { |v| options[:config] = v }
           opts.on("--output=PATH", "Write baseline to PATH (default: #{DEFAULT_BASELINE_PATH})") do |v|
             options[:output] = v
@@ -102,7 +118,10 @@ module Rigor
                   "Row form: rule (default) or message") do |v|
             options[:match_mode] = v
           end
-          opts.on("--force", "Overwrite an existing baseline file") { options[:force] = true }
+          # `regenerate` always overwrites — no `--force` to offer.
+          if subcommand == "generate"
+            opts.on("--force", "Overwrite an existing baseline file") { options[:force] = true }
+          end
         end
         parser.parse!(@argv)
         options
@@ -290,7 +309,7 @@ module Rigor
         case status
         when :over then "## Over threshold (#{count}) — bucket exceeded; check the regular diagnostic output."
         when :cleared then "## Cleared (#{count}) — `rigor baseline prune` can drop these."
-        when :reducible then "## Reducible (#{count}) — tightening opportunity; consider `regenerate` (slice 5)."
+        when :reducible then "## Reducible (#{count}) — tightening opportunity; run `rigor baseline regenerate`."
         when :within then "## Within threshold (#{count})"
         end
       end
@@ -365,6 +384,7 @@ module Rigor
 
           Subcommands:
             generate    Write a fresh baseline file from a `rigor check` run.
+            regenerate  Rewrite the baseline unconditionally (post-fix refresh).
             dump        Print the contents of an existing baseline.
             drift       Compare baseline vs current diagnostics (reduction / regression hints).
             prune       Drop cleared buckets (`actual == 0`) from the baseline.

data/lib/rigor/cli/coverage_command.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require "optionparser"
+require "prism"
+
+require_relative "../configuration"
+require_relative "../environment"
+require_relative "../inference/precision_scanner"
+require_relative "../scope"
+require_relative "coverage_report"
+require_relative "coverage_renderer"
+
+module Rigor
+  class CLI
+    # Executes the `rigor coverage` command.
+    #
+    # Walks every Prism node in one or more files, infers its type via
+    # `Rigor::Scope#type_of`, and classifies the result into precision tiers
+    # (constant / nominal / shaped / refined / bot / dynamic_specific /
+    # dynamic_top / top).  Reports aggregate and per-file statistics so
+    # maintainers can track type-precision trends and SKILL pipelines can
+    # measure the impact of adding new constant-fold or shape-dispatch rules.
+    #
+    # Exit codes:
+    #   0  — scan complete, precision ratio ≥ threshold (or no threshold given)
+    #   1  — precision ratio < threshold, or parse errors encountered
+    #   64 — usage error
+    class CoverageCommand
+      USAGE = "Usage: rigor coverage [options] PATH..."
+
+      def initialize(argv:, out:, err:)
+        @argv = argv
+        @out = out
+        @err = err
+      end
+
+      # @return [Integer] CLI exit status.
+      def run
+        options = parse_options
+        paths = collect_paths(@argv)
+        return CLI::EXIT_USAGE if paths.nil?
+        return usage_error if paths.empty?
+
+        report = scan_paths(paths, options)
+        CoverageRenderer.new(out: @out).render(report, format: options.fetch(:format))
+        determine_exit(report, options)
+      end
+
+      private
+
+      def parse_options
+        options = { format: "text", threshold: nil, config: nil }
+
+        OptionParser.new do |opts|
+          opts.banner = USAGE
+          opts.on("--format=FORMAT", "Output format: text or json") { |v| options[:format] = v }
+          opts.on("--config=PATH", "Path to the Rigor configuration file") { |v| options[:config] = v }
+          opts.on(
+            "--threshold=RATIO", Float,
+            "Exit 1 when precision ratio is below RATIO (0.0–1.0)"
+          ) { |v| options[:threshold] = v }
+        end.parse!(@argv)
+
+        options
+      end
+
+      def collect_paths(args)
+        paths = []
+        args.each do |arg|
+          if File.directory?(arg)
+            paths.concat(Dir.glob(File.join(arg, "**/*.rb")))
+          elsif File.file?(arg)
+            paths << arg
+          else
+            @err.puts("coverage: not a file or directory: #{arg}")
+            return nil
+          end
+        end
+        paths.uniq
+      end
+
+      def usage_error
+        @err.puts("coverage: at least one path is required")
+        @err.puts(USAGE)
+        CLI::EXIT_USAGE
+      end
+
+      def scan_paths(paths, options)
+        configuration = Configuration.load(options.fetch(:config))
+        scope = Scope.empty(environment: project_environment(configuration))
+        scanner = Inference::PrecisionScanner.new(scope: scope)
+        accumulator = CoverageAccumulator.new
+
+        paths.each { |path| scan_one(path, scanner, accumulator, configuration) }
+        accumulator.to_report(paths, options)
+      end
+
+      def project_environment(configuration)
+        Environment.for_project(
+          libraries: configuration.libraries,
+          signature_paths: configuration.signature_paths
+        )
+      end
+
+      def scan_one(path, scanner, accumulator, configuration)
+        source = File.read(path)
+        parse_result = Prism.parse(source, filepath: path, version: configuration.target_ruby)
+        if parse_result.errors.any?
+          accumulator.record_parse_error(path, parse_result.errors)
+          return
+        end
+
+        accumulator.absorb(path, scanner.scan(parse_result.value))
+      end
+
+      def determine_exit(report, options)
+        return 1 unless report.parse_errors.empty?
+
+        threshold = options[:threshold]
+        return 0 if threshold.nil?
+
+        report.precision_ratio < threshold ? 1 : 0
+      end
+    end
+  end
+end

data/lib/rigor/cli/coverage_renderer.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Rigor
+  class CLI
+    # Renders a `CoverageReport` as terminal-friendly text or JSON.
+    class CoverageRenderer
+      TIER_LABELS = {
+        constant: "constant",
+        nominal: "nominal",
+        shaped: "shaped (Tuple/Hash/Range/generic)",
+        refined: "refined",
+        bot: "bot (unreachable)",
+        dynamic_specific: "dynamic — partial info",
+        dynamic_top: "dynamic — opaque (untyped)",
+        top: "top"
+      }.freeze
+
+      def initialize(out:)
+        @out = out
+      end
+
+      def render(report, format:)
+        case format
+        when "text" then render_text(report)
+        when "json" then render_json(report)
+        else raise OptionParser::InvalidArgument, "unsupported format: #{format}"
+        end
+      end
+
+      private
+
+      def render_text(report)
+        render_text_header(report)
+        render_text_summary(report)
+        render_text_tier_table(report)
+        render_text_per_file(report) if report.per_file.size > 1
+        render_text_parse_errors(report)
+      end
+
+      def render_text_header(report)
+        n = report.files.size
+        suffix = n == 1 ? "" : "s"
+        @out.puts("Type coverage: #{n} file#{suffix}")
+        report.files.first(5).each { |f| @out.puts("  - #{f}") }
+        @out.puts("  ... (#{n - 5} more)") if n > 5
+        @out.puts
+      end
+
+      def render_text_summary(report)
+        g = report.grand_total
+        p = report.precise_count
+        o = report.opaque_count
+        @out.puts("Summary:")
+        @out.puts("  files processed:      #{report.files.size - report.parse_errors.size}")
+        @out.puts("  parse errors:         #{report.parse_errors.size}")
+        @out.puts("  expressions typed:    #{g}")
+        @out.puts("  precise:              #{p}#{pct(p, g)}")
+        @out.puts("  dynamic (opaque):     #{o}#{pct(o, g)}")
+        @out.puts("  precision ratio:      #{(report.precision_ratio * 100).round(2)}%")
+        @out.puts
+      end
+
+      def render_text_tier_table(report)
+        @out.puts("Tier breakdown:")
+        g = report.grand_total
+        Inference::PrecisionScanner::TIERS.each do |tier|
+          n = report.tier_count(tier)
+          next if n.zero?
+
+          label = TIER_LABELS.fetch(tier, tier.to_s).ljust(36)
+          @out.puts("  #{label} #{n.to_s.rjust(7)}#{pct(n, g)}")
+        end
+        @out.puts
+      end
+
+      def render_text_per_file(report)
+        @out.puts("Per-file breakdown:")
+        width = report.per_file.map { |e| e[:file].size }.max || 0
+        report.per_file.sort_by { |e| e[:result].precision_ratio }.each do |entry|
+          r = entry[:result]
+          next if r.total.zero?
+
+          ratio_str = "#{(r.precision_ratio * 100).round(1)}%".rjust(6)
+          @out.puts("  #{entry[:file].ljust(width)}  #{ratio_str}  (#{r.precise_count}/#{r.total})")
+        end
+        @out.puts
+      end
+
+      def render_text_parse_errors(report)
+        return if report.parse_errors.empty?
+
+        @out.puts("Parse errors:")
+        report.parse_errors.each do |entry|
+          @out.puts("  #{entry[:file]}: #{entry[:errors].join('; ')}")
+        end
+      end
+
+      def render_json(report)
+        @out.puts(JSON.pretty_generate(json_payload(report)))
+      end
+
+      def json_payload(report)
+        g = report.grand_total
+        {
+          summary: json_summary(report, g),
+          by_tier: tier_payload(g) { |tier| report.tier_count(tier) },
+          by_file: report.per_file.map { |e| file_payload(e) },
+          parse_errors: report.parse_errors.map { |e| { file: e[:file], errors: e[:errors] } }
+        }
+      end
+
+      def json_summary(report, grand_total)
+        g = grand_total
+        dsc = report.total.dynamic_specific_count
+        {
+          files_processed: report.files.size - report.parse_errors.size,
+          parse_errors: report.parse_errors.size,
+          expressions_typed: g,
+          precise_count: report.precise_count,
+          precise_ratio: ratio_f(report.precision_ratio),
+          dynamic_opaque_count: report.opaque_count,
+          dynamic_opaque_ratio: ratio_f(report.opaque_ratio),
+          dynamic_specific_count: dsc,
+          dynamic_specific_ratio: ratio_f(dsc.fdiv(g.nonzero? || 1))
+        }
+      end
+
+      def tier_payload(grand_total)
+        g = grand_total
+        Inference::PrecisionScanner::TIERS.to_h do |tier|
+          n = yield tier
+          [tier, { count: n, ratio: ratio_f(n.fdiv(g.nonzero? || 1)) }]
+        end
+      end
+
+      def file_payload(entry)
+        r = entry[:result]
+        {
+          file: entry[:file],
+          expressions_typed: r.total,
+          precise_count: r.precise_count,
+          precise_ratio: ratio_f(r.precision_ratio),
+          dynamic_opaque_count: r.opaque_count,
+          dynamic_opaque_ratio: ratio_f(r.opaque_ratio),
+          by_tier: tier_payload(r.total) { |tier| r.tier_counts.fetch(tier, 0) }
+        }
+      end
+
+      def pct(numerator, denominator)
+        return "" if denominator.zero?
+
+        " (#{(numerator.fdiv(denominator) * 100).round(1)}%)"
+      end
+
+      def ratio_f(val)
+        val.round(4)
+      end
+    end
+  end
+end

data/lib/rigor/cli/coverage_report.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Rigor
+  class CLI
+    # Aggregated precision-coverage report assembled by `CoverageCommand`.
+    # Holds per-file breakdowns and accumulated totals; consumed by
+    # `CoverageRenderer` for text and JSON output.
+    class CoverageReport < Data.define(
+      :files,
+      :parse_errors,
+      :per_file,
+      :total
+    )
+      # Sum of all per-file totals.
+      def grand_total
+        total.total
+      end
+
+      def precise_count
+        total.precise_count
+      end
+
+      def opaque_count
+        total.opaque_count
+      end
+
+      def precision_ratio
+        total.precision_ratio
+      end
+
+      def opaque_ratio
+        total.opaque_ratio
+      end
+
+      def tier_count(tier)
+        total.tier_counts.fetch(tier, 0)
+      end
+    end
+
+    # Mutable accumulator used while scanning files.
+    class CoverageAccumulator
+      require_relative "../inference/precision_scanner"
+
+      def initialize
+        @per_file = []
+        @parse_errors = []
+        # Accumulated totals across all files.
+        @total_total = 0
+        @total_tier_counts = Inference::PrecisionScanner::TIERS.to_h { |t| [t, 0] }
+      end
+
+      def absorb(path, file_result)
+        @per_file << { file: path, result: file_result }
+        @total_total += file_result.total
+        file_result.tier_counts.each { |tier, n| @total_tier_counts[tier] += n }
+      end
+
+      def record_parse_error(path, errors)
+        @parse_errors << { file: path, errors: errors.map(&:message) }
+      end
+
+      def to_report(files, _options)
+        CoverageReport.new(
+          files: files,
+          parse_errors: @parse_errors,
+          per_file: @per_file,
+          total: Inference::PrecisionScanner::FileResult.new(
+            total: @total_total,
+            tier_counts: @total_tier_counts
+          )
+        )
+      end
+    end
+  end
+end

data/lib/rigor/cli/mcp_command.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "optionparser"
+
+module Rigor
+  class CLI
+    # Executes the `rigor mcp` command.
+    #
+    # Starts a long-running MCP (Model Context Protocol) server over stdio.
+    # The server exposes Rigor's analysis tools as MCP tool calls over a
+    # newline-delimited JSON-RPC 2.0 stream. See ADR-33.
+    #
+    # Slice 1 ships the stdio transport with seven read-only tools:
+    # rigor_check, rigor_type_of, rigor_triage, rigor_annotate,
+    # rigor_sig_gen, rigor_explain, rigor_coverage.
+    class McpCommand
+      USAGE = "Usage: rigor mcp [options]"
+
+      def initialize(argv:, out:, err:)
+        @argv = argv
+        @out = out
+        @err = err
+      end
+
+      # @return [Integer] CLI exit status.
+      def run
+        options = parse_options
+        return CLI::EXIT_USAGE if options == :usage_error
+
+        transport = options.fetch(:transport)
+        unless transport == "stdio"
+          @err.puts("rigor mcp: unsupported transport: #{transport.inspect} (only `stdio` is supported in v1)")
+          return CLI::EXIT_USAGE
+        end
+
+        require_relative "../mcp"
+        require_relative "../version"
+
+        server = MCP::Server.new(config_path: options.fetch(:config), err: $stderr)
+        loop_runner = MCP::Loop.new(input: $stdin, output: $stdout, server: server)
+        loop_runner.run
+        0
+      end
+
+      private
+
+      def parse_options
+        options = { transport: "stdio", config: nil }
+
+        parser = OptionParser.new do |opts|
+          opts.banner = USAGE
+          opts.on("--transport=NAME",
+                  "Transport (default: stdio; only stdio is supported in v1)") do |value|
+            options[:transport] = value
+          end
+          opts.on("--config=PATH",
+                  "Session-level default config path (individual tool calls may override)") do |value|
+            options[:config] = value
+          end
+        end
+        parser.parse!(@argv)
+        options
+      rescue OptionParser::ParseError => e
+        @err.puts(e.message)
+        @err.puts(USAGE)
+        :usage_error
+      end
+    end
+  end
+end

data/lib/rigor/cli/prism_colorizer.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Rigor
+  class CLI
+    # Re-lexes Ruby source with Prism and wraps each token in an
+    # ANSI colour escape, producing IRB-style syntax highlighting.
+    #
+    # Rigor ships no runtime dependencies (ADR-0), so the `irb`
+    # gem's `IRB::Color` is not available; this module reproduces
+    # the same effect from Prism's own token stream. `rigor
+    # annotate` re-parses its annotated output through here before
+    # printing.
+    module PrismColorizer
+      module_function
+
+      RESET = "\e[0m"
+
+      # token category => ANSI SGR parameters.
+      CATEGORY_SGR = {
+        comment: "90",      # bright black (faint grey)
+        keyword: "33",      # yellow
+        literal_kw: "36",   # cyan   — nil / true / false / self
+        number: "34",       # blue
+        string: "32",       # green
+        symbol: "36",       # cyan
+        constant: "1;34",   # bold blue
+        variable: "34",     # blue   — @ivar / @@cvar / $gvar
+        default: nil
+      }.freeze
+
+      LITERAL_KEYWORDS = %i[
+        KEYWORD_NIL KEYWORD_TRUE KEYWORD_FALSE KEYWORD_SELF
+        KEYWORD___FILE__ KEYWORD___LINE__ KEYWORD___ENCODING__
+      ].freeze
+
+      VARIABLE_TOKENS = %i[INSTANCE_VARIABLE CLASS_VARIABLE GLOBAL_VARIABLE].freeze
+
+      # @param source [String] Ruby source.
+      # @return [String] the source with ANSI colour escapes, or
+      #   the input unchanged when lexing surfaces an error.
+      def colorize(source)
+        result = Prism.lex(source)
+        return source unless result.errors.empty?
+
+        render(source, result.value)
+      end
+
+      def render(source, lexed)
+        out = +""
+        offset = 0
+        previous_type = nil
+        lexed.each do |entry|
+          token = entry.first
+          location = token.location
+          out << source[offset...location.start_offset]
+          break if token.type == :EOF
+
+          text = source[location.start_offset...location.end_offset]
+          out << paint(text, effective_category(token.type, previous_type))
+          offset = location.end_offset
+          previous_type = token.type
+        end
+        out << (source[offset..] || "")
+        out
+      end
+
+      # The token after a `SYMBOL_BEGIN` (`:`) carries the symbol
+      # name — and Prism lexes `:then` / `:class` etc. as a
+      # keyword token — so it is painted with the symbol colour
+      # regardless of its own token type.
+      def effective_category(token_type, previous_type)
+        return :symbol if previous_type == :SYMBOL_BEGIN
+
+        category(token_type)
+      end
+
+      def paint(text, category)
+        sgr = CATEGORY_SGR.fetch(category)
+        return text if sgr.nil? || text.empty?
+
+        # Keep a trailing newline outside the colour span so the
+        # reset sits on the token's own line (comments include it).
+        trailing = text[/\s*\z/] || ""
+        body = trailing.empty? ? text : text[0...-trailing.length]
+        return text if body.empty?
+
+        "\e[#{sgr}m#{body}#{RESET}#{trailing}"
+      end
+
+      def category(token_type)
+        name = token_type.to_s
+        return :comment if token_type == :COMMENT
+        return :literal_kw if LITERAL_KEYWORDS.include?(token_type)
+        return :keyword if name.start_with?("KEYWORD_")
+        return :number if number_token?(name)
+        return :string if name.start_with?("STRING_", "HEREDOC_") || token_type == :STRING_CONTENT
+        return :symbol if name.start_with?("SYMBOL_")
+        return :constant if token_type == :CONSTANT
+        return :variable if VARIABLE_TOKENS.include?(token_type)
+
+        :default
+      end
+
+      def number_token?(name)
+        name.start_with?("INTEGER", "FLOAT", "RATIONAL", "IMAGINARY")
+      end
+    end
+  end
+end