evilution 0.5.0 → 0.7.0

data/lib/evilution/config.rb

@@ -18,32 +18,21 @@ module Evilution
       quiet: false,
       jobs: 1,
       fail_fast: nil,
+      baseline: true,
+      isolation: :auto,
       line_ranges: {},
       spec_files: []
     }.freeze
 
     attr_reader :target_files, :timeout, :format, :diff_base,
                 :target, :min_score, :integration, :coverage, :verbose, :quiet,
-                :jobs, :fail_fast, :line_ranges, :spec_files
+                :jobs, :fail_fast, :baseline, :isolation, :line_ranges, :spec_files
 
     def initialize(**options)
       file_options = options.delete(:skip_config_file) ? {} : load_config_file
       merged = DEFAULTS.merge(file_options).merge(options)
       warn_removed_options(merged, file_options)
-      @target_files = Array(merged[:target_files])
-      @timeout = merged[:timeout]
-      @format = merged[:format].to_sym
-      @diff_base = merged[:diff_base]
-      @target = merged[:target]
-      @min_score = merged[:min_score].to_f
-      @integration = merged[:integration].to_sym
-      @coverage = merged[:coverage]
-      @verbose = merged[:verbose]
-      @quiet = merged[:quiet]
-      @jobs = validate_jobs(merged[:jobs])
-      @fail_fast = validate_fail_fast(merged[:fail_fast])
-      @line_ranges = merged[:line_ranges] || {}
-      @spec_files = Array(merged[:spec_files])
+      assign_attributes(merged)
       freeze
     end
 
@@ -71,6 +60,10 @@ module Evilution
       !fail_fast.nil?
     end
 
+    def baseline?
+      baseline
+    end
+
     def self.file_options
       CONFIG_FILES.each do |path|
         next unless File.exist?(path)
@@ -128,6 +121,34 @@ module Evilution
       raise ConfigError, "fail_fast must be a positive integer, got #{value.inspect}"
     end
 
+    def assign_attributes(merged)
+      @target_files = Array(merged[:target_files])
+      @timeout = merged[:timeout]
+      @format = merged[:format].to_sym
+      @diff_base = merged[:diff_base]
+      @target = merged[:target]
+      @min_score = merged[:min_score].to_f
+      @integration = merged[:integration].to_sym
+      @coverage = merged[:coverage]
+      @verbose = merged[:verbose]
+      @quiet = merged[:quiet]
+      @jobs = validate_jobs(merged[:jobs])
+      @fail_fast = validate_fail_fast(merged[:fail_fast])
+      @baseline = merged[:baseline]
+      @isolation = validate_isolation(merged[:isolation])
+      @line_ranges = merged[:line_ranges] || {}
+      @spec_files = Array(merged[:spec_files])
+    end
+
+    def validate_isolation(value)
+      raise ConfigError, "isolation must be auto, fork, or in_process, got nil" if value.nil?
+
+      value = value.to_sym
+      raise ConfigError, "isolation must be auto, fork, or in_process, got #{value.inspect}" unless %i[auto fork in_process].include?(value)
+
+      value
+    end
+
     def validate_jobs(value)
       raise ConfigError, "jobs must be a positive integer, got #{value.inspect}" if value.is_a?(Float)
 

data/lib/evilution/isolation/fork.rb

@@ -2,6 +2,7 @@
 
 require "fileutils"
 require "tmpdir"
+require_relative "../memory"
 
 module Evilution
   module Isolation
@@ -51,7 +52,8 @@ module Evilution
       end
 
       def execute_in_child(mutation, test_command)
-        test_command.call(mutation)
+        result = test_command.call(mutation)
+        { child_rss_kb: Memory.rss_kb }.merge(result)
       rescue StandardError => e
         { passed: false, error: e.message }
       end
@@ -98,7 +100,8 @@ module Evilution
           mutation: mutation,
           status: status,
           duration: duration,
-          test_command: result[:test_command]
+          test_command: result[:test_command],
+          child_rss_kb: result[:child_rss_kb]
         )
       end
     end

