stryker-mutator/stryker4s

Stryker4s is a mutation testing framework for the Scala ecosystem that systematically introduces code changes to verify the effectiveness of test suites. It provides build tool integrations for SBT, Maven, and Mill, allowing developers to run mutation analysis directly within their existing build workflows. The system operates by forking processes to apply mutations, executing tests to detect failures, and rolling back changes to maintain project integrity.

7 changes.

The project modernized its build infrastructure by upgrading to SBT 2.x and Scala 3, while introducing a standalone Maven plugin for mutation testing. This period also included cross-platform tooling improvements, such as adding PowerShell support for Windows users.

8 changes.

This period focused on establishing the foundational infrastructure for command-line execution and SBT plugin integration. Key developments included introducing a structured, multi-source configuration system and a dedicated command-runner module to handle CLI arguments and process-based mutation testing. The SBT plugin was rewritten to support modern SBT features, including a new test interface mapper and legacy runner compatibility, alongside enhanced logging and test utilities.

9 changes.

This period focused on expanding Stryker4s support to Mill and SBT 2.x while introducing a new Scala-based test runner with socket communication. The Maven integration was also rewritten to align with the new architecture, enabling mutant rollback and dynamic dependency resolution. Comprehensive test coverage was added across all three build tool plugins to ensure stability.

Users can now run Stryker4s mutation testing directly within Mill build files by mixing in the \Stryker4sModule\ trait. This adds a \stryker\ command that automatically discovers the module's test suite, applies mutations to the source files, and executes the tests using Mill's internal test runner and compilation infrastructure. Configuration is handled via standard Mill task definitions (e.g., \strykerMutate\, \strykerTestFilter\, \strykerTimeout\), allowing users to customize mutation scope, test filtering, reporting, and timeouts without leaving the Mill environment.

modules/mill/src/main · high confidence

The SBT module now includes a dedicated \SbtLogger\ class that bridges the internal logging system with SBT's native logger. This implementation respects SBT's log levels and environment variables (such as \NO\_COLOR\) to control output formatting and verbosity, ensuring that log messages are correctly routed and displayed within the SBT build environment.

modules/sbt/src/main/scala/stryker4s/log · high confidence

A new PowerShell script (bin/scalafmt.ps1) has been added to allow users to run the scalafmt formatter directly from the command line on Windows environments. The script delegates execution to the existing Java-based scalafmt binary located in the bin directory, passing through any provided arguments.

bin · high confidence

This change introduces the Stryker4s Maven plugin as a standalone project, separate from the core SBT-based implementation. It includes the necessary configuration files (stryker4s.conf, settings.xml) and documentation (README.MD) to enable mutation testing for Maven-based Scala projects. The plugin supports overriding compiler flags via Maven profiles to handle fatal warnings during mutation compilation and allows users to activate specific profiles for the mutation run.

maven · high confidence

This change adds the new \commandRunner\ module, which provides the entry point (\Stryker4sMain\) and infrastructure for running Stryker4s from the command line. It introduces \Stryker4sArgumentHandler\ to parse CLI arguments (specifically log levels like \--debug\ or \--info\) and configure SLF4J logging, and \Stryker4sCommandRunner\ to wire the core runner with CLI configuration sources and timeout handling. The module also includes \ProcessTestRunner\, which executes test commands via the OS process runner, mapping exit codes and timeouts to mutant statuses (Survived, Killed, Timeout, RuntimeError). Tests verify the argument parsing logic and the process runner's behavior under various exit conditions.

modules/commandRunner · high confidence

A new LegacySbtTestRunner class has been added to handle mutation testing execution on SBT 1.x versions. This component implements the TestRunner interface by managing SBT state and executing the 'test' task within the context of a specific project reference, allowing the tool to support older SBT versions alongside the newer SBT 2.x cross-publishing capabilities.

modules/sbt/src/main/scala/stryker4s/sbt/runner · high confidence

