evilution 0.28.0 → 0.29.0

data/lib/evilution/compare/normalizer.rb

@@ -57,11 +57,7 @@ class Evilution::Compare::Normalizer
   private
 
   def build_evilution_record(entry, index:)
-    file_path = entry["file"] or raise Evilution::Compare::InvalidInput.new("missing 'file' in record", index: index)
-    line = entry["line"] or raise Evilution::Compare::InvalidInput.new("missing 'line' in record", index: index)
-    diff = entry["diff"].to_s
-    status = EVILUTION_STATUS_MAP[entry["status"]] ||
-             raise(Evilution::Compare::InvalidInput.new("unknown status #{entry["status"].inspect}", index: index))
+    file_path, line, diff, status = extract_evilution_fields(entry, index)
     Evilution::Compare::Record.new(
       source: :evilution,
       file_path: file_path,
@@ -74,6 +70,15 @@ class Evilution::Compare::Normalizer
     )
   end
 
+  def extract_evilution_fields(entry, index)
+    file_path = entry["file"] or raise Evilution::Compare::InvalidInput.new("missing 'file' in record", index: index)
+    line = entry["line"] or raise Evilution::Compare::InvalidInput.new("missing 'line' in record", index: index)
+    diff = entry["diff"].to_s
+    status = EVILUTION_STATUS_MAP[entry["status"]] ||
+             raise(Evilution::Compare::InvalidInput.new("unknown status #{entry["status"].inspect}", index: index))
+    [file_path, line, diff, status]
+  end
+
   def build_mutant_record(cov, source_path:, index:)
     mr = cov["mutation_result"] or raise Evilution::Compare::InvalidInput.new("missing mutation_result", index: index)
     cr = cov["criteria_result"] or raise Evilution::Compare::InvalidInput.new("missing criteria_result", index: index)

data/lib/evilution/config.rb

@@ -239,17 +239,17 @@ class Evilution::Config
     end
   end
 
+  VALIDATED_ATTRS = %i[
+    integration jobs fail_fast isolation ignore_patterns
+    hooks preload spec_mappings spec_pattern profile
+  ].freeze
+  private_constant :VALIDATED_ATTRS
+
   def assign_validated_attributes(merged)
-    @integration     = Validators::Integration.call(merged[:integration])
-    @jobs            = Validators::Jobs.call(merged[:jobs])
-    @fail_fast       = Validators::FailFast.call(merged[:fail_fast])
-    @isolation       = Validators::Isolation.call(merged[:isolation])
-    @ignore_patterns = Validators::IgnorePatterns.call(merged[:ignore_patterns])
-    @hooks           = Validators::Hooks.call(merged[:hooks])
-    @preload         = Validators::Preload.call(merged[:preload])
-    @spec_mappings   = Validators::SpecMappings.call(merged[:spec_mappings])
-    @spec_pattern    = Validators::SpecPattern.call(merged[:spec_pattern])
-    @profile         = Validators::Profile.call(merged[:profile])
+    VALIDATED_ATTRS.each do |key|
+      validator = Validators.const_get(key.to_s.split("_").map(&:capitalize).join)
+      instance_variable_set(:"@#{key}", validator.call(merged[key]))
+    end
   end
 
   def assign_example_targeting(merged)

data/lib/evilution/disable_comment.rb

@@ -20,21 +20,30 @@ class Evilution::DisableComment
   private
 
   def classify_comments(parse_result, source)
-    parse_result.comments.filter_map do |comment|
-      loc = comment.location
-      text = source.byteslice(loc.start_offset, loc.end_offset - loc.start_offset)
-                   .force_encoding(source.encoding)
-
-      if text.match?(DISABLE_MARKER)
-        line = source.lines[loc.start_line - 1]
-        standalone = line.strip == text.strip
-        { type: :disable, line: loc.start_line, standalone: standalone }
-      elsif text.match?(ENABLE_MARKER)
-        { type: :enable, line: loc.start_line }
-      end
+    parse_result.comments.filter_map { |comment| classify_comment(comment, source) }
+  end
+
+  def classify_comment(comment, source)
+    loc = comment.location
+    text = comment_text(loc, source)
+
+    if text.match?(DISABLE_MARKER)
+      disable_entry(loc, text, source)
+    elsif text.match?(ENABLE_MARKER)
+      { type: :enable, line: loc.start_line }
     end
   end
 
