evilution 0.13.0 → 0.15.0

data/lib/evilution/mcp/session_show_tool.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "json"
+require "mcp"
+require_relative "../session/store"
+
+require_relative "../mcp"
+
+class Evilution::MCP::SessionShowTool < MCP::Tool
+  tool_name "evilution-session-show"
+  description "Show full details of a past mutation testing session, " \
+              "including survived mutations with diffs."
+  input_schema(
+    properties: {
+      path: {
+        type: "string",
+        description: "Path to the session JSON file (as returned by evilution-session-list)"
+      }
+    }
+  )
+
+  class << self
+    # rubocop:disable Lint/UnusedMethodArgument
+    def call(server_context:, path: nil)
+      unless path
+        return ::MCP::Tool::Response.new(
+          [{ type: "text", text: ::JSON.generate({ error: { type: "config_error", message: "path is required" } }) }],
+          error: true
+        )
+      end
+
+      store = Evilution::Session::Store.new
+      data = store.load(path)
+      ::MCP::Tool::Response.new([{ type: "text", text: ::JSON.generate(data) }])
+    rescue Evilution::Error => e
+      ::MCP::Tool::Response.new(
+        [{ type: "text", text: ::JSON.generate({ error: { type: "not_found", message: e.message } }) }],
+        error: true
+      )
+    rescue ::JSON::ParserError => e
+      ::MCP::Tool::Response.new(
+        [{ type: "text", text: ::JSON.generate({ error: { type: "parse_error", message: e.message } }) }],
+        error: true
+      )
+    rescue SystemCallError => e
+      ::MCP::Tool::Response.new(
+        [{ type: "text", text: ::JSON.generate({ error: { type: "runtime_error", message: e.message } }) }],
+        error: true
+      )
+    end
+    # rubocop:enable Lint/UnusedMethodArgument
+  end
+end

data/lib/evilution/mcp.rb

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

data/lib/evilution/memory/leak_check.rb

@@ -2,90 +2,86 @@
 
 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
+class Evilution::Memory::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

data/lib/evilution/memory.rb

@@ -1,40 +1,38 @@
 # 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
+module Evilution::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

data/lib/evilution/mutation.rb

@@ -3,57 +3,55 @@
 require "diff/lcs"
 require "diff/lcs/hunk"
 
-module Evilution
-  class Mutation
-    attr_reader :subject, :operator_name, :original_source,
-                :mutated_source, :file_path, :line, :column
-
-    def initialize(subject:, operator_name:, original_source:, mutated_source:, file_path:, line:, column: 0)
-      @subject = subject
-      @operator_name = operator_name
-      @original_source = original_source
-      @mutated_source = mutated_source
-      @file_path = file_path
-      @line = line
-      @column = column
-      @diff = nil
-    end
+class Evilution::Mutation
+  attr_reader :subject, :operator_name, :original_source,
+              :mutated_source, :file_path, :line, :column
+
+  def initialize(subject:, operator_name:, original_source:, mutated_source:, file_path:, line:, column: 0)
+    @subject = subject
+    @operator_name = operator_name
+    @original_source = original_source
+    @mutated_source = mutated_source
+    @file_path = file_path
+    @line = line
+    @column = column
+    @diff = nil
+  end
 
-    def diff
-      @diff ||= compute_diff
-    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
+  def strip_sources!
+    diff # ensure diff is cached before clearing sources
+    @original_source = nil
+    @mutated_source = nil
+  end
 
-    private
+  private
 
-    def compute_diff
-      original_lines = original_source.lines
-      mutated_lines = mutated_source.lines
-      diffs = ::Diff::LCS.diff(original_lines, mutated_lines)
+  def compute_diff
+    original_lines = original_source.lines
+    mutated_lines = mutated_source.lines
+    diffs = ::Diff::LCS.diff(original_lines, mutated_lines)
 
-      return "" if diffs.empty?
+    return "" if diffs.empty?
 
-      result = []
-      diffs.flatten(1).each do |change|
-        case change.action
-        when "-"
-          result << "- #{change.element.chomp}"
-        when "+"
-          result << "+ #{change.element.chomp}"
-        end
+    result = []
+    diffs.flatten(1).each do |change|
+      case change.action
+      when "-"
+        result << "- #{change.element.chomp}"
+      when "+"
+        result << "+ #{change.element.chomp}"
       end
-      result.join("\n")
     end
+    result.join("\n")
+  end
 
-    public
+  public
 
-    def to_s
-      "#{operator_name}: #{file_path}:#{line}"
-    end
+  def to_s
+    "#{operator_name}: #{file_path}:#{line}"
   end
 end