The core module now features a comprehensive configuration framework that aggregates settings from multiple sources—including CLI arguments, HOCON files, and defaults—using the Ciris library. This change introduces a new \Config\ data structure and a \ConfigLoader\ that resolves values based on priority, enabling users to configure mutation testing parameters (such as test filters, timeouts, and reporters) via command-line flags or configuration files. It also includes dedicated sources for parsing CLI options and reading HOCON files, along with codecs for encoding/decoding configuration values.

modules/core · high confidence

Added MavenMojoLogger to bridge Stryker4s logging with Maven's plugin logging API, respecting Maven's color and debug settings, and added XsbtiLogger to adapt Stryker4s logging for the XSBT build tool interface.

maven/src/main/scala/stryker4s/log · high confidence

Added a new \TestInterfaceMapper\ component in the SBT module that converts SBT testing structures (frameworks, test groups, definitions, fingerprints, and selectors) into the internal Striker4s API representation. This enables the mutation testing engine to correctly identify and group tests discovered via the SBT testing interface, supporting various fingerprint types (annotated, subclass) and selector types (nested suite/test, wildcard).

modules/sbt/src/main/scala/stryker4s/model · high confidence

The testkit module now includes new helper classes to simplify testing. LogMatchers provides assertions to verify that specific log messages were recorded at expected levels (Debug, Info, Warn, Error) and includes extensions for asserting logs on cats.effect.IO actions. FileUtil adds a convenience method to load resources from the classloader as fs2 Paths or Strings. Stryker4sSuite and Stryker4sIOSuite are updated to integrate these new matchers and provide a base for tests using MUnit.

modules/testkit · high confidence

The Maven integration has been completely rewritten to support the new test-runner architecture and enable mutant rollback. The runner now dynamically resolves the test-runner artifact and Scala compiler dependencies at runtime using Aether, rather than relying on build-time resolution. Compilation is performed in two passes via Zinc: first compiling mutated main sources to identify and roll back non-compiling mutants, then compiling test sources against the mutated classes. Test discovery now uses the sbt.testing API to detect frameworks (such as ScalaTest, JUnit, and Munit) on the classpath, and test selection is aligned with the project's enabled Maven plugins (Surefire or scalatest-maven-plugin) to ensure parity with standard \mvn test\ execution.

maven/src/main/scala/stryker4s/maven/runner · high confidence

The Maven plugin has been rewritten to use a dedicated test-runner process (similar to the sbt and Mill plugins) instead of the previous in-process approach. This change introduces support for rollback capabilities and allows the plugin to resolve configuration directly from the Maven project, such as deriving the Scala dialect from the project's version and SCM URL for dashboard reporting. Users benefit from improved stability and consistency with other build tools, as the mutation testing now runs in a separate forked JVM process.

maven/src/main/scala/stryker4s/maven · high confidence

The SBT plugin has been completely rewritten to support modern SBT features and improve reliability. A new \SbtConfigSource\ now reads configuration directly from SBT settings (e.g., \strykerMutate\, \strykerBaseDir\), replacing previous methods. The \Stryker4sSbtRunner\ has been updated to use a new test runner architecture that integrates with the \stryker4s-testrunner\ library, enabling better compiler error detection and rollback support. The plugin now enforces a minimum SBT version of 1.11.2 and includes fixes for Windows glob expressions, cross-project compatibility, and fatal warning handling during mutation.

modules/sbt/src/main/scala/stryker4s/sbt · high confidence

The test runner module has been rewritten in Scala, replacing the previous implementation. It now communicates with the main process via TCP or Unix sockets, resolving the connection type from system properties. The new runner manages test execution and mutation testing through a message handler, leveraging the sbt testing interface to run tests and collect coverage data concurrently.

modules/testRunner · high confidence

The SBT plugin's compatibility layer has been updated to support SBT 2.x. This change modifies how tasks are executed to detach the build state, preventing errors from bubbling up during task runs, and adapts internal path conversion methods to align with SBT 2.x APIs.

modules/sbt/src/main/scala-3 · high confidence

The SBT plugin now correctly scopes task queries (such as loading test frameworks and compiling) to the specific invoking project. This resolves a bug where running Stryker in a subproject (e.g., \app/stryker\) incorrectly resolved against the auto-generated root project, which previously led to empty test frameworks and a silent 0% mutation score. The fix ensures that mutation testing works accurately in multi-project SBT builds where the target code resides in a subdirectory.