+  def comment_text(loc, source)
+    source.byteslice(loc.start_offset, loc.end_offset - loc.start_offset)
+          .force_encoding(source.encoding)
+  end
+
+  def disable_entry(loc, text, source)
+    standalone = source.lines[loc.start_line - 1].strip == text.strip
+    { type: :disable, line: loc.start_line, standalone: standalone }
+  end
+
   def scan_comments(comments, method_ranges, total_lines)
     disabled = []
     range_start = nil

data/lib/evilution/integration/loading/mutation_applier.rb

@@ -28,25 +28,30 @@ class Evilution::Integration::Loading::MutationApplier
     syntax_error = @syntax_validator.call(mutation.mutated_source)
     return syntax_error if syntax_error
 
+    apply(mutation)
+    nil
+  rescue SyntaxError => e
+    failure_result(e, "syntax error in mutated source: #{e.message}")
+  rescue ScriptError, StandardError => e
+    failure_result(e, "#{e.class}: #{e.message}")
+  end
+
+  private
+
+  def apply(mutation)
     @constant_pinner.call(mutation.original_source)
     @concern_state_cleaner.call(mutation.file_path)
     @redefinition_recovery.call(mutation.original_source) do
       @source_evaluator.call(mutation.mutated_source, mutation.file_path)
     end
-    nil
-  rescue SyntaxError => e
-    {
-      passed: false,
-      error: "syntax error in mutated source: #{e.message}",
-      error_class: e.class.name,
-      error_backtrace: Array(e.backtrace).first(5)
-    }
-  rescue ScriptError, StandardError => e
+  end
+
+  def failure_result(error, message)
     {
       passed: false,
-      error: "#{e.class}: #{e.message}",
-      error_class: e.class.name,
-      error_backtrace: Array(e.backtrace).first(5)
+      error: message,
+      error_class: error.class.name,
+      error_backtrace: Array(error.backtrace).first(5)
     }
   end
 end

data/lib/evilution/integration/minitest.rb

@@ -10,22 +10,31 @@ require_relative "../integration"
 
 class Evilution::Integration::Minitest < Evilution::Integration::Base
   def self.baseline_runner
-    lambda { |test_file|
-      require "minitest"
-      require "stringio"
-      ::Minitest::Runnable.runnables.clear
-      files = File.directory?(test_file) ? Dir.glob(File.join(test_file, "**/*_test.rb")) : [test_file]
-      files.each { |f| load(File.expand_path(f)) }
-      out = StringIO.new
-      options = ::Minitest.process_args(["--seed", "0"])
-      options[:io] = out
-      reporter = ::Minitest::CompositeReporter.new
-      reporter << ::Minitest::SummaryReporter.new(out, options)
-      reporter.start
-      ::Minitest.__run(reporter, options)
-      reporter.report
-      reporter.passed?
-    }
+    ->(test_file) { run_baseline_test_file(test_file) }
+  end
+
+  def self.run_baseline_test_file(test_file)
+    require "minitest"
+    require "stringio"
+    ::Minitest::Runnable.runnables.clear
+    baseline_test_files(test_file).each { |f| load(File.expand_path(f)) }
+    run_baseline_minitest
+  end
+
+  def self.baseline_test_files(test_file)
+    File.directory?(test_file) ? Dir.glob(File.join(test_file, "**/*_test.rb")) : [test_file]
+  end
+
+  def self.run_baseline_minitest
+    out = StringIO.new
+    options = ::Minitest.process_args(["--seed", "0"])
+    options[:io] = out
+    reporter = ::Minitest::CompositeReporter.new
+    reporter << ::Minitest::SummaryReporter.new(out, options)
+    reporter.start
+    ::Minitest.__run(reporter, options)
+    reporter.report
+    reporter.passed?
   end
 
   def self.baseline_options

data/lib/evilution/integration/rspec.rb

@@ -74,6 +74,10 @@ class Evilution::Integration::RSpec < Evilution::Integration::Base
     command = "rspec #{args.join(" ")}"
 
     reset_examples
+    execute_run(args, command)
+  end
+
+  def execute_run(args, command)
     detector = @crash_detector_lifecycle.current
     snapshot = @state_guard.snapshot
     begin