data/lib/evilution/isolation/in_process.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "timeout"
+require_relative "../memory"
+require_relative "../result/mutation_result"
+
+module Evilution
+  module Isolation
+    class InProcess
+      def call(mutation:, test_command:, timeout:)
+        start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        rss_before = Memory.rss_kb
+        result = execute_with_timeout(mutation, test_command, timeout)
+        rss_after = Memory.rss_kb
+        duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
+        delta = compute_memory_delta(rss_before, rss_after, result)
+
+        build_mutation_result(mutation, result, duration, rss_after, delta)
+      end
+
+      private
+
+      def execute_with_timeout(mutation, test_command, timeout)
+        result = Timeout.timeout(timeout) do
+          suppress_output { test_command.call(mutation) }
+        end
+        { timeout: false }.merge(result)
+      rescue Timeout::Error
+        { timeout: true }
+      rescue StandardError => e
+        { timeout: false, passed: false, error: e.message }
+      end
+
+      def suppress_output
+        saved_stdout = $stdout
+        saved_stderr = $stderr
+        File.open(File::NULL, "w") do |null_out|
+          File.open(File::NULL, "w") do |null_err|
+            $stdout = null_out
+            $stderr = null_err
+            yield
+          end
+        end
+      ensure
+        $stdout = saved_stdout
+        $stderr = saved_stderr
+      end
+
+      def compute_memory_delta(rss_before, rss_after, result)
+        return nil if result[:timeout]
+        return nil unless rss_before && rss_after
+
+        rss_after - rss_before
+      end
+
+      def build_mutation_result(mutation, result, duration, rss_after, memory_delta_kb)
+        status = if result[:timeout]
+                   :timeout
+                 elsif result[:error]
+                   :error
+                 elsif result[:passed]
+                   :survived
+                 else
+                   :killed
+                 end
+
+        Result::MutationResult.new(
+          mutation: mutation,
+          status: status,
+          duration: duration,
+          test_command: result[:test_command],
+          child_rss_kb: rss_after,
+          memory_delta_kb: memory_delta_kb
+        )
+      end
+    end
+  end
+end

data/lib/evilution/mcp/mutate_tool.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require "json"
+require "mcp"
+require_relative "../config"
+require_relative "../runner"
+require_relative "../reporter/json"
+
+module Evilution
+  module MCP
+    class MutateTool < ::MCP::Tool
+      tool_name "evilution-mutate"
+      description "Run mutation testing on Ruby source files"
+      input_schema(
+        properties: {
+          files: {
+            type: "array",
+            items: { type: "string" },
+            description: "Target files, supports line-range syntax (e.g. lib/foo.rb:15-30)"
+          },
+          target: {
+            type: "string",
+            description: "Only mutate the named method (e.g. Foo#bar)"
+          },
+          timeout: {
+            type: "integer",
+            description: "Per-mutation timeout in seconds (default: 30)"
+          },
+          jobs: {
+            type: "integer",
+            description: "Number of parallel workers (default: 1)"
+          },
+          fail_fast: {
+            type: "integer",
+            description: "Stop after N surviving mutants"
+          },
+          spec: {
+            type: "array",
+            items: { type: "string" },
+            description: "Spec files to run (overrides auto-detection)"
+          }
+        }
+      )
+
+      class << self
+        def call(server_context:, files: [], target: nil, timeout: nil, jobs: nil, fail_fast: nil, spec: nil) # rubocop:disable Lint/UnusedMethodArgument
+          parsed_files, line_ranges = parse_files(Array(files))
+          config_opts = build_config_opts(parsed_files, line_ranges, target, timeout, jobs, fail_fast, spec)
+          config = Config.new(**config_opts)
+          runner = Runner.new(config: config)
+          summary = runner.call
+          report = Reporter::JSON.new.call(summary)
+
+          ::MCP::Tool::Response.new([{ type: "text", text: report }])
+        rescue Evilution::Error => e
+          error_payload = build_error_payload(e)
+          ::MCP::Tool::Response.new([{ type: "text", text: ::JSON.generate(error_payload) }], error: true)
+        end
+
+        private
+
+        def parse_files(raw_files)
+          files = []
+          ranges = {}
+
+          raw_files.each do |arg|
+            file, range_str = arg.split(":", 2)
+            files << file
+            next unless range_str
+
+            ranges[file] = parse_line_range(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 ParseError, "invalid line range: #{str.inspect}"
+        end
+
+        def build_config_opts(files, line_ranges, target, timeout, jobs, fail_fast, spec)
+          opts = { target_files: files, line_ranges: line_ranges, format: :json, quiet: true, skip_config_file: true }
+          opts[:target] = target if target
+          opts[:timeout] = timeout if timeout
+          opts[:jobs] = jobs if jobs
+          opts[:fail_fast] = fail_fast if fail_fast
+          opts[:spec_files] = spec if spec
+          opts
+        end
+
+        def build_error_payload(error)
+          error_type = case error
+                       when ConfigError then "config_error"
+                       when ParseError then "parse_error"
+                       else "runtime_error"
+                       end
+
+          payload = { type: error_type, message: error.message }
+          payload[:file] = error.file if error.file
+          { error: payload }
+        end
+      end
+    end
+  end
+end

data/lib/evilution/mcp/server.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "mcp"
+require_relative "../version"
+require_relative "mutate_tool"
+
+module Evilution
+  module MCP
+    class Server
+      def self.build
+        ::MCP::Server.new(
+          name: "evilution",
+          version: Evilution::VERSION,
+          tools: [MutateTool]
+        )
+      end
+    end
+  end
+end

data/lib/evilution/memory/leak_check.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require_relative "../memory"
+
+module Evilution
+  module Memory
+    class LeakCheck
+      WARMUP_ITERATIONS = 5
+      DEFAULT_ITERATIONS = 50
+      DEFAULT_MAX_GROWTH_KB = 10_240 # 10 MB
+
+      attr_reader :samples
+
+      def initialize(iterations: DEFAULT_ITERATIONS, max_growth_kb: DEFAULT_MAX_GROWTH_KB)
+        @iterations = iterations
+        @max_growth_kb = max_growth_kb
+        @samples = []
+      end
+
+      def run(&)
+        warmup(&)
+        measure(&)
+        result
+      end
+
+      def rss_available?
+        !Evilution::Memory.rss_kb.nil?
+      end
+
+      def growth_kb
+        return nil if samples.any?(&:nil?)
+        return 0 if samples.size < 2
+
+        samples.last - samples.first
+      end
+
+      def passed?
+        kb = growth_kb
+        return false if kb.nil?
+
+        kb <= @max_growth_kb
+      end
+
+      private
+
+      def warmup(&block)
+        WARMUP_ITERATIONS.times { block.call }
+        GC.start
+        GC.compact if GC.respond_to?(:compact)
+      end
+
+      def measure(&)
+        @samples << Evilution::Memory.rss_kb
+
+        @iterations.times do |i|
+          yield
+
+          next unless ((i + 1) % sample_interval).zero?
+
+          GC.start
+          @samples << Evilution::Memory.rss_kb
+        end
+
+        take_final_sample
+      end
+
+      def take_final_sample
+        return if (@iterations % sample_interval).zero?
+
+        GC.start
+        @samples << Evilution::Memory.rss_kb
+      end
+
+      def sample_interval
+        @sample_interval ||= [@iterations / 10, 1].max
+      end
+
+      def result
+        {
+          passed: passed?,
+          growth_kb: growth_kb,
+          growth_mb: growth_kb ? growth_kb / 1024.0 : nil,
+          samples: samples,
+          iterations: @iterations,
+          max_growth_kb: @max_growth_kb,
+          rss_available: rss_available?
+        }
+      end
+    end
+  end
+end

data/lib/evilution/memory.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Evilution
+  module Memory
+    PROC_STATUS_PATH = "/proc/%d/status"
+    RSS_PATTERN = /VmRSS:\s+(\d+)\s+kB/
+
+    module_function
+
+    def rss_kb
+      rss_kb_for(Process.pid)
+    end
+
+    def rss_mb
+      kb = rss_kb
+      return nil unless kb
+
+      kb / 1024.0
+    end
+
+    def rss_kb_for(pid)
+      path = format(PROC_STATUS_PATH, pid)
+      content = File.read(path)
+      match = content.match(RSS_PATTERN)
+      return nil unless match
+
+      match[1].to_i
+    rescue Errno::ENOENT, Errno::EACCES, Errno::ESRCH
+      nil
+    end
+
+    def delta
+      before = rss_kb
+      result = yield
+      after = rss_kb
+      delta_kb = before && after ? after - before : nil
+      [result, delta_kb]
+    end
+  end
+end

data/lib/evilution/mutation.rb

@@ -16,10 +16,22 @@ module Evilution
       @file_path = file_path
       @line = line
       @column = column
-      freeze
+      @diff = nil
     end
 
     def diff
+      @diff ||= compute_diff
+    end
+
+    def strip_sources!
+      diff # ensure diff is cached before clearing sources
+      @original_source = nil
+      @mutated_source = nil
+    end
+
+    private
+
+    def compute_diff
       original_lines = original_source.lines
       mutated_lines = mutated_source.lines
       diffs = ::Diff::LCS.diff(original_lines, mutated_lines)
@@ -38,6 +50,8 @@ module Evilution
       result.join("\n")
     end
 
+    public
+
     def to_s
       "#{operator_name}: #{file_path}:#{line}"
     end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Evilution
+  module Mutator
+    module Operator
+      class ArgumentRemoval < Base
+        SKIP_TYPES = [
+          Prism::SplatNode,
+          Prism::KeywordHashNode,
+          Prism::BlockArgumentNode,
+          Prism::ForwardingArgumentsNode
+        ].freeze
+
+        def visit_call_node(node)
+          args = node.arguments&.arguments
+
+          if args && args.length >= 2 && positional_only?(args)
+            args.each_index do |i|
+              remaining = args.each_with_index.filter_map { |a, j| a.slice if j != i }
+              replacement = remaining.join(", ")
+
+              add_mutation(
+                offset: node.arguments.location.start_offset,
+                length: node.arguments.location.length,
+                replacement:,
+                node:
+              )
+            end
+          end
+
+          super
+        end
+
+        private
+
+        def positional_only?(args)
+          args.none? { |arg| SKIP_TYPES.any? { |type| arg.is_a?(type) } }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Evilution
+  module Mutator
+    module Operator
+      class MethodCallRemoval < Base
+        def visit_call_node(node)
+          if node.receiver
+            add_mutation(
+              offset: node.location.start_offset,
+              length: node.location.length,
+              replacement: node.receiver.slice,
+              node: node
+            )
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/evilution/mutator/registry.rb

@@ -23,7 +23,9 @@ module Evilution
           Operator::MethodBodyReplacement,
           Operator::NegationInsertion,
           Operator::ReturnValueRemoval,
-          Operator::CollectionReplacement
+          Operator::CollectionReplacement,
+          Operator::MethodCallRemoval,
+          Operator::ArgumentRemoval
         ].each { |op| registry.register(op) }
         registry
       end

