evilution 0.13.0 → 0.15.0

data/lib/evilution/isolation/in_process.rb

@@ -4,75 +4,73 @@ 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)
+require_relative "../isolation"
 
-        build_mutation_result(mutation, result, duration, rss_after, delta)
-      end
+class Evilution::Isolation::InProcess
+  def call(mutation:, test_command:, timeout:)
+    start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    rss_before = Evilution::Memory.rss_kb
+    result = execute_with_timeout(mutation, test_command, timeout)
+    rss_after = Evilution::Memory.rss_kb
+    duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
+    delta = compute_memory_delta(rss_before, rss_after, result)
 
-      private
+    build_mutation_result(mutation, result, duration, rss_after, delta)
+  end
 
-      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
+  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
+  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
+  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
+    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
+  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
+    Evilution::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

data/lib/evilution/isolation.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+module Evilution::Isolation
+end

data/lib/evilution/mcp/mutate_tool.rb

@@ -5,167 +5,196 @@ require "mcp"
 require_relative "../config"
 require_relative "../runner"
 require_relative "../reporter/json"
+require_relative "../reporter/suggestion"
+
+require_relative "../mcp"
+
+class Evilution::MCP::MutateTool < MCP::Tool
+  tool_name "evilution-mutate"
+  description "Run mutation testing on Ruby source files. " \
+              "Use suggest_tests: true to get concrete RSpec test code for surviving mutants."
+  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)"
+      },
+      suggest_tests: {
+        type: "boolean",
+        description: "When true, suggestions for survived mutants include concrete RSpec test code " \
+                     "instead of static description text (default: false)"
+      },
+      verbosity: {
+        type: "string",
+        enum: %w[full summary minimal],
+        description: "Response verbosity: full (all entries, diffs stripped from killed/neutral/equivalent), " \
+                     "summary (omits killed/neutral/equivalent arrays; default), " \
+                     "minimal (only summary + survived)"
+      }
+    }
+  )
+
+  class << self
+    # rubocop:disable Metrics/ParameterLists
+    def call(server_context:, files: [], target: nil, timeout: nil, jobs: nil,
+             fail_fast: nil, spec: nil, suggest_tests: nil, verbosity: nil)
+      parsed_files, line_ranges = parse_files(Array(files))
+      config_opts = build_config_opts(parsed_files, line_ranges, target, timeout, jobs, fail_fast, spec,
+                                      suggest_tests)
+      config = Evilution::Config.new(**config_opts)
+      on_result = build_streaming_callback(server_context, suggest_tests)
+      runner = Evilution::Runner.new(config: config, on_result: on_result)
+      summary = runner.call
+      report = Evilution::Reporter::JSON.new(suggest_tests: suggest_tests == true).call(summary)
+      compact = trim_report(report, normalize_verbosity(verbosity))
+
+      ::MCP::Tool::Response.new([{ type: "text", text: compact }])
+    rescue Evilution::Error => e
+      error_payload = build_error_payload(e)
+      ::MCP::Tool::Response.new([{ type: "text", text: ::JSON.generate(error_payload) }], error: true)
+    end
+    # rubocop:enable Metrics/ParameterLists
 
-module Evilution
-  module MCP
-    class MutateTool < ::MCP::Tool
-      tool_name "evilution-mutate"
-      description "Run mutation testing on Ruby source files. " \
-                  "Use suggest_tests: true to get concrete RSpec test code for surviving mutants."
-      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)"
-          },
-          suggest_tests: {
-            type: "boolean",
-            description: "When true, suggestions for survived mutants include concrete RSpec test code " \
-                         "instead of static description text (default: false)"
-          },
-          verbosity: {
-            type: "string",
-            enum: %w[full summary minimal],
-            description: "Response verbosity: full (all entries, diffs stripped from killed/neutral/equivalent), " \
-                         "summary (omits killed/neutral/equivalent arrays; default), " \
-                         "minimal (only summary + survived)"
-          }
-        }
-      )
-
-      class << self
-        # rubocop:disable Lint/UnusedMethodArgument,Metrics/ParameterLists
-        def call(server_context:, files: [], target: nil, timeout: nil, jobs: nil,
-                 fail_fast: nil, spec: nil, suggest_tests: nil, verbosity: nil)
-          parsed_files, line_ranges = parse_files(Array(files))
-          config_opts = build_config_opts(parsed_files, line_ranges, target, timeout, jobs, fail_fast, spec,
-                                          suggest_tests)
-          config = Config.new(**config_opts)
-          runner = Runner.new(config: config)
-          summary = runner.call
-          report = Reporter::JSON.new.call(summary)
-          compact = trim_report(report, normalize_verbosity(verbosity))
-
-          ::MCP::Tool::Response.new([{ type: "text", text: compact }])
-        rescue Evilution::Error => e
-          error_payload = build_error_payload(e)
-          ::MCP::Tool::Response.new([{ type: "text", text: ::JSON.generate(error_payload) }], error: true)
-        end
-        # rubocop:enable Lint/UnusedMethodArgument,Metrics/ParameterLists
+    VALID_VERBOSITIES = %w[full summary minimal].freeze
 
