src/Validator/ResultType.php (1)

25-36: Consider documenting the strict mode behavior.

The method handles strict mode only for WARNING cases but not for ERROR. This is likely intentional (errors always fail regardless of strict mode), but it would be helpful to add a PHPDoc comment explaining this behavior for clarity.

+    /**
+     * Resolves the result type to a command exit code.
+     * 
+     * @param bool $dryRun If true, always returns SUCCESS
+     * @param bool $strict If true, treats WARNINGs as failures
+     * @return int Command exit code (SUCCESS or FAILURE)
+     */
     public function resolveErrorToCommandExitCode(bool $dryRun, bool $strict): int

src/Command/ValidateTranslationCommand.php (2)

111-117: Consider performance impact of instantiating validators in the loop.

Moving validator instantiation inside the nested loops (line 111) means the same validator class could be instantiated multiple times. This might impact performance for large file sets.

Consider caching validator instances:

 $validators = $input->getOption('validator') ? [$input->getOption('validator')] : ValidatorRegistry::getAvailableValidators();
 $issues = [];
+$validatorInstances = [];

 // ToDo: Simplify this nested loop structure
 foreach ($allFiles as $parser => $paths) {
     foreach ($paths as $path => $translationSets) {
         foreach ($translationSets as $setKey => $files) {
             foreach ($validators as $validator) {
-                $validatorInstance = new $validator($this->logger);
+                if (!isset($validatorInstances[$validator])) {
+                    $validatorInstances[$validator] = new $validator($this->logger);
+                }
+                $validatorInstance = $validatorInstances[$validator];
                 $result = $validatorInstance->validate($files, $parser);

---

194-199: Consider simplifying the else clause (optional).

The static analysis tool suggests removing the else clause for cleaner code. While the current code is readable, you could consider early return pattern.

 if ($this->resultType->notFullySuccessful()) {
     $this->io->newLine();
     $this->io->{$this->dryRun ? 'warning' : 'error'}(
         $this->dryRun
             ? 'Language validation failed and completed in dry-run mode.'
             : 'Language validation failed.'
     );
-} else {
-    $message = 'Language validation succeeded.';
-    $this->output->isVerbose()
-        ? $this->io->success($message)
-        : $this->output->writeln('<fg=green>'.$message.'</>');
+    return $this->resultType->resolveErrorToCommandExitCode($this->dryRun, false);
 }

-return $this->resultType->resolveErrorToCommandExitCode($this->dryRun, false);
+$message = 'Language validation succeeded.';
+$this->output->isVerbose()
+    ? $this->io->success($message)
+    : $this->output->writeln('<fg=green>'.$message.'</>');
+
+return Command::SUCCESS;

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

tests/src/Validator/ResultTypeTest.php (1)

29-66: Excellent comprehensive testing of resolveErrorToCommandExitCode() method.

The test covers all 12 possible combinations (3 enum values × 2 dryRun flags × 2 strict flags) with clear comments explaining each scenario. The expected results align perfectly with the implementation logic:

• ERROR fails unless it's a dry run
• WARNING fails only in strict mode
• SUCCESS always succeeds

The explicit approach makes the test cases very clear and maintainable.

For future maintenance, you could consider using a data provider to make the test more concise:

/**
 * @dataProvider resolveErrorToCommandExitCodeProvider
 */
public function testResolveErrorToCommandExitCode(ResultType $resultType, bool $dryRun, bool $strict, int $expected): void
{
    $this->assertSame($expected, $resultType->resolveErrorToCommandExitCode($dryRun, $strict));
}

public function resolveErrorToCommandExitCodeProvider(): array
{
    return [
        'ERROR, not dryRun, not strict' => [ResultType::ERROR, false, false, Command::FAILURE],
        'ERROR, dryRun, not strict' => [ResultType::ERROR, true, false, Command::SUCCESS],
        // ... other test cases
    ];
}

However, the current explicit approach is also perfectly valid and may be more readable for this specific case.

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro