rigortype 0.1.5 → 0.1.7

data/lib/rigor/cli/baseline_command.rb

@@ -0,0 +1,377 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+require_relative "../analysis/baseline"
+require_relative "../analysis/runner"
+require_relative "../cache/store"
+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`.
+    #
+    #   rigor baseline generate              # default: rule-ID rows
+    #   rigor baseline generate --match-mode message
+    #   rigor baseline generate --force      # overwrite existing
+    #   rigor baseline generate --output=PATH
+    class BaselineCommand # rubocop:disable Metrics/ClassLength
+      EXIT_USAGE = 64
+      DEFAULT_BASELINE_PATH = ".rigor-baseline.yml"
+
+      SUBCOMMANDS = %w[generate dump drift prune].freeze
+
+      def initialize(argv:, out: $stdout, err: $stderr)
+        @argv = argv
+        @out = out
+        @err = err
+      end
+
+      def run
+        subcommand = @argv.shift
+        case subcommand
+        when nil, "help", "-h", "--help"
+          @out.puts(help)
+          0
+        when "generate" then run_generate
+        when "dump" then run_dump
+        when "drift" then run_drift
+        when "prune" then run_prune
+        else
+          @err.puts("Unknown baseline subcommand: #{subcommand.inspect}")
+          @err.puts(help)
+          EXIT_USAGE
+        end
+      rescue OptionParser::ParseError => e
+        @err.puts(e.message)
+        EXIT_USAGE
+      end
+
+      private
+
+      def run_generate
+        options = parse_generate_options
+        path = options.fetch(:output)
+
+        if File.exist?(path) && !options.fetch(:force)
+          @err.puts("rigor: #{path} already exists. Re-run with --force to overwrite.")
+          return EXIT_USAGE
+        end
+
+        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); " \
+          "match-mode: #{options.fetch(:match_mode)})"
+        )
+        if configuration.baseline_path.nil?
+          @err.puts(
+            "rigor: note — `.rigor.yml` does not declare `baseline:`; " \
+            "add `baseline: #{path}` to activate the suppression."
+          )
+        end
+        0
+      end
+
+      def parse_generate_options
+        options = {
+          config: nil,
+          output: DEFAULT_BASELINE_PATH,
+          match_mode: :rule,
+          force: false
+        }
+        parser = OptionParser.new do |opts|
+          opts.banner = "Usage: rigor baseline generate [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
+          end
+          opts.on("--match-mode=MODE", %i[rule message],
+                  "Row form: rule (default) or message") do |v|
+            options[:match_mode] = v
+          end
+          opts.on("--force", "Overwrite an existing baseline file") { options[:force] = true }
+        end
+        parser.parse!(@argv)
+        options
+      end
+
+      def collect_diagnostics(configuration, _options)
+        cache_store = Cache::Store.new(root: configuration.cache_path)
+        # IMPORTANT: do NOT activate the existing baseline when
+        # generating a fresh one — otherwise the new file
+        # records the post-filter (silenced) diagnostic set,
+        # which is empty after a successful first run.
+        configuration_for_generation = override_configuration_baseline_off(configuration)
+        runner = Analysis::Runner.new(
+          configuration: configuration_for_generation,
+          cache_store: cache_store,
+          collect_stats: false
+        )
+        runner.run(configuration_for_generation.paths).diagnostics
+      end
+
+      def override_configuration_baseline_off(configuration)
+        # Synthesise a new Configuration with `baseline` explicitly
+        # disabled. The original Configuration is frozen-ish so we
+        # round-trip through the constructor with an override hash.
+        defaults = Configuration::DEFAULTS.merge(
+          "paths" => configuration.paths,
+          "exclude" => configuration.exclude_patterns,
+          "plugins" => configuration.plugins.map(&:to_h),
+          "disable" => configuration.disabled_rules,
+          "libraries" => configuration.libraries,
+          "signature_paths" => configuration.signature_paths,
+          "pre_eval" => configuration.pre_eval,
+          "severity_profile" => configuration.severity_profile.to_s,
+          "severity_overrides" => configuration.severity_overrides,
+          "baseline" => false,
+          "cache" => { "path" => configuration.cache_path }
+        )
+        Configuration.new(defaults)
+      end
+
+      # ---- dump --------------------------------------------------
+
+      def run_dump
+        options = parse_dump_options
+        baseline = load_baseline_or_exit(options.fetch(:baseline))
+        return EXIT_USAGE if baseline == :error
+
+        rows = filter_dump_rows(baseline.buckets, options)
+        case options.fetch(:format)
+        when :json then @out.puts(JSON.pretty_generate(dump_to_json(rows)))
+        else dump_text(rows, options)
+        end
+        0
+      end
+
+      def parse_dump_options
+        options = { baseline: DEFAULT_BASELINE_PATH, format: :text, rule: nil, file: nil }
+        parser = OptionParser.new do |opts|
+          opts.banner = "Usage: rigor baseline dump [options]"
+          opts.on("--baseline=PATH", "Path to the baseline file (default: #{DEFAULT_BASELINE_PATH})") do |v|
+            options[:baseline] = v
+          end
+          opts.on("--format=FORMAT", %i[text json], "Output format: text (default) or json") do |v|
+            options[:format] = v
+          end
+          opts.on("--rule=RULE", "Filter rows by exact rule id") { |v| options[:rule] = v }
+          opts.on("--file=GLOB", "Filter rows by File.fnmatch? glob") { |v| options[:file] = v }
+        end
+        parser.parse!(@argv)
+        options
+      end
+
+      def filter_dump_rows(buckets, options)
+        buckets.select do |b|
+          next false if options[:rule] && b.rule != options[:rule]
+          next false if options[:file] && !File.fnmatch?(options[:file], b.file)
+
+          true
+        end
+      end
+
+      def dump_text(rows, options)
+        if rows.empty?
+          @out.puts("(no baseline rows matching the supplied filters)")
+          return
+        end
+
+        # Group by rule for readability; rules with the most
+        # entries first.
+        by_rule = rows.group_by(&:rule).sort_by { |_rule, group| -group.size }
+        by_rule.each do |rule, group|
+          total = group.sum(&:count)
+          @out.puts("#{rule}  (#{group.size} bucket(s), #{total} occurrence(s))")
+          group.sort_by { |b| [-b.count, b.file] }.each do |bucket|
+            label = if bucket.message_regex
+                      "  #{bucket.file}: #{bucket.count}  ~/#{bucket.message_regex.source}/"
+                    else
+                      "  #{bucket.file}: #{bucket.count}"
+                    end
+            @out.puts(label)
+          end
+          @out.puts("")
+        end
+        @out.puts("Total: #{rows.size} bucket(s), #{rows.sum(&:count)} occurrence(s)")
+        _ = options # reserved for future flags
+      end
+
+      def dump_to_json(rows)
+        {
+          "version" => Analysis::Baseline::CURRENT_VERSION,
+          "ignored" => rows.map do |b|
+            row = { "file" => b.file, "rule" => b.rule, "count" => b.count }
+            row["message"] = b.message_regex.source if b.message_regex
+            row
+          end
+        }
+      end
+
+      # ---- drift --------------------------------------------------
+
+      def run_drift
+        options = parse_drift_options
+        baseline = load_baseline_or_exit(options.fetch(:baseline))
+        return EXIT_USAGE if baseline == :error
+
+        configuration = Configuration.load(options.fetch(:config))
+        diagnostics = collect_diagnostics(configuration, options)
+        drift_rows = baseline.audit(diagnostics)
+
+        shown = if options.fetch(:only).nil?
+                  drift_rows.reject { |r| r.delta.zero? }
+                else
+                  drift_rows.select { |r| r.status == options.fetch(:only) }
+                end
+
+        if shown.empty?
+          @out.puts("No drift detected.")
+          return 0
+        end
+
+        report_drift_rows(shown, baseline_path: options.fetch(:baseline))
+        0
+      end
+
+      def parse_drift_options
+        options = {
+          config: nil,
+          baseline: DEFAULT_BASELINE_PATH,
+          only: nil
+        }
+        parser = OptionParser.new do |opts|
+          opts.banner = "Usage: rigor baseline drift [options]"
+          opts.on("--config=PATH", "Path to the Rigor configuration file") { |v| options[:config] = v }
+          opts.on("--baseline=PATH", "Path to the baseline file (default: #{DEFAULT_BASELINE_PATH})") do |v|
+            options[:baseline] = v
+          end
+          opts.on("--only=STATUS", %i[within over cleared reducible],
+                  "Show only buckets with the given status (within|over|cleared|reducible)") do |v|
+            options[:only] = v
+          end
+        end
+        parser.parse!(@argv)
+        options
+      end
+
+      def report_drift_rows(rows, baseline_path:) # rubocop:disable Metrics/AbcSize
+        @out.puts("Drift report against #{baseline_path}:")
+        @out.puts("")
+        groups = rows.group_by(&:status)
+        %i[over cleared reducible within].each do |status|
+          group = groups[status] || []
+          next if group.empty?
+
+          @out.puts(drift_section_header(status, group.size))
+          group.sort_by { |r| [r.bucket.file, r.bucket.rule] }.each do |row|
+            delta_str = row.delta.positive? ? "+#{row.delta}" : row.delta.to_s
+            @out.puts("  #{row.bucket.file}  [#{row.bucket.rule}]  " \
+                      "#{row.bucket.count} → #{row.actual_count}  (Δ#{delta_str})")
+          end
+          @out.puts("")
+        end
+      end
+
+      def drift_section_header(status, count)
+        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 :within then "## Within threshold (#{count})"
+        end
+      end
+
+      # ---- prune --------------------------------------------------
+
+      def run_prune
+        options = parse_prune_options
+        baseline = load_baseline_or_exit(options.fetch(:baseline))
+        return EXIT_USAGE if baseline == :error
+
+        configuration = Configuration.load(options.fetch(:config))
+        diagnostics = collect_diagnostics(configuration, options)
+        drift_rows = baseline.audit(diagnostics)
+        cleared = drift_rows.select { |r| r.status == :cleared }
+
+        if cleared.empty?
+          @out.puts("No cleared buckets to prune.")
+          return 0
+        end
+
+        announce_prune(cleared, options.fetch(:baseline))
+        return 0 if options.fetch(:dry_run)
+
+        pruned = baseline.without(cleared.map(&:bucket))
+        File.write(options.fetch(:baseline), pruned.to_yaml)
+        @err.puts("rigor: pruned #{cleared.size} bucket(s); baseline now has #{pruned.size} entries.")
+        0
+      end
+
+      def parse_prune_options
+        options = {
+          config: nil,
+          baseline: DEFAULT_BASELINE_PATH,
+          dry_run: false
+        }
+        parser = OptionParser.new do |opts|
+          opts.banner = "Usage: rigor baseline prune [options]"
+          opts.on("--config=PATH", "Path to the Rigor configuration file") { |v| options[:config] = v }
+          opts.on("--baseline=PATH", "Path to the baseline file (default: #{DEFAULT_BASELINE_PATH})") do |v|
+            options[:baseline] = v
+          end
+          opts.on("--dry-run", "Show what would be dropped without writing the file") { options[:dry_run] = true }
+        end
+        parser.parse!(@argv)
+        options
+      end
+
+      def announce_prune(cleared, baseline_path)
+        @out.puts("#{cleared.size} bucket(s) to prune from #{baseline_path}:")
+        cleared.sort_by { |r| [r.bucket.file, r.bucket.rule] }.each do |row|
+          @out.puts("  - #{row.bucket.file}  [#{row.bucket.rule}]  (was: #{row.bucket.count})")
+        end
+      end
+
+      # ---- shared helpers ----------------------------------------
+
+      def load_baseline_or_exit(path)
+        unless File.exist?(path)
+          @err.puts("rigor: baseline file not found: #{path}")
+          return :error
+        end
+        Analysis::Baseline.load(path)
+      rescue Analysis::Baseline::LoadError => e
+        @err.puts("rigor: baseline load failed: #{e.message}")
+        :error
+      end
+
+      def help
+        <<~HELP
+          Usage: rigor baseline <subcommand> [options]
+
+          Subcommands:
+            generate    Write a fresh baseline file from a `rigor check` run.
+            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.
+
+          Run `rigor baseline <subcommand> --help` for subcommand options.
+        HELP
+      end
+    end
+  end
+end

data/lib/rigor/cli/lsp_command.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require "optionparser"
+
+module Rigor
+  class CLI
+    # Executes the `rigor lsp` command.
+    #
+    # See `docs/design/20260517-language-server.md` for the design.
+    # Slice 1 (this commit) ships the CLI subcommand entry point.
+    # The actual stdio JSON-RPC reader / writer is queued for slice 2;
+    # invoking `rigor lsp` at slice 1 returns immediately after
+    # validating the transport flag.
+    class LspCommand
+      USAGE = "Usage: rigor lsp [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 lsp: unsupported transport: #{transport.inspect} (only `stdio` is supported in v1)")
+          return CLI::EXIT_USAGE
+        end
+
+        require_relative "../language_server"
+        require_relative "../configuration"
+        require "language_server-protocol"
+
+        # STDIN is read frame-by-frame via the gem's `Io::Reader`;
+        # STDOUT is wrapped in `SynchronizedWriter` so concurrent
+        # writes from the main dispatch thread + the Debouncer's
+        # async threads don't interleave frames. The Loop runs
+        # until either STDIN hits EOF or `server.exited?`; the
+        # process then exits with the server's recorded code
+        # (0 after a clean shutdown+exit, 1 otherwise).
+        writer = LanguageServer::SynchronizedWriter.new(
+          ::LanguageServer::Protocol::Transport::Io::Writer.new($stdout)
+        )
+        server, loop_runner = build_server(writer: writer, config_path: options.fetch(:config))
+        loop_runner.run
+        server.exit_code || 0
+      end
+
+      private
+
+      # Builds the full collaborator graph from a fresh
+      # `Configuration` + `ProjectContext`. Returns `[server,
+      # loop]` so the caller drives the loop and reads
+      # `server.exit_code` for the process exit status.
+      def build_server(writer:, config_path:) # rubocop:disable Metrics/MethodLength
+        configuration = Configuration.load(config_path)
+        # ProjectContext caches Environment + Cache::Store across
+        # requests so hover / publish hit the warm path. Invalidated
+        # by `workspace/didChangeWatchedFiles` and
+        # `workspace/didChangeConfiguration`.
+        project_context = LanguageServer::ProjectContext.new(configuration: configuration)
+        # Single source of truth for buffer state — threaded to
+        # Server + all three providers.
+        buffer_table = LanguageServer::BufferTable.new
+        debouncer = LanguageServer::Debouncer.new
+        publisher = LanguageServer::DiagnosticPublisher.new(
+          writer: writer, buffer_table: buffer_table, project_context: project_context,
+          debouncer: debouncer, debounce_seconds: 0.2
+        )
+        server = LanguageServer::Server.new(
+          buffer_table: buffer_table,
+          publisher: publisher,
+          hover_provider: LanguageServer::HoverProvider.new(
+            buffer_table: buffer_table, project_context: project_context
+          ),
+          document_symbol_provider: LanguageServer::DocumentSymbolProvider.new(
+            buffer_table: buffer_table, project_context: project_context
+          ),
+          completion_provider: LanguageServer::CompletionProvider.new(
+            buffer_table: buffer_table, project_context: project_context
+          ),
+          signature_help_provider: LanguageServer::SignatureHelpProvider.new(
+            buffer_table: buffer_table, project_context: project_context
+          ),
+          folding_range_provider: LanguageServer::FoldingRangeProvider.new(
+            buffer_table: buffer_table, project_context: project_context
+          ),
+          selection_range_provider: LanguageServer::SelectionRangeProvider.new(
+            buffer_table: buffer_table, project_context: project_context
+          ),
+          project_context: project_context
+        )
+        loop_runner = LanguageServer::Loop.new(
+          reader: ::LanguageServer::Protocol::Transport::Io::Reader.new($stdin),
+          writer: writer,
+          server: server
+        )
+        [server, loop_runner]
+      end
+
+      def parse_options
+        options = { transport: "stdio", log: nil, config: nil }
+
+        parser = OptionParser.new do |opts|
+          opts.banner = USAGE
+          opts.on("--transport=NAME", "Transport (default: stdio; only stdio supported in v1)") do |value|
+            options[:transport] = value
+          end
+          opts.on("--log=PATH", "Write LSP wire log + server debug to PATH (default: stderr)") do |value|
+            options[:log] = value
+          end
+          opts.on("--config=PATH", "Path to the Rigor configuration file") 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/type_of_command.rb