-        VALID_VERBOSITIES = %w[full summary minimal].freeze
+    private
 
-        private
+    def parse_files(raw_files)
+      files = []
+      ranges = {}
 
-        def parse_files(raw_files)
-          files = []
-          ranges = {}
+      raw_files.each do |arg|
+        file, range_str = arg.split(":", 2)
+        files << file
+        next unless range_str
 
-          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
 
-            ranges[file] = parse_line_range(range_str)
-          end
+      [files, ranges]
+    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 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, suggest_tests)
+      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[:suggest_tests] = true if suggest_tests
+      opts
+    end
 
-        def build_config_opts(files, line_ranges, target, timeout, jobs, fail_fast, spec, suggest_tests)
-          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[:suggest_tests] = true if suggest_tests
-          opts
-        end
+    def normalize_verbosity(value)
+      normalized = value.to_s.strip.downcase
+      normalized = "summary" if normalized.empty?
+      return normalized if VALID_VERBOSITIES.include?(normalized)
 
-        def normalize_verbosity(value)
-          normalized = value.to_s.strip.downcase
-          normalized = "summary" if normalized.empty?
-          return normalized if VALID_VERBOSITIES.include?(normalized)
+      raise Evilution::ParseError, "invalid verbosity: #{value.inspect} (must be full, summary, or minimal)"
+    end
 
-          raise ParseError, "invalid verbosity: #{value.inspect} (must be full, summary, or minimal)"
-        end
+    def trim_report(json_string, verbosity)
+      data = ::JSON.parse(json_string)
+      case verbosity
+      when "full"
+        strip_diffs(data, "killed")
+        strip_diffs(data, "neutral")
+        strip_diffs(data, "equivalent")
+      when "summary"
+        data.delete("killed")
+        data.delete("neutral")
+        data.delete("equivalent")
+      when "minimal"
+        data.delete("killed")
+        data.delete("neutral")
+        data.delete("equivalent")
+        data.delete("timed_out")
+        data.delete("errors")
+      end
+      ::JSON.generate(data)
+    end
 
-        def trim_report(json_string, verbosity)
-          data = ::JSON.parse(json_string)
-          case verbosity
-          when "full"
-            strip_diffs(data, "killed")
-            strip_diffs(data, "neutral")
-            strip_diffs(data, "equivalent")
-          when "summary"
-            data.delete("killed")
-            data.delete("neutral")
-            data.delete("equivalent")
-          when "minimal"
-            data.delete("killed")
-            data.delete("neutral")
-            data.delete("equivalent")
-            data.delete("timed_out")
-            data.delete("errors")
-          end
-          ::JSON.generate(data)
-        end
+    def strip_diffs(data, key)
+      return unless data[key]
 
-        def strip_diffs(data, key)
-          return unless data[key]
+      data[key].each { |entry| entry.delete("diff") }
+    end
 
-          data[key].each { |entry| entry.delete("diff") }
-        end
+    def build_streaming_callback(server_context, suggest_tests)
+      return nil unless suggest_tests && server_context.respond_to?(:report_progress)
+
+      suggestion = Evilution::Reporter::Suggestion.new(suggest_tests: true)
+      survivor_index = 0
 
-        def build_error_payload(error)
-          error_type = case error
-                       when ConfigError then "config_error"
-                       when ParseError then "parse_error"
-                       else "runtime_error"
-                       end
+      proc do |result|
+        next unless result.survived?
 
-          payload = { type: error_type, message: error.message }
-          payload[:file] = error.file if error.file
-          { error: payload }
+        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
         end
       end
     end
+
+    def build_suggestion_detail(mutation, suggestion)
+      {
+        operator: mutation.operator_name,
+        file: mutation.file_path,
+        line: mutation.line,
+        subject: mutation.subject.name,
+        diff: mutation.diff,
+        suggestion: suggestion.suggestion_for(mutation)
+      }
+    end
+
+    def build_error_payload(error)
+      error_type = case error
+                   when Evilution::ConfigError then "config_error"
+                   when Evilution::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

data/lib/evilution/mcp/server.rb

@@ -3,17 +3,18 @@
 require "mcp"
 require_relative "../version"
 require_relative "mutate_tool"
+require_relative "session_list_tool"
+require_relative "session_show_tool"
+require_relative "session_diff_tool"
 