data/lib/evilution/mutator/base.rb

@@ -2,53 +2,67 @@
 
 require "prism"
 
-module Evilution
-  module Mutator
-    class Base < Prism::Visitor
-      attr_reader :mutations
-
-      def initialize
-        @mutations = []
-        @subject = nil
-        @file_source = nil
-      end
-
-      def call(subject)
-        @subject = subject
-        @file_source = File.read(subject.file_path)
-        @mutations = []
-        visit(subject.node)
-        @mutations
-      end
-
-      private
-
-      def add_mutation(offset:, length:, replacement:, node:)
-        mutated_source = AST::SourceSurgeon.apply(
-          @file_source,
-          offset: offset,
-          length: length,
-          replacement: replacement
-        )
-
-        @mutations << Mutation.new(
-          subject: @subject,
-          operator_name: self.class.operator_name,
-          original_source: @file_source,
-          mutated_source: mutated_source,
-          file_path: @subject.file_path,
-          line: node.location.start_line,
-          column: node.location.start_column
-        )
-      end
-
-      def self.operator_name
-        class_name = name || "anonymous"
-        class_name.split("::").last
-                  .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
-                  .gsub(/([a-z\d])([A-Z])/, '\1_\2')
-                  .downcase
-      end
-    end
+require_relative "../mutator"
+
+class Evilution::Mutator::Base < Prism::Visitor
+  attr_reader :mutations
+
+  def initialize
+    @mutations = []
+    @subject = nil
+    @file_source = nil
+  end
+
+  def call(subject)
+    @subject = subject
+    @file_source = File.read(subject.file_path)
+    @mutations = []
+    visit(subject.node)
+    @mutations
+  end
+
+  private
+
+  def add_mutation(offset:, length:, replacement:, node:)
+    mutated_source = Evilution::AST::SourceSurgeon.apply(
+      @file_source,
+      offset: offset,
+      length: length,
+      replacement: replacement
+    )
+
+    @mutations << Evilution::Mutation.new(
+      subject: @subject,
+      operator_name: self.class.operator_name,
+      original_source: @file_source,
+      mutated_source: mutated_source,
+      file_path: @subject.file_path,
+      line: node.location.start_line,
+      column: node.location.start_column
+    )
+  end
+
+  def self.operator_name
+    class_name = name || "anonymous"
+    class_name.split("::").last
+              .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+              .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+              .downcase
+  end
+
+  @parse_cache = {}
+
+  def self.parsed_tree_for(file_path, file_source)
+    cache = Evilution::Mutator::Base.instance_variable_get(:@parse_cache)
+    entry = cache[file_path]
+    return entry[:tree] if entry && entry[:source_hash] == file_source.hash
+
+    tree = Prism.parse(file_source).value
+    cache[file_path] = { source_hash: file_source.hash, tree: tree }
+    tree
+  end
+
+  def self.clear_parse_cache!
+    Evilution::Mutator::Base.instance_variable_set(:@parse_cache, {})
   end
 end

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

@@ -1,42 +1,38 @@
 # frozen_string_literal: true
 
-module Evilution
-  module Mutator
-    module Operator
-      class ArgumentNilSubstitution < 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 >= 1 && positional_only?(args)
-            args.each_index do |i|
-              parts = args.each_with_index.map { |a, j| j == i ? "nil" : a.slice }
-              replacement = parts.join(", ")
-
-              add_mutation(
-                offset: node.arguments.location.start_offset,
-                length: node.arguments.location.length,
-                replacement: replacement,
-                node: node
-              )
-            end
-          end
-
-          super
-        end
-
-        private
-
-        def positional_only?(args)
-          args.none? { |arg| SKIP_TYPES.any? { |type| arg.is_a?(type) } }
-        end
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::ArgumentNilSubstitution < Evilution::Mutator::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 >= 1 && positional_only?(args)
+      args.each_index do |i|
+        parts = args.each_with_index.map { |a, j| j == i ? "nil" : a.slice }
+        replacement = parts.join(", ")
+
+        add_mutation(
+          offset: node.arguments.location.start_offset,
+          length: node.arguments.location.length,
+          replacement: replacement,
+          node: node
+        )
       end
     end
+
+    super
+  end
+
+  private
+
+  def positional_only?(args)
+    args.none? { |arg| SKIP_TYPES.any? { |type| arg.is_a?(type) } }
   end
 end

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

@@ -1,42 +1,38 @@
 # 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
+require_relative "../operator"
+
+class Evilution::Mutator::Operator::ArgumentRemoval < Evilution::Mutator::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