@@ -3,6 +3,7 @@
 require "optionparser"
 require "prism"
 
+require_relative "../analysis/buffer_binding"
 require_relative "../configuration"
 require_relative "../environment"
 require_relative "../scope"
@@ -38,35 +39,73 @@ module Rigor
       # @return [Integer] CLI exit status.
       def run
         options = parse_options
+        buffer = resolve_buffer_binding(options)
+        return CLI::EXIT_USAGE if buffer == :usage_error
 
         target = parse_position_argument(@argv)
         return CLI::EXIT_USAGE if target.nil?
 
-        execute(target: target, options: options)
+        execute(target: target, options: options, buffer: buffer)
       end
 
       private
 
       def parse_options
-        options = { format: "text", trace: false, config: nil }
+        options = { format: "text", trace: false, config: nil, tmp_file: nil, instead_of: nil }
 
         parser = OptionParser.new do |opts|
           opts.banner = USAGE
           opts.on("--format=FORMAT", "Output format: text or json") { |value| options[:format] = value }
           opts.on("--trace", "Record fail-soft fallbacks via FallbackTracer") { options[:trace] = true }
           opts.on("--config=PATH", "Path to the Rigor configuration file") { |value| options[:config] = value }
+          opts.on("--tmp-file=PATH",
+                  "Editor mode: read source bytes from PATH instead of --instead-of (paired)") do |value|
+            options[:tmp_file] = value
+          end
+          opts.on("--instead-of=PATH",
+                  "Editor mode: the logical project path the buffer represents (paired with --tmp-file)") do |value|
+            options[:instead_of] = value
+          end
         end
         parser.parse!(@argv)
 
         options
       end
 
