MutahunterAI

Generates intelligent, semantically meaningful code mutations using LLMs instead of predefined mutation operators. The LLMMutationEngine analyzes source code structure and uses LLM reasoning to create realistic mutations that mimic real-world programming errors (logic flaws, boundary conditions, operator changes) across multiple languages. This approach moves beyond simple syntactic transformations to produce mutations that test actual test suite comprehensiveness.

Analyzes source code across 40+ programming languages using tree-sitter's language-agnostic Abstract Syntax Tree (AST) parsing. The Analyzer component extracts mutation points (functions, control flow, expressions) from the AST without language-specific parsing logic, enabling a single mutation testing pipeline to handle Java, Python, JavaScript, Go, Rust, and others. This avoids the complexity of maintaining separate parsers per language.

Executes tests using the native test runner for the project (Maven, Gradle, pytest, npm test, etc.) rather than implementing language-specific test runners. The MutantTestRunner accepts a configurable test command that is executed as a subprocess, capturing exit codes and output to determine test results. This approach works with any test framework that can be invoked from the command line, making Mutahunter compatible with diverse testing ecosystems.

Identifies candidate code locations for mutation (functions, control flow statements, expressions) using AST analysis via the Analyzer component. The analyzer extracts structural information from the code (function boundaries, loop/conditional statements, operator expressions) and filters out non-testable code (comments, imports, trivial statements). This produces a focused set of mutation points that are semantically meaningful and likely to be exercised by tests, reducing the number of trivial or untestable mutations.

Executes test suites against individual mutants in isolation, running only the tests relevant to each mutation to minimize execution time. The MutantTestRunner applies test filtering logic to identify which tests exercise the mutated code region, then executes only those tests rather than the full suite. This is coordinated by the MutationTestController, which tracks test results and determines whether each mutant was 'killed' (test failed) or 'survived' (test passed).

The MutationTestController orchestrates the entire mutation testing workflow, managing the sequence of operations: initial dry run (verify tests pass), mutation generation, test execution, result processing, and report generation. It maintains state across the workflow (mutant counts, test results, statistics) and coordinates interactions between the LLMMutationEngine, Analyzer, MutantTestRunner, and ReportingSystem. The controller implements the process flow defined in the architecture, handling error recovery and result aggregation.

Abstracts LLM provider interactions through an LLMRouter that supports multiple LLM backends (OpenAI, Anthropic, Ollama, etc.) without changing mutation generation logic. The router handles API calls, token counting, and cost calculation for each provider, enabling users to switch providers or use multiple providers simultaneously. Cost tracking is built-in, reporting LLM API expenses alongside mutation testing results to help teams manage LLM usage budgets.

Generates detailed mutation testing reports that quantify test suite effectiveness through metrics like mutation score (percentage of killed mutants), killed/survived/timeout counts, and per-file/per-function mutation coverage. The ReportingSystem aggregates results from the MutationTestController and produces structured reports (JSON, HTML, or text) that identify which mutations survived (test gaps) and provide actionable insights for improving test coverage. Reports also include LLM cost breakdowns and execution time metrics.

The FileOperationHandler manages the creation and reversion of mutated code files on disk. For each mutation, it creates a temporary copy of the source file with the mutation applied, executes tests against the mutated file, then reverts the file to its original state. This approach avoids in-memory code manipulation and ensures test execution operates on actual file system state, matching real development workflows. File operations are tracked and logged for debugging.

Executes the full test suite on unmodified code before beginning mutation testing to verify that all tests pass. This dry run is performed by the MutationTestController as the first step in the workflow, ensuring that any test failures during mutation testing are due to mutations, not pre-existing test issues. If the dry run fails, mutation testing is aborted with a clear error message, preventing misleading mutation testing results.

Provides a CLI interface for running mutation testing with configuration options for source paths, test commands, LLM provider selection, and output formats. The CLI parses arguments and creates a configuration object that is passed to the MutationTestController. Configuration can be specified via command-line flags or a configuration file (YAML/JSON), enabling both interactive usage and CI/CD integration. The CLI includes help text and validation for required parameters.

Provides comprehensive logging throughout the mutation testing workflow, capturing details about mutation generation, test execution, file operations, and LLM API calls. Logs are written to files and optionally to stdout, with configurable verbosity levels (DEBUG, INFO, WARNING, ERROR). The logging system enables debugging of mutation testing failures and provides visibility into the execution flow, including timing information for performance analysis.