evilution 0.26.0 → 0.28.0

data/lib/evilution/mcp/info_tool.rb

@@ -13,25 +13,30 @@ require_relative "../version"
 require_relative "../mcp"
 
 class Evilution::MCP::InfoTool < MCP::Tool
+  VALID_ACTIONS = %w[subjects tests environment statuses feedback].freeze
+
   tool_name "evilution-info"
   description "Discover what evilution sees before running any mutations. " \
-              "One tool, four actions: " \
+              "One tool, five actions: " \
               "'subjects' lists every mutatable method in the target files with its file, line, and mutation count; " \
               "'tests' resolves which spec/test files cover the given sources (so you pick the right --spec before mutating); " \
               "'environment' dumps the effective config (version, ruby, config file, timeout, " \
               "integration, isolation, and every other setting); " \
               "'statuses' returns the mutation-result status glossary (killed/survived/neutral/error/etc.) with " \
-              "per-status meaning and scoring semantics so agents can triage results without guessing. " \
+              "per-status meaning and scoring semantics so agents can triage results without guessing; " \
+              "'feedback' returns the public discussion URL plus consent and privacy guidance for posting " \
+              "feedback on errors, usage problems, friction, or missing capabilities. " \
               "Use this instead of shelling out to 'evilution subjects', 'evilution tests list', or 'evilution environment show' — " \
               "the response is structured JSON so you can plan the next mutation run without parsing CLI text."
   input_schema(
     properties: {
       action: {
         type: "string",
-        enum: %w[subjects tests environment statuses],
+        enum: VALID_ACTIONS,
         description: "Which discovery operation to perform. " \
                      "'subjects' lists mutatable methods; 'tests' resolves specs for sources; " \
-                     "'environment' dumps effective config; 'statuses' returns the result-status glossary."
+                     "'environment' dumps effective config; 'statuses' returns the result-status glossary; " \
+                     "'feedback' returns the discussion URL and consent/privacy guidance."
       },
       files: {
         type: "array",
@@ -64,270 +69,45 @@ class Evilution::MCP::InfoTool < MCP::Tool
     required: ["action"]
   )
 
-  VALID_ACTIONS = %w[subjects tests environment statuses].freeze
-
-  STATUS_GLOSSARY = [
-    {
-      "status" => "killed",
-      "meaning" => "A test failed when the mutation was applied — the test suite caught the mutation. " \
-                   "This is the desired outcome.",
-      "counted_in_score" => true
-    },
-    {
-      "status" => "survived",
-      "meaning" => "No test failed when the mutation was applied — gap in coverage. " \
-                   "The test suite did not detect the behavioral change.",
-      "counted_in_score" => true
-    },
-    {
-      "status" => "timeout",
-      "meaning" => "Test run exceeded the configured per-mutation timeout. " \
-                   "Treated like survived for scoring (counted in the denominator); " \
-                   "may indicate an infinite loop introduced by the mutation.",
-      "counted_in_score" => true
-    },
-    {
-      "status" => "error",
-      "meaning" => "Mutation execution raised an unexpected error (syntax error at load time, " \
-                   "boot failure, test-infrastructure crash). The mutation could not be evaluated.",
-      "counted_in_score" => false
-    },
-    {
-      "status" => "neutral",
-      "meaning" => "Baseline tests already failed before the mutation was applied — pre-existing " \
-                   "test-suite problem (flaky spec, infra collision, fixture setup failure). " \
-                   "Not a meaningful mutation signal.",
-      "counted_in_score" => false
-    },
-    {
-      "status" => "equivalent",
-      "meaning" => "Mutation is provably identical to the original source " \
-                   "(e.g. a no-op replacement that the parser or evaluator treats as semantically equal).",
-      "counted_in_score" => false
-    },
-    {
-      "status" => "unresolved",
-      "meaning" => "No spec/test file resolved for the mutated source — coverage gap, not a failure. " \
-                   "The file has no corresponding test file the resolver could locate.",
-      "counted_in_score" => false
-    },
-    {
-      "status" => "unparseable",
-      "meaning" => "Mutated source failed to parse (e.g. dangling heredoc after method_body_replacement). " \
-                   "Short-circuited before execution; no test run was attempted.",
-      "counted_in_score" => false
-    }
-  ].freeze
-  private_constant :STATUS_GLOSSARY
-
   class << self
-    # rubocop:disable Lint/UnusedMethodArgument
     def call(server_context:, action: nil, files: nil, target: nil, spec: nil, integration: nil, skip_config: nil)
-      return error_response("config_error", "action is required") unless action
-      return error_response("config_error", "unknown action: #{action}") unless VALID_ACTIONS.include?(action)
-
-      parsed_files, line_ranges = parse_files(Array(files)) if files
-
-      case action
-      when "subjects"
-        subjects_action(files: parsed_files, line_ranges: line_ranges, target: target,
-                        integration: integration, skip_config: skip_config)
-      when "tests"
-        tests_action(files: parsed_files, spec: spec, integration: integration, skip_config: skip_config)
-      when "environment"
-        environment_action
-      when "statuses"
-        statuses_action
-      end
-    rescue Evilution::Error => e
-      error_response_for(e)
-    end
-    # rubocop:enable Lint/UnusedMethodArgument
-
-    private
-
-    def parse_files(raw_files)
-      files = []
-      ranges = {}
-
-      raw_files.each do |arg|
-        file, range_str = arg.split(":", 2)
-        files << file
-        ranges[file] = parse_line_range(range_str) if range_str
-      end
-
-      [files, ranges]
-    end
-
-    def parse_line_range(str)
-      if str.include?("-")
-        start_str, end_str = str.split("-", 2)
-        start_line = Integer(start_str)
-        end_line = end_str.empty? ? Float::INFINITY : Integer(end_str)
-        start_line..end_line
-      else
-        line = Integer(str)
-        line..line
-      end
-    rescue ArgumentError, TypeError
-      raise Evilution::ParseError, "invalid line range: #{str.inspect}"
-    end
-
-    def subjects_action(files:, line_ranges:, target:, integration:, skip_config:)
-      return error_response("config_error", "files is required") if files.nil? || files.empty?
-
-      config = build_subjects_config(files: files, line_ranges: line_ranges,
-                                     target: target, integration: integration, skip_config: skip_config)
-      runner = Evilution::Runner.new(config: config)
-      subjects = runner.parse_and_filter_subjects
-
-      registry = Evilution::Mutator::Registry.default
-      filter = build_subject_filter(config)
-      operator_options = { skip_heredoc_literals: config.skip_heredoc_literals? }
-
-      entries = subjects.map do |subj|
-        count = registry.mutations_for(subj, filter: filter, operator_options: operator_options).length
-        { "name" => subj.name, "file" => subj.file_path, "line" => subj.line_number, "mutations" => count }
-      ensure
-        subj.release_node!
-      end
-
-      success_response(
-        "subjects" => entries,
-        "total_subjects" => entries.length,
-        "total_mutations" => entries.sum { |e| e["mutations"] }
-      )
-    end
-
-    def tests_action(files:, spec:, integration:, skip_config:)
-      return error_response("config_error", "files is required") if files.nil? || files.empty?
-
-      config = build_tests_config(files: files, spec: spec, integration: integration, skip_config: skip_config)
-      return explicit_specs_response(files, config.spec_files) if config.spec_files.any?
-
-      resolver = resolver_for_integration(config.integration)
-      resolved, unresolved = resolve_specs(files, resolver)
-      success_response(
-        "specs" => resolved,
-        "unresolved" => unresolved,
-        "total_sources" => files.length,
-        "total_specs" => resolved.map { |r| r["spec"] }.uniq.length
-      )
-    end
-
-    def build_subjects_config(files:, line_ranges:, target:, integration:, skip_config:)
-      opts = { target_files: files, line_ranges: line_ranges || {} }
-      opts[:skip_config_file] = true if skip_config
-      opts[:target] = target if target
-      opts[:integration] = integration if integration
-      Evilution::Config.new(**opts)
-    end
-
-    def build_tests_config(files:, spec:, integration:, skip_config:)
-      opts = { target_files: files }
-      opts[:skip_config_file] = true if skip_config
-      opts[:spec_files] = spec if spec
-      opts[:integration] = integration if integration
-      Evilution::Config.new(**opts)
-    end
-
-    def resolver_for_integration(integration)
-      integration_class = Evilution::Runner::INTEGRATIONS[integration.to_sym]
-      return Evilution::SpecResolver.new unless integration_class
-
-      integration_class.baseline_options[:spec_resolver] || Evilution::SpecResolver.new
-    end
-
-    def explicit_specs_response(files, spec_files)
-      success_response(
-        "specs" => spec_files.map { |f| { "source" => nil, "spec" => f } },
-        "unresolved" => [],
-        "total_sources" => files.length,
-        "total_specs" => spec_files.length
-      )
-    end
-
-    def resolve_specs(files, resolver)
-      resolved = []
-      unresolved = []
-      files.each do |source|
-        found = resolver.call(source)
-        if found
-          resolved << { "source" => source, "spec" => found }
-        else
-          unresolved << source
-        end
-      end
-      [resolved, unresolved]
-    end
-
-    def environment_action
-      config = Evilution::Config.new(skip_config_file: false)
-      config_file = Evilution::Config::CONFIG_FILES.find { |path| File.exist?(path) }
-
-      success_response(
-        "version" => Evilution::VERSION,
-        "ruby" => RUBY_VERSION,
-        "config_file" => config_file,
-        "settings" => environment_settings(config)
-      )
-    end
-
-    def statuses_action
-      # Guard against drift: every STATUSES symbol must have a glossary entry.
-      defined = Evilution::Result::MutationResult::STATUSES.map(&:to_s).sort
-      documented = STATUS_GLOSSARY.map { |s| s["status"] }.sort
-      if defined != documented
-        missing = (defined - documented) + (documented - defined)
-        raise Evilution::Error, "status glossary drift: #{missing.inspect}"
-      end
-
-      success_response("statuses" => STATUS_GLOSSARY)
-    end
-
-    def error_response_for(error)
-      type = case error
-             when Evilution::ConfigError then "config_error"
-             when Evilution::ParseError then "parse_error"
-             else "runtime_error"
-             end
-      error_response(type, error.message)
-    end
-
-    def environment_settings(config)
-      {
-        "timeout" => config.timeout,
-        "format" => config.format,
-        "integration" => config.integration,
-        "jobs" => config.jobs,
-        "isolation" => config.isolation,
-        "baseline" => config.baseline,
-        "incremental" => config.incremental,
-        "fail_fast" => config.fail_fast,
-        "min_score" => config.min_score,
-        "suggest_tests" => config.suggest_tests,
-        "save_session" => config.save_session,
-        "target" => config.target,
-        "skip_heredoc_literals" => config.skip_heredoc_literals,
-        "ignore_patterns" => config.ignore_patterns
-      }
-    end
-
-    def build_subject_filter(config)
-      return nil if config.ignore_patterns.empty?
-
-      Evilution::AST::Pattern::Filter.new(config.ignore_patterns)
-    end
+      return ResponseFormatter.error("config_error", "action is required") unless action
+      return ResponseFormatter.error("config_error", "unknown action: #{action}") unless ACTIONS.key?(action)
 
-    def success_response(payload)
-      ::MCP::Tool::Response.new([{ type: "text", text: ::JSON.generate(payload) }])
-    end
+      parsed_files, line_ranges = RequestParser.parse_files(Array(files)) if files
 
-    def error_response(type, message)
-      ::MCP::Tool::Response.new(
-        [{ type: "text", text: ::JSON.generate({ error: { type: type, message: message } }) }],
-        error: true
+      ACTIONS[action].call(
+        files: parsed_files, line_ranges: line_ranges, target: target, spec: spec,
+        integration: integration, skip_config: skip_config
       )
+    rescue Evilution::Error => e
+      ResponseFormatter.error_for(e)
     end
   end
 end
+
+require_relative "info_tool/request_parser"
+require_relative "info_tool/error_mapper"
+require_relative "info_tool/response_formatter"
+require_relative "info_tool/status_glossary"
+require_relative "info_tool/config_factory"
+require_relative "info_tool/actions"
+require_relative "info_tool/actions/base"
+require_relative "info_tool/actions/subjects"
+require_relative "info_tool/actions/tests"
+require_relative "info_tool/actions/environment"
+require_relative "info_tool/actions/statuses"
+require_relative "info_tool/actions/feedback"
+
+Evilution::MCP::InfoTool.const_set(:ACTIONS, {
+  "subjects" => Evilution::MCP::InfoTool::Actions::Subjects,
+  "tests" => Evilution::MCP::InfoTool::Actions::Tests,
+  "environment" => Evilution::MCP::InfoTool::Actions::Environment,
+  "statuses" => Evilution::MCP::InfoTool::Actions::Statuses,
+  "feedback" => Evilution::MCP::InfoTool::Actions::Feedback
+}.freeze)
+Evilution::MCP::InfoTool.send(:private_constant, :ACTIONS)
+
+unless Evilution::MCP::InfoTool.send(:const_get, :ACTIONS).keys == Evilution::MCP::InfoTool::VALID_ACTIONS
+  raise "InfoTool action drift: ACTIONS keys do not match VALID_ACTIONS"
+end

data/lib/evilution/mcp/mutate_tool/error_payload.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require_relative "../mutate_tool"
+require_relative "../../feedback"
+require_relative "../../feedback/messages"
 
 module Evilution::MCP::MutateTool::ErrorPayload
   def self.build(error)
@@ -12,6 +14,11 @@ module Evilution::MCP::MutateTool::ErrorPayload
 
     payload = { type: type, message: error.message }
     payload[:file] = error.file if error.file
-    { error: payload }
+
+    {
+      error: payload,
+      feedback_url: Evilution::Feedback::DISCUSSION_URL,
+      feedback_hint: Evilution::Feedback::Messages.mcp_hint
+    }
   end
 end

data/lib/evilution/mcp/mutate_tool/progress_streamer.rb

@@ -10,15 +10,19 @@ module Evilution::MCP::MutateTool::ProgressStreamer
 
     suggestion = Evilution::Reporter::Suggestion.new(suggest_tests: true, integration: integration)
     survivor_index = 0
+    disabled = false
 
     proc do |result|
       next unless result.survived?
+      next if disabled
 
       begin
         survivor_index += 1
         detail = build_suggestion_detail(result.mutation, suggestion)
         server_context.report_progress(survivor_index, message: ::JSON.generate(detail))
-      rescue StandardError # rubocop:disable Lint/SuppressedException
+      rescue StandardError => e
+        warn "[evilution] progress stream disabled after error: #{e.class}: #{e.message}"
+        disabled = true
       end
     end
   end

data/lib/evilution/mcp/mutate_tool/report_trimmer.rb

@@ -2,13 +2,16 @@
 
 require "json"
 require_relative "../mutate_tool"
+require_relative "../../feedback"
+require_relative "../../feedback/detector"
+require_relative "../../feedback/messages"
 
 module Evilution::MCP::MutateTool::ReportTrimmer
   MINIMAL_KEYS = %w[summary survived].freeze
   FULL_DIFF_STRIP_KEYS = %w[killed neutral equivalent unresolved unparseable].freeze
   SUMMARY_DROP_KEYS = %w[killed neutral equivalent unparseable].freeze
 
-  def self.call(json_string, verbosity:, survived_results:, config:, enricher:)
+  def self.call(json_string, verbosity:, survived_results:, config:, enricher:, summary: nil)
     data = ::JSON.parse(json_string)
     case verbosity
     when "full"
@@ -19,6 +22,7 @@ module Evilution::MCP::MutateTool::ReportTrimmer
       data.keep_if { |key, _| MINIMAL_KEYS.include?(key) }
     end
     enricher.call(data, survived_results, config)
+    embed_feedback(data, summary) unless verbosity == "minimal"
     ::JSON.generate(data)
   end
 
@@ -28,4 +32,12 @@ module Evilution::MCP::MutateTool::ReportTrimmer
     data[key].each { |entry| entry.delete("diff") }
   end
   private_class_method :strip_diffs
+
+  def self.embed_feedback(data, summary)
+    return unless Evilution::Feedback::Detector.friction?(summary)
+
+    data["feedback_url"]  = Evilution::Feedback::DISCUSSION_URL
+    data["feedback_hint"] = Evilution::Feedback::Messages.mcp_hint
+  end
+  private_class_method :embed_feedback
 end

data/lib/evilution/mcp/mutate_tool.rb

@@ -26,7 +26,9 @@ class Evilution::MCP::MutateTool < MCP::Tool
               "'subject' (Class#method), resolved 'spec_file', and a concrete 'next_step' hint — " \
               "so the agent can jump straight to writing the missing test. " \
               "Prefer this over shelling out to 'evilution' — the response is machine-readable " \
-              "and already trimmed for survived-mutant triage."
+              "and already trimmed for survived-mutant triage. " \
+              "Hitting errors, friction, or missing capabilities? See evilution-info action=feedback for the " \
+              "public feedback channel — ask the user before posting anything."
   input_schema(
     properties: {
       files: {
@@ -126,7 +128,8 @@ class Evilution::MCP::MutateTool < MCP::Tool
         verbosity: normalized_verbosity,
         survived_results: summary.survived_results,
         config: config,
-        enricher: Evilution::MCP::MutateTool::SurvivedEnricher
+        enricher: Evilution::MCP::MutateTool::SurvivedEnricher,
+        summary: summary
       )
 
       ::MCP::Tool::Response.new([{ type: "text", text: compact }])

data/lib/evilution/mcp/session_tool.rb

@@ -51,7 +51,6 @@ class Evilution::MCP::SessionTool < MCP::Tool
   VALID_ACTIONS = %w[list show diff].freeze
 
   class << self
-    # rubocop:disable Lint/UnusedMethodArgument
     def call(server_context:, action: nil, results_dir: nil, limit: nil, path: nil, base: nil, head: nil)
       return error_response("config_error", "action is required") unless action
       return error_response("config_error", "unknown action: #{action}") unless VALID_ACTIONS.include?(action)
@@ -62,7 +61,6 @@ class Evilution::MCP::SessionTool < MCP::Tool
       when "diff" then diff_action(base: base, head: head, results_dir: results_dir)
       end
     end
-    # rubocop:enable Lint/UnusedMethodArgument
 
     private
 

data/lib/evilution/mutation.rb

@@ -1,30 +1,53 @@
 # frozen_string_literal: true
 
 require "diff/lcs"
+require_relative "../evilution"
 
 class Evilution::Mutation
-  attr_reader :subject, :operator_name, :original_source,
-              :mutated_source, :original_slice, :mutated_slice,
-              :file_path, :line, :column, :parse_status
-
-  # rubocop:disable Metrics/ParameterLists
-  def initialize(subject:, operator_name:, original_source:, mutated_source:,
-                 file_path:, line:, column: 0, original_slice: nil, mutated_slice: nil,
-                 parse_status: :ok)
-    # rubocop:enable Metrics/ParameterLists
+  Sources = Data.define(:original, :mutated)
+  Slice = Data.define(:original, :mutated)
+  Location = Data.define(:file_path, :line, :column)
+
+  attr_reader :subject, :operator_name, :parse_status, :location
+
+  def initialize(subject:, operator_name:, sources:, location:, slice: nil, parse_status: :ok)
     @subject = subject
     @operator_name = operator_name
-    @original_source = original_source
-    @mutated_source = mutated_source
-    @original_slice = original_slice
-    @mutated_slice = mutated_slice
-    @file_path = file_path
-    @line = line
-    @column = column
+    @sources = sources
+    @location = location
+    @slice = slice
     @parse_status = parse_status
     @diff = nil
   end
 
+  def original_source
+    @sources&.original
+  end
+
+  def mutated_source
+    @sources&.mutated
+  end
+
+  def original_slice
+    @slice&.original
+  end
+
+  def mutated_slice
+    @slice&.mutated
+  end
+
+  def file_path
+    @location.file_path
+  end
+
+  def line
+    @location.line
+  end
+
+  def column
+    @location.column
+  end
+
   def unparseable?
     @parse_status == :unparseable
   end
@@ -41,8 +64,11 @@ class Evilution::Mutation
 
   def strip_sources!
     diff # ensure diff is cached before clearing sources
-    @original_source = nil
-    @mutated_source = nil
+    @sources = nil
+  end
+
+  def to_s
+    "#{operator_name}: #{file_path}:#{line}"
   end
 
   private
@@ -67,10 +93,10 @@ class Evilution::Mutation
   end
 
   def compute_unified_diff
-    return nil if @original_slice.nil? || @mutated_slice.nil?
+    return nil if @slice.nil?
 
-    original_lines = @original_slice.lines
-    mutated_lines = @mutated_slice.lines
+    original_lines = @slice.original.lines
+    mutated_lines = @slice.mutated.lines
     body = ::Diff::LCS.sdiff(original_lines, mutated_lines).map { |c| format_sdiff_change(c) }.join("\n")
     [
       "--- a/#{file_path}",
@@ -88,10 +114,4 @@ class Evilution::Mutation
     when "!" then "-#{change.old_element.chomp}\n+#{change.new_element.chomp}"
     end
   end
-
-  public
-
-  def to_s
-    "#{operator_name}: #{file_path}:#{line}"
-  end
 end

data/lib/evilution/mutator/base.rb

@@ -45,14 +45,14 @@ class Evilution::Mutator::Base < Prism::Visitor
     @mutations << Evilution::Mutation.new(
       subject: @subject,
       operator_name: self.class.operator_name,
-      original_source: @file_source,
-      mutated_source: mutated_source,
-      original_slice: original_slice,
-      mutated_slice: mutated_slice,
-      parse_status: surgery.status,
-      file_path: @subject.file_path,
-      line: node.location.start_line,
-      column: node.location.start_column
+      sources: Evilution::Mutation::Sources.new(original: @file_source, mutated: mutated_source),
+      slice: Evilution::Mutation::Slice.new(original: original_slice, mutated: mutated_slice),
+      location: Evilution::Mutation::Location.new(
+        file_path: @subject.file_path,
+        line: node.location.start_line,
+        column: node.location.start_column
+      ),
+      parse_status: surgery.status
     )
   end
 

data/lib/evilution/mutator/operator/block_removal.rb

@@ -4,7 +4,7 @@ require_relative "../operator"
 
 class Evilution::Mutator::Operator::BlockRemoval < Evilution::Mutator::Base
   def visit_call_node(node)
-    if node.block
+    if node.block && !node.block.is_a?(Prism::BlockArgumentNode)
       block_node = node.block
       call_end = block_node.location.start_offset
       call_start = node.location.start_offset

data/lib/evilution/mutator/operator/method_body_replacement.rb

@@ -3,11 +3,15 @@
 require_relative "../operator"
 
 class Evilution::Mutator::Operator::MethodBodyReplacement < Evilution::Mutator::Base
-  REPLACEMENTS = %w[nil self super].freeze
+  ALWAYS_SAFE_REPLACEMENTS = %w[nil self].freeze
+  SUPER_REPLACEMENT = "super"
 
   def visit_def_node(node)
     if node.body
-      REPLACEMENTS.each do |replacement|
+      replacements = ALWAYS_SAFE_REPLACEMENTS.dup
+      replacements << SUPER_REPLACEMENT if body_calls_super?(node.body)
+
+      replacements.each do |replacement|
         add_mutation(
           offset: node.body.location.start_offset,
           length: node.body.location.length,
@@ -19,4 +23,16 @@ class Evilution::Mutator::Operator::MethodBodyReplacement < Evilution::Mutator::
 
     super
   end
+
+  private
+
+  # The bare-super replacement raises NoMethodError at runtime when the enclosing
+  # class has no parent implementation of the method. We emit it only when the
+  # original body already calls super, using that as a heuristic that a super
+  # target is intended in this context.
+  def body_calls_super?(node)
+    return true if node.is_a?(Prism::SuperNode) || node.is_a?(Prism::ForwardingSuperNode)
+
+    node.child_nodes.any? { |child| child && body_calls_super?(child) }
+  end
 end

data/lib/evilution/mutator/operator/predicate_to_nil.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::PredicateToNil < Evilution::Mutator::Base
+  def visit_call_node(node)
+    if node.name.to_s.end_with?("?")
+      loc = node.location
+
+      add_mutation(
+        offset: loc.start_offset,
+        length: loc.length,
+        replacement: "nil",
+        node: node
+      )
+    end
+
+    super
+  end
+end