modules/sbt/src/sbt-test/sbt-stryker4s/test-subproject · high confidence

Add Mill integration test scaffolding; Add SBT plugin scripted test suite for mutation testing; Added tests for Maven plugin components; Added tests for TestInterfaceMapper; Added tests for the Mill plugin integration.

The Maven plugin's build configuration has been updated to use Scala 3.9.0 and align with Maven 3.9.16 core and plugin APIs. This upgrade ensures compatibility with the latest Maven ecosystem standards and Scala 3 features for the mutation testing plugin.

(dependencies) · high confidence

The build system has been upgraded to SBT 2.0.8 and the project now compiles against Scala 3.8.4 (alongside LTS 3.3.8 and Scala 2.13/2.12). This upgrade includes a migration to the SBT 2.x plugin ecosystem (e.g., sbt-protoc 1.1.0-RC2) and updates core dependencies like sttp to 4.0.26 and scalameta to 4.17.4. The build now supports cross-compilation for a new Mill plugin module and configures the SBT plugin to build against SBT 2.0.0 for Scala 2.13+ targets.

project · high confidence

The repository has been initialized with essential configuration files, including \.scalafmt.conf\ (version 3.11.5), \.scalafix.conf\ (OrganizeImports), \.scala-steward.conf\, and \.gitignore\, alongside a comprehensive \CLAUDE.md\ guide and an expanded \README.md\ detailing the Stryker4s mutation testing framework for Scala.

(repo-wide) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• First survey — no prior run to compare against. CAI 67.

• Code Health 97
• Architecture 93
• Maturity 68
• Readiness 65
• Security 62

• 300 commits — 281 feature/other, 19 fixes

• project/Dependencies.scala — 58 commits
• maven/pom.xml — 57 commits
• .github/workflows — 42 commits
• modules/core — 36 commits
• (root) — 31 commits
• modules/sbt — 23 commits
• project/build.properties — 19 commits
• project/Settings.scala — 11 commits
• project/plugins.sbt — 8 commits
• modules/mill — 3 commits
• (repo) — 2 commits
• .github/setup — 2 commits
• modules/testRunner — 2 commits
• .github/pull_request_template.md — 1 commit
• bin/scalafmt — 1 commit
• docs/configuration.md — 1 commit
• docs/getting-started.md — 1 commit
• maven/src — 1 commit
• modules/commandRunner — 1 commit

• fix: fix(regex): fix regex matching for postfix calls (#2113)
• fix: fix(rollback): fix line-offset handling for compile error rollback (#2088)
• fix: fix(rollback): use offset for compile error location when available (#2013)
• fix: fix(sbt): read test-runner responses on demand to avoid teardown race (#1861) (#2010)
• fix: fix(sbt): scope task queries to the invoking project (#1994)
• fix: fix(sbt): strip -Werror alongside -Xfatal-warnings (#1999)
• fix: fix(sbt2): detach state when running tasks to avoid errors bubbling up (#2095)
• fix: fix(scala-dialect): support Scala 3.9 (#2039)
• fix: fix(testrunner): create new framework instance for each run (fixing Weaver compatibility) (#2091)
• fix: fix(testrunner): handle messages larger than socket buffer (#2068)
• fix: fix(unix-sockets): use temp file for socket path instead of fixed path (#1958)
• fix: fix: always preserve original statement in mutation switch case (#2045)
• fix: fix: disable Scala3 pattern match exhaustiveness check (#2023)
• fix: fix: fix test-runner timeouts (#1950)
• fix: fix: improve exclude-annotation matching (#2063)
• fix: fix: place coverage statement inside wildcard block instead of in condition (#2024)
• fix: fix: report correct location for statements with comments (#2025)
• fix: fix: splice only outermost mutated statements (fixes IndexOutOfBoundsException) (#2115)
• fix: fix: target java-output-version 17 (#2040)
• change: Add mill-plugin mutation testing job
• …and 280 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

stryker-mutator/stryker4s was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.