data/lib/evilution/isolation/fork.rb

@@ -21,41 +21,51 @@ class Evilution::Isolation::Fork
     sandbox_dir = Dir.mktmpdir("evilution-run")
     start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
     parent_rss = Evilution::Memory.rss_kb
+    read_io, write_io = binary_pipe
+    pid = fork_child(read_io, write_io, sandbox_dir, mutation, test_command)
+    write_io.close
+    result = wait_for_result(pid, read_io, timeout)
+    duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
+    build_mutation_result(mutation, result, duration, parent_rss)
+  ensure
+    cleanup_resources(read_io, write_io, pid, sandbox_dir)
+  end
+
+  private
+
+  # Marshal result payload is ASCII-8BIT; pipes default to text mode and may
+  # transcode according to their external/internal encodings (influenced by
+  # Encoding.default_external and/or Encoding.default_internal — Rails sets
+  # the latter to UTF-8), failing on bytes with no mapping. Force binmode on
+  # both ends.
+  def binary_pipe
     read_io, write_io = IO.pipe
-    # Marshal result payload is ASCII-8BIT; pipes default to text mode and may
-    # transcode according to their external/internal encodings (influenced by
-    # Encoding.default_external and/or Encoding.default_internal — Rails sets
-    # the latter to UTF-8), failing on bytes with no mapping. Force binmode on
-    # both ends.
     read_io.binmode
     write_io.binmode
+    [read_io, write_io]
+  end
 
-    pid = ::Process.fork do
+  def fork_child(read_io, write_io, sandbox_dir, mutation, test_command)
+    ::Process.fork do
       ENV["TMPDIR"] = sandbox_dir
       read_io.close
       suppress_child_output
-      @hooks.fire(:worker_process_start, mutation: mutation) if @hooks
+      @hooks.fire(:worker_process_start, mutation:) if @hooks
       result = execute_in_child(mutation, test_command)
       Marshal.dump(result, write_io)
       write_io.close
       exit!(result[:passed] ? 0 : 1)
     end
+  end
 
-    write_io.close
-    result = wait_for_result(pid, read_io, timeout)
-    duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
-
-    build_mutation_result(mutation, result, duration, parent_rss)
-  ensure
-    read_io&.close
-    write_io&.close
+  def cleanup_resources(read_io, write_io, pid, sandbox_dir)
+    read_io.close unless read_io.nil?
+    write_io.close unless write_io.nil?
     ensure_reaped(pid)
     restore_original_source
     FileUtils.rm_rf(sandbox_dir) if sandbox_dir
   end
 
-  private
-
   def restore_original_source
     Evilution::TempDirTracker.cleanup_all
   end

data/lib/evilution/mcp/info_tool/actions/subjects.rb

@@ -10,34 +10,43 @@ class Evilution::MCP::InfoTool::Actions::Subjects < Evilution::MCP::InfoTool::Ac
   def self.call(files: nil, line_ranges: nil, target: nil, integration: nil, skip_config: nil, **)
     return config_error("files is required") if files.nil? || files.empty?
 