data/lib/evilution/reporter/cli.rb

@@ -13,15 +13,10 @@ module Evilution
         lines << mutations_line(summary)
         lines << score_line(summary)
         lines << duration_line(summary)
-
-        if summary.survived_results.any?
-          lines << ""
-          lines << "Survived mutations:"
-          summary.survived_results.each do |result|
-            lines << format_survived(result)
-          end
-        end
-
+        peak = summary.peak_memory_mb
+        lines << peak_memory_line(peak) if peak
+        append_survived(lines, summary)
+        append_neutral(lines, summary)
         lines << ""
         lines << "[TRUNCATED] Stopped early due to --fail-fast" if summary.truncated?
         lines << result_line(summary)
@@ -31,17 +26,35 @@ module Evilution
 
       private
 
+      def append_survived(lines, summary)
+        return unless summary.survived_results.any?
+
+        lines << ""
+        lines << "Survived mutations:"
+        summary.survived_results.each { |result| lines << format_survived(result) }
+      end
+
+      def append_neutral(lines, summary)
+        return unless summary.neutral_results.any?
+
+        lines << ""
+        lines << "Neutral mutations (test already failing):"
+        summary.neutral_results.each { |result| lines << format_neutral(result) }
+      end
+
       def header
         "Evilution v#{Evilution::VERSION} — Mutation Testing Results"
       end
 
       def mutations_line(summary)
