evilution 0.26.0 → 0.28.0

data/lib/evilution/isolation/fork.rb

@@ -4,6 +4,8 @@ require "fileutils"
 require "tmpdir"
 require_relative "../memory"
 require_relative "../temp_dir_tracker"
+require_relative "../child_output"
+require_relative "../process_cleanup"
 
 require_relative "../isolation"
 
@@ -48,19 +50,23 @@ class Evilution::Isolation::Fork
     read_io&.close
     write_io&.close
     ensure_reaped(pid)
-    restore_original_source(mutation)
+    restore_original_source
     FileUtils.rm_rf(sandbox_dir) if sandbox_dir
   end
 
   private
 
-  def restore_original_source(mutation) # rubocop:disable Lint/UnusedMethodArgument
+  def restore_original_source
     Evilution::TempDirTracker.cleanup_all
   end
 
   def suppress_child_output
-    $stdout.reopen(File::NULL, "w")
-    $stderr.reopen(File::NULL, "w")
+    if Evilution::ChildOutput.log_dir
+      Evilution::ChildOutput.redirect!
+    else
+      $stdout.reopen(File::NULL, "w")
+      $stderr.reopen(File::NULL, "w")
+    end
   end
 
   def execute_in_child(mutation, test_command)
@@ -83,7 +89,7 @@ class Evilution::Isolation::Fork
       if data.empty?
         { timeout: false, passed: false, error: "empty result from child" }
       else
-        { timeout: false }.merge(Marshal.load(data)) # rubocop:disable Security/MarshalLoad
+        { timeout: false }.merge(Marshal.load(data))
       end
     else
       terminate_child(pid)
@@ -108,7 +114,7 @@ class Evilution::Isolation::Fork
   end
 
   def terminate_child(pid)
-    ::Process.kill("TERM", pid) rescue nil # rubocop:disable Style/RescueModifier
+    Evilution::ProcessCleanup.safe_kill("TERM", pid)
     _, status = ::Process.waitpid2(pid, ::Process::WNOHANG)
     return if status
 
@@ -116,8 +122,8 @@ class Evilution::Isolation::Fork
     _, status = ::Process.waitpid2(pid, ::Process::WNOHANG)
     return if status
 
-    ::Process.kill("KILL", pid) rescue nil # rubocop:disable Style/RescueModifier
-    ::Process.wait(pid) rescue nil # rubocop:disable Style/RescueModifier
+    Evilution::ProcessCleanup.safe_kill("KILL", pid)
+    Evilution::ProcessCleanup.safe_wait(pid)
   end
 
   def classify_status(result)
@@ -138,11 +144,15 @@ class Evilution::Isolation::Fork
       status: status,
       duration: duration,
       test_command: result[:test_command],
-      child_rss_kb: result[:child_rss_kb],
-      parent_rss_kb: parent_rss_kb,
-      error_message: result[:error],
-      error_class: result[:error_class],
-      error_backtrace: result[:error_backtrace]
+      memory: Evilution::Result::MemoryStats.from_fields(
+        child_rss_kb: result[:child_rss_kb],
+        parent_rss_kb: parent_rss_kb
+      ),
+      error: Evilution::Result::ErrorInfo.from_fields(
+        message: result[:error],
+        klass: result[:error_class],
+        backtrace: result[:error_backtrace]
+      )
     )
   end
 end

data/lib/evilution/isolation/in_process.rb

@@ -80,12 +80,16 @@ class Evilution::Isolation::InProcess
       status: status,
       duration: duration,
       test_command: result[:test_command],
-      child_rss_kb: rss_after,
-      memory_delta_kb: memory_delta_kb,
-      parent_rss_kb: rss_before,
-      error_message: result[:error],
-      error_class: result[:error_class],
-      error_backtrace: result[:error_backtrace]
+      memory: Evilution::Result::MemoryStats.from_fields(
+        child_rss_kb: rss_after,
+        memory_delta_kb: memory_delta_kb,
+        parent_rss_kb: rss_before
+      ),
+      error: Evilution::Result::ErrorInfo.from_fields(
+        message: result[:error],
+        klass: result[:error_class],
+        backtrace: result[:error_backtrace]
+      )
     )
   end
 end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "../actions"