-module Evilution
-  module MCP
-    class Server
-      def self.build
-        ::MCP::Server.new(
-          name: "evilution",
-          version: Evilution::VERSION,
-          tools: [MutateTool]
-        )
-      end
-    end
+require_relative "../mcp"
+
+class Evilution::MCP::Server
+  def self.build
+    ::MCP::Server.new(
+      name: "evilution",
+      version: Evilution::VERSION,
+      tools: [Evilution::MCP::MutateTool, Evilution::MCP::SessionListTool, Evilution::MCP::SessionShowTool, Evilution::MCP::SessionDiffTool]
+    )
   end
 end

data/lib/evilution/mcp/session_diff_tool.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "json"
+require "mcp"
+require_relative "../session/store"
+
+require_relative "../mcp"
+
+class Evilution::MCP::SessionDiffTool < MCP::Tool
+  tool_name "evilution-session-diff"
+  description "Compare two mutation testing sessions and return the diff. " \
+              "Shows new regressions, fixed mutations, and persistent survivors."
+  input_schema(
+    properties: {
+      base: {
+        type: "string",
+        description: "Path to the base (older) session JSON file"
+      },
+      head: {
+        type: "string",
+        description: "Path to the head (newer) session JSON file"
+      }
+    }
+  )
+
+  class << self
+    # rubocop:disable Lint/UnusedMethodArgument
+    def call(server_context:, base: nil, head: nil)
+      return error_response("config_error", "base is required") unless base
+      return error_response("config_error", "head is required") unless head
+
+      store = Evilution::Session::Store.new
+      base_data = store.load(base)
+      head_data = store.load(head)
+
+      ::MCP::Tool::Response.new([{ type: "text", text: ::JSON.generate(build_diff(base_data, head_data)) }])
+    rescue Evilution::Error => e
+      error_response("not_found", e.message)
+    rescue ::JSON::ParserError => e
+      error_response("parse_error", e.message)
+    rescue SystemCallError => e
+      error_response("runtime_error", e.message)
+    end
+    # rubocop:enable Lint/UnusedMethodArgument
+
+    private
+
+    def build_diff(base_data, head_data)
+      base_survivors = base_data["survived"] || []
+      head_survivors = head_data["survived"] || []
+
+      base_keys = base_survivors.to_set { |m| mutation_key(m) }
+      head_keys = head_survivors.to_set { |m| mutation_key(m) }
+
+      {
+        "summary" => build_summary_diff(base_data, head_data),
+        "fixed" => base_survivors.reject { |m| head_keys.include?(mutation_key(m)) },
+        "new_survivors" => head_survivors.reject { |m| base_keys.include?(mutation_key(m)) },
+        "persistent" => head_survivors.select { |m| base_keys.include?(mutation_key(m)) }
+      }
+    end
+
+    def build_summary_diff(base_data, head_data)
+      base_summary = base_data["summary"] || {}
+      head_summary = head_data["summary"] || {}
+      base_score = base_summary["score"] || 0.0
+      head_score = head_summary["score"] || 0.0
+
+      {
+        "base_score" => base_score,
+        "head_score" => head_score,
+        "score_delta" => (head_score - base_score).round(4),
+        "base_survived" => base_summary["survived"] || 0,
+        "head_survived" => head_summary["survived"] || 0
+      }
+    end
+
+    def mutation_key(mutation)
+      [mutation["operator"], mutation["file"], mutation["line"], mutation["subject"]]
+    end
+
+    def error_response(type, message)
+      ::MCP::Tool::Response.new(
+        [{ type: "text", text: ::JSON.generate({ error: { type: type, message: message } }) }],
+        error: true
+      )
+    end
+  end
+end

data/lib/evilution/mcp/session_list_tool.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "json"
+require "mcp"
+require_relative "../session/store"
+
+require_relative "../mcp"
+
+class Evilution::MCP::SessionListTool < MCP::Tool
+  tool_name "evilution-session-list"
+  description "List past mutation testing sessions with summary statistics. " \
+              "Returns sessions in reverse chronological order."
+  input_schema(
+    properties: {
+      results_dir: {
+        type: "string",
+        description: "Session results directory (default: .evilution/results)"
+      },
+      limit: {
+        type: "integer",
+        description: "Return only the N most recent sessions"
+      }
+    }
+  )
+
+  class << self
+    # rubocop:disable Lint/UnusedMethodArgument
+    def call(server_context:, results_dir: nil, limit: nil)
+      store_opts = {}
+      store_opts[:results_dir] = results_dir if results_dir
+      store = Evilution::Session::Store.new(**store_opts)
+      entries = store.list
+      entries = entries.first(limit) if limit
+
+      payload = entries.map { |e| stringify_keys(e) }
+      ::MCP::Tool::Response.new([{ type: "text", text: ::JSON.generate(payload) }])
+    end
+    # rubocop:enable Lint/UnusedMethodArgument
+
+    private
+
+    def stringify_keys(hash)
+      hash.transform_keys(&:to_s)
+    end
+  end
+end