-        "Mutations: #{summary.total} total, #{summary.killed} killed, " \
-          "#{summary.survived} survived, #{summary.timed_out} timed out"
+        parts = "Mutations: #{summary.total} total, #{summary.killed} killed, " \
+                "#{summary.survived} survived, #{summary.timed_out} timed out"
+        parts += ", #{summary.neutral} neutral" if summary.neutral.positive?
+        parts
       end
 
       def score_line(summary)
-        denominator = summary.total - summary.errors
+        denominator = summary.total - summary.errors - summary.neutral
         score_pct = format_pct(summary.score)
         "Score: #{score_pct} (#{summary.killed}/#{denominator})"
       end
@@ -57,6 +70,11 @@ module Evilution
         "  #{mutation.operator_name}: #{location}\n#{diff_lines}"
       end
 
+      def format_neutral(result)
+        mutation = result.mutation
+        "  #{mutation.operator_name}: #{mutation.file_path}:#{mutation.line}"
+      end
+
       def result_line(summary)
         min_score = 0.8
         pass_fail = summary.success?(min_score: min_score) ? "PASS" : "FAIL"
@@ -65,6 +83,10 @@ module Evilution
         "Result: #{pass_fail} (score #{score_pct} #{pass_fail == "PASS" ? ">=" : "<"} #{threshold_pct})"
       end
 
+      def peak_memory_line(peak_mb)
+        format("Peak memory: %<mb>.1f MB", mb: peak_mb)
+      end
+
       def format_pct(value)
         format("%.2f%%", value * 100)
       end

data/lib/evilution/reporter/json.rb

@@ -24,6 +24,7 @@ module Evilution
           summary: build_summary(summary),
           survived: summary.survived_results.map { |r| build_mutation_detail(r) },
           killed: summary.killed_results.map { |r| build_mutation_detail(r) },
+          neutral: summary.neutral_results.map { |r| build_mutation_detail(r) },
           timed_out: summary.results.select(&:timeout?).map { |r| build_mutation_detail(r) },
           errors: summary.results.select(&:error?).map { |r| build_mutation_detail(r) }
         }
@@ -36,10 +37,13 @@ module Evilution
           survived: summary.survived,
           timed_out: summary.timed_out,
           errors: summary.errors,
+          neutral: summary.neutral,
           score: summary.score.round(4),
           duration: summary.duration.round(4)
         }
         data[:truncated] = true if summary.truncated?
+        peak = summary.peak_memory_mb
+        data[:peak_memory_mb] = peak.round(1) if peak
         data
       end
 
@@ -55,6 +59,8 @@ module Evilution
         }
         detail[:suggestion] = @suggestion.suggestion_for(mutation) if result.status == :survived
         detail[:test_command] = result.test_command if result.test_command
+        detail[:child_rss_kb] = result.child_rss_kb if result.child_rss_kb
+        detail[:memory_delta_kb] = result.memory_delta_kb if result.memory_delta_kb
         detail
       end
     end

data/lib/evilution/reporter/suggestion.rb

@@ -21,7 +21,9 @@ module Evilution
         "method_body_replacement" => "Add a test that checks the method's return value or side effects",
         "negation_insertion" => "Add a test where the predicate result matters (not just truthiness)",
         "return_value_removal" => "Add a test that uses the return value of this method",
-        "collection_replacement" => "Add a test that checks the return value of the collection operation, not just side effects"
+        "collection_replacement" => "Add a test that checks the return value of the collection operation, not just side effects",
+        "method_call_removal" => "Add a test that depends on the return value or side effect of this method call",
+        "argument_removal" => "Add a test that verifies the correct arguments are passed to this method call"
       }.freeze
 
       DEFAULT_SUGGESTION = "Add a more specific test that detects this mutation"