+require_relative "../response_formatter"
+
+class Evilution::MCP::InfoTool::Actions::Base
+  def self.call(**)
+    raise NotImplementedError
+  end
+
+  class << self
+    private
+
+    def success(payload)
+      Evilution::MCP::InfoTool::ResponseFormatter.success(payload)
+    end
+
+    def config_error(message)
+      Evilution::MCP::InfoTool::ResponseFormatter.error("config_error", message)
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../../../config"
+require_relative "../../../version"
+
+class Evilution::MCP::InfoTool::Actions::Environment < Evilution::MCP::InfoTool::Actions::Base
+  def self.call(**)
+    config = Evilution::Config.new(skip_config_file: false)
+    config_file = Evilution::Config::CONFIG_FILES.find { |path| File.exist?(path) }
+
+    success(
+      "version" => Evilution::VERSION,
+      "ruby" => RUBY_VERSION,
+      "config_file" => config_file,
+      "settings" => settings(config)
+    )
+  end
+
+  class << self
+    private
+
+    def 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
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../../../version"
+require_relative "../../../feedback"
+require_relative "../../../feedback/messages"
+
+class Evilution::MCP::InfoTool::Actions::Feedback < Evilution::MCP::InfoTool::Actions::Base
+  def self.call(**)
+    success(
+      "discussion_url" => Evilution::Feedback::DISCUSSION_URL,
+      "version" => Evilution::VERSION,
+      "guidance_for_agent" => Evilution::Feedback::Messages.info_guidance
+    )
+  end
+end

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../status_glossary"
+
+class Evilution::MCP::InfoTool::Actions::Statuses < Evilution::MCP::InfoTool::Actions::Base
+  def self.call(**)
+    success("statuses" => Evilution::MCP::InfoTool::StatusGlossary.entries)
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../config_factory"
+require_relative "../../../runner"
+require_relative "../../../mutator/registry"
+require_relative "../../../ast/pattern/filter"
+
+class Evilution::MCP::InfoTool::Actions::Subjects < Evilution::MCP::InfoTool::Actions::Base
+  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"] }
+    )
+  end
+
+  class << self
+    private
+
+    def build_subject_filter(config)
+      return nil if config.ignore_patterns.empty?
+
+      Evilution::AST::Pattern::Filter.new(config.ignore_patterns)
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../config_factory"
+require_relative "../../../runner"
+require_relative "../../../spec_resolver"
+
+class Evilution::MCP::InfoTool::Actions::Tests < Evilution::MCP::InfoTool::Actions::Base
+  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
+    )
+    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
+    )
+  end
+
+  class << self
+    private
+
+    def resolver_for(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(
+        "specs" => spec_files.map { |f| { "source" => nil, "spec" => f } },
+        "unresolved" => [],
+        "total_sources" => files.length,
+        "total_specs" => spec_files.uniq.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
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "mcp"
+require_relative "../../mcp"
+
+class Evilution::MCP::InfoTool < MCP::Tool; end unless defined?(Evilution::MCP::InfoTool)
+
+module Evilution::MCP::InfoTool::Actions
+end
+
+unless defined?(Evilution::MCP::InfoTool::Actions::Base)
+  class Evilution::MCP::InfoTool::Actions::Base # rubocop:disable Lint/EmptyClass
+  end
+end
+
+require_relative "../info_tool"

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "../info_tool"
+require_relative "../../config"
+
+module Evilution::MCP::InfoTool::ConfigFactory
+  module_function
+
+  def subjects(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 tests(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
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "../info_tool"
+
+module Evilution::MCP::InfoTool::ErrorMapper
+  module_function
+
+  def type_for(error)
+    case error
+    when Evilution::ConfigError then "config_error"
+    when Evilution::ParseError  then "parse_error"
+    else "runtime_error"
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "../info_tool"
+
+module Evilution::MCP::InfoTool::RequestParser
+  module_function
+
+  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
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "../info_tool"
+require_relative "error_mapper"
+
+module Evilution::MCP::InfoTool::ResponseFormatter
+  module_function
+
+  def success(payload)
+    ::MCP::Tool::Response.new([{ type: "text", text: ::JSON.generate(payload) }])
+  end
+
+  def error(type, message)
+    ::MCP::Tool::Response.new(
+      [{ type: "text", text: ::JSON.generate({ error: { type: type, message: message } }) }],
+      error: true
+    )
+  end
+
+  def error_for(exception)
+    error(Evilution::MCP::InfoTool::ErrorMapper.type_for(exception), exception.message)
+  end
+end

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative "../info_tool"
+require_relative "../../result/mutation_result"
+
+module Evilution::MCP::InfoTool::StatusGlossary
+  ENTRIES = [
+    {
+      "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
+    }
+  ].each(&:freeze).freeze
+
+  module_function
+
+  def entries
+    check_drift!
+    ENTRIES
+  end
+
+  def check_drift!
+    defined_statuses = Evilution::Result::MutationResult::STATUSES.map(&:to_s).sort
+    documented = ENTRIES.map { |s| s["status"] }.sort
+    return if defined_statuses == documented
+
+    missing = (defined_statuses - documented) + (documented - defined_statuses)
+    raise Evilution::Error, "status glossary drift: #{missing.inspect}"
+  end
+end