-    config = Evilution::MCP::InfoTool::ConfigFactory.subjects(
-      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(
-      "subjects" => entries,
-      "total_subjects" => entries.length,
-      "total_mutations" => entries.sum { |e| e["mutations"] }
-    )
+    config = build_config(files, line_ranges, target, integration, skip_config)
+    subjects = Evilution::Runner.new(config: config).parse_and_filter_subjects
+    entries = subject_entries(subjects, config)
+    success_response(entries)
   end
 
   class << self
     private
 
+    def build_config(files, line_ranges, target, integration, skip_config)
+      Evilution::MCP::InfoTool::ConfigFactory.subjects(
+        files: files, line_ranges: line_ranges,
+        target: target, integration: integration, skip_config: skip_config
+      )
+    end
+
+    def subject_entries(subjects, config)
+      registry = Evilution::Mutator::Registry.default
+      filter = build_subject_filter(config)
+      operator_options = { skip_heredoc_literals: config.skip_heredoc_literals? }
+
+      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
+    end
+
+    def success_response(entries)
+      success(
+        "subjects" => entries,
+        "total_subjects" => entries.length,
+        "total_mutations" => entries.sum { |e| e["mutations"] }
+      )
+    end
+
     def build_subject_filter(config)
       return nil if config.ignore_patterns.empty?
 

data/lib/evilution/mcp/info_tool/actions/tests.rb

@@ -6,27 +6,37 @@ require_relative "../../../runner"
 require_relative "../../../spec_resolver"
 
 class Evilution::MCP::InfoTool::Actions::Tests < Evilution::MCP::InfoTool::Actions::Base
+  ResolveResult = Data.define(:resolved, :unresolved)
+  private_constant :ResolveResult
+
   def self.call(files: nil, spec: nil, integration: nil, skip_config: nil, **)
     return config_error("files is required") if files.nil? || files.empty?
 
-    config = Evilution::MCP::InfoTool::ConfigFactory.tests(
-      files: files, spec: spec, integration: integration, skip_config: skip_config
-    )
+    config = build_config(files, spec, integration, skip_config)
     return explicit_specs_response(files, config.spec_files) if config.spec_files.any?
 
-    resolver = resolver_for(config.integration)
-    resolved, unresolved = resolve_specs(files, resolver)
-    success(
-      "specs" => resolved,
-      "unresolved" => unresolved,
-      "total_sources" => files.length,
-      "total_specs" => resolved.map { |r| r["spec"] }.uniq.length
-    )
+    resolved_specs_response(files, resolver_for(config.integration))
   end
 
   class << self
     private
 
+    def build_config(files, spec, integration, skip_config)
+      Evilution::MCP::InfoTool::ConfigFactory.tests(
+        files: files, spec: spec, integration: integration, skip_config: skip_config
+      )
+    end
+
+    def resolved_specs_response(files, resolver)
+      result = resolve_specs(files, resolver)
+      success(
+        "specs" => result.resolved,
+        "unresolved" => result.unresolved,
+        "total_sources" => files.length,
+        "total_specs" => result.resolved.map { |r| r["spec"] }.uniq.length
+      )
+    end
+
     def resolver_for(integration)
       integration_class = Evilution::Runner::INTEGRATIONS[integration.to_sym]
       return Evilution::SpecResolver.new unless integration_class
@@ -54,7 +64,7 @@ class Evilution::MCP::InfoTool::Actions::Tests < Evilution::MCP::InfoTool::Actio
           unresolved << source
         end
       end
-      [resolved, unresolved]
+      ResolveResult.new(resolved: resolved, unresolved: unresolved)
     end
   end
 end

data/lib/evilution/mcp/info_tool/request_parser.rb

@@ -3,6 +3,8 @@
 require_relative "../info_tool"
 
 module Evilution::MCP::InfoTool::RequestParser
+  ParsedPaths = Data.define(:files, :ranges)
+
   module_function
 
   def parse_files(raw_files)
@@ -15,7 +17,7 @@ module Evilution::MCP::InfoTool::RequestParser
       ranges[file] = parse_line_range(range_str) if range_str
     end
 
-    [files, ranges]
+    ParsedPaths.new(files: files, ranges: ranges)
   end
 
   def parse_line_range(str)

data/lib/evilution/mcp/info_tool.rb

@@ -74,7 +74,13 @@ class Evilution::MCP::InfoTool < MCP::Tool
       return ResponseFormatter.error("config_error", "action is required") unless action
       return ResponseFormatter.error("config_error", "unknown action: #{action}") unless ACTIONS.key?(action)
 
-      parsed_files, line_ranges = RequestParser.parse_files(Array(files)) if files
+      parsed_files = nil
+      line_ranges = nil
+      if files
+        parsed = RequestParser.parse_files(Array(files))
+        parsed_files = parsed.files
+        line_ranges = parsed.ranges
+      end
 
       ACTIONS[action].call(
         files: parsed_files, line_ranges: line_ranges, target: target, spec: spec,

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

@@ -8,6 +8,8 @@ module Evilution::MCP::MutateTool::OptionParser
                         isolation baseline save_session].freeze
   ALLOWED_OPT_KEYS = (PASSTHROUGH_KEYS + %i[spec skip_config]).freeze
 
+  ParsedPaths = Data.define(:files, :ranges)
+
   def self.parse_files(raw_files)
     files = []
     ranges = {}
@@ -20,7 +22,7 @@ module Evilution::MCP::MutateTool::OptionParser
       ranges[file] = parse_line_range(range_str)
     end
 
-    [files, ranges]
+    ParsedPaths.new(files: files, ranges: ranges)
   end
 
   def self.parse_line_range(str)

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

@@ -9,23 +9,33 @@ module Evilution::MCP::MutateTool::SurvivedEnricher
     entries = data["survived"]
     return unless entries.is_a?(Array)
 
-    explicit_spec = explicit_spec_override(config)
-    resolver = explicit_spec ? nil : resolver_for_integration(config.integration)
+    explicit_spec, resolver = build_resolver(config)
     cache = {}
 
     entries.each_with_index do |entry, index|
       result = survived_results[index]
       next unless result
 
-      mutation = result.mutation
-      entry["subject"] = mutation.subject.name
-      spec_file = explicit_spec || cache.fetch(mutation.file_path) do
-        cache[mutation.file_path] = resolver.call(mutation.file_path)
-      end
-      entry["spec_file"] = spec_file if spec_file
-      entry["next_step"] = build_next_step(mutation, spec_file)
+      enrich_entry(entry, result.mutation, explicit_spec, resolver, cache)
+    end
+  end
+
+  def self.build_resolver(config)
+    explicit_spec = explicit_spec_override(config)
+    resolver = explicit_spec ? nil : resolver_for_integration(config.integration)
+    [explicit_spec, resolver]
+  end
+  private_class_method :build_resolver
+
+  def self.enrich_entry(entry, mutation, explicit_spec, resolver, cache)
+    entry["subject"] = mutation.subject.name
+    spec_file = explicit_spec || cache.fetch(mutation.file_path) do
+      cache[mutation.file_path] = resolver.call(mutation.file_path)
     end
+    entry["spec_file"] = spec_file if spec_file
+    entry["next_step"] = build_next_step(mutation, spec_file)
   end
+  private_class_method :enrich_entry
 
   def self.explicit_spec_override(config)
     return nil unless config.respond_to?(:spec_files)

data/lib/evilution/mcp/mutate_tool.rb

@@ -105,37 +105,50 @@ class Evilution::MCP::MutateTool < MCP::Tool
 
   class << self
     def call(server_context:, files: [], verbosity: nil, **opts)
+      config = build_config(files, opts)
+      on_result = build_progress_streamer(server_context, opts, config)
+      summary = Evilution::Runner.new(config: config, on_result: on_result).call
+      compact = build_compact_report(summary, verbosity, opts, config)
+
+      ::MCP::Tool::Response.new([{ type: "text", text: compact }])
+    rescue Evilution::Error => e
+      payload = Evilution::MCP::MutateTool::ErrorPayload.build(e)
+      ::MCP::Tool::Response.new([{ type: "text", text: ::JSON.generate(payload) }], error: true)
+    end
+
+    private
+
+    def build_config(files, opts)
       Evilution::MCP::MutateTool::OptionParser.validate!(opts)
-      parsed_files, line_ranges = Evilution::MCP::MutateTool::OptionParser.parse_files(Array(files))
-      config = Evilution::MCP::MutateTool::ConfigBuilder.build(
-        files: parsed_files,
-        line_ranges: line_ranges,
+      parsed = Evilution::MCP::MutateTool::OptionParser.parse_files(Array(files))
+      Evilution::MCP::MutateTool::ConfigBuilder.build(
+        files: parsed.files,
+        line_ranges: parsed.ranges,
         params: opts
       )
-      on_result = Evilution::MCP::MutateTool::ProgressStreamer.build(
+    end
+
+    def build_progress_streamer(server_context, opts, config)
+      Evilution::MCP::MutateTool::ProgressStreamer.build(
         server_context: server_context,
         suggest_tests: opts[:suggest_tests],
         integration: config.integration
       )
-      summary = Evilution::Runner.new(config: config, on_result: on_result).call
+    end
+
+    def build_compact_report(summary, verbosity, opts, config)
       report = Evilution::Reporter::JSON.new(
         suggest_tests: opts[:suggest_tests] == true,
         integration: config.integration
       ).call(summary)
-      normalized_verbosity = Evilution::MCP::MutateTool::OptionParser.normalize_verbosity(verbosity)
-      compact = Evilution::MCP::MutateTool::ReportTrimmer.call(
+      Evilution::MCP::MutateTool::ReportTrimmer.call(
         report,
-        verbosity: normalized_verbosity,
+        verbosity: Evilution::MCP::MutateTool::OptionParser.normalize_verbosity(verbosity),
         survived_results: summary.survived_results,
         config: config,
         enricher: Evilution::MCP::MutateTool::SurvivedEnricher,
         summary: summary
       )
-
-      ::MCP::Tool::Response.new([{ type: "text", text: compact }])
-    rescue Evilution::Error => e
-      payload = Evilution::MCP::MutateTool::ErrorPayload.build(e)
-      ::MCP::Tool::Response.new([{ type: "text", text: ::JSON.generate(payload) }], error: true)
     end
   end
 end

data/lib/evilution/mcp/session_tool.rb

@@ -50,6 +50,9 @@ class Evilution::MCP::SessionTool < MCP::Tool
 
   VALID_ACTIONS = %w[list show diff].freeze
 
+  LimitResult = Data.define(:limit, :error)
+  private_constant :LimitResult
+
   class << self
     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
@@ -65,28 +68,28 @@ class Evilution::MCP::SessionTool < MCP::Tool
     private
 
     def list_action(results_dir:, limit:)
-      normalized_limit, limit_error = normalize_limit(limit)
-      return error_response("config_error", limit_error) if limit_error
+      result = normalize_limit(limit)
+      return error_response("config_error", result.error) if result.error
 
       store_opts = {}
       store_opts[:results_dir] = results_dir if results_dir
       store = Evilution::Session::Store.new(**store_opts)
       entries = store.list
-      entries = entries.first(normalized_limit) unless normalized_limit.nil?
+      entries = entries.first(result.limit) unless result.limit.nil?
 
       payload = entries.map { |e| e.transform_keys(&:to_s) }
       success_response(payload)
     end
 
     def normalize_limit(limit)
-      return [nil, nil] if limit.nil?
+      return LimitResult.new(limit: nil, error: nil) if limit.nil?
 
       coerced = Integer(limit)
-      return [nil, "limit must be a non-negative integer"] if coerced.negative?
+      return LimitResult.new(limit: nil, error: "limit must be a non-negative integer") if coerced.negative?
 
-      [coerced, nil]
+      LimitResult.new(limit: coerced, error: nil)
     rescue ArgumentError, TypeError
-      [nil, "limit must be a non-negative integer"]
+      LimitResult.new(limit: nil, error: "limit must be a non-negative integer")
     end
 
     def show_action(path:, results_dir:)
@@ -107,19 +110,11 @@ class Evilution::MCP::SessionTool < MCP::Tool
     end
 
     def diff_action(base:, head:, results_dir:)
-      return error_response("config_error", "base is required") unless base
-      return error_response("config_error", "head is required") unless head
-
       dir = results_dir || Evilution::Session::Store::DEFAULT_DIR
-      return error_response("config_error", "base must be under results directory") unless within?(base, dir)
-      return error_response("config_error", "head must be under results directory") unless within?(head, dir)
-
-      store = Evilution::Session::Store.new(results_dir: dir)
-      base_data = store.load(base)
-      head_data = store.load(head)
+      validation = validate_diff_args(base, head, dir)
+      return validation if validation
 
-      diff = Evilution::Session::Diff.new
-      result = diff.call(base_data, head_data)
+      result = load_and_diff(base, head, dir)
       success_response(result.to_h)
     rescue Evilution::Error => e
       error_response("not_found", e.message)
@@ -129,6 +124,20 @@ class Evilution::MCP::SessionTool < MCP::Tool
       error_response("runtime_error", e.message)
     end
 
+    def validate_diff_args(base, head, dir)
+      return error_response("config_error", "base is required") unless base
+      return error_response("config_error", "head is required") unless head
+      return error_response("config_error", "base must be under results directory") unless within?(base, dir)
+      return error_response("config_error", "head must be under results directory") unless within?(head, dir)
+
+      nil
+    end
+
+    def load_and_diff(base, head, dir)
+      store = Evilution::Session::Store.new(results_dir: dir)
+      Evilution::Session::Diff.new.call(store.load(base), store.load(head))
+    end
+
     def within?(path, results_dir)
       resolved_root = canonical_path(results_dir)
       resolved_path = canonical_path(path)