-      def execute(target:, options:)
+      # Mirrors `Rigor::CLI#resolve_buffer_binding` (the `check`
+      # path). Returns nil / BufferBinding / :usage_error. The
+      # symbol return path lets the caller translate to
+      # `CLI::EXIT_USAGE` without raising.
+      def resolve_buffer_binding(options)
+        tmp = options[:tmp_file]
+        instead = options[:instead_of]
+        return nil if tmp.nil? && instead.nil?
+
+        if tmp.nil? || instead.nil?
+          @err.puts("--tmp-file and --instead-of must appear together")
+          return :usage_error
+        end
+
+        unless File.file?(tmp)
+          @err.puts("--tmp-file #{tmp.inspect}: no such file or not readable")
+          return :usage_error
+        end
+
+        Rigor::Analysis::BufferBinding.new(logical_path: instead, physical_path: tmp)
+      end
+
+      def execute(target:, options:, buffer: nil)
         file, line, column = target
-        return 1 unless file_exists?(file)
+        # Under editor mode the logical `file` may not exist on disk
+        # (user editing a new file); the runtime check is only that
+        # the BUFFER is readable, which `resolve_buffer_binding`
+        # has already enforced. For non-editor mode `file` must
+        # exist.
+        physical = buffer ? buffer.resolve(file) : file
+        return 1 unless file_exists?(buffer ? physical : file)
 
         configuration = Configuration.load(options.fetch(:config))
-        source = File.read(file)
+        source = File.read(physical)
         parse_result = Prism.parse(source, filepath: file, version: configuration.target_ruby)
         return 1 if parse_errors?(parse_result, file)