@intentsolutionsio/mutation-test-runner 1.0.0

package/.claude-plugin/plugin.json

@@ -0,0 +1,19 @@
+{
+  "name": "mutation-test-runner",
+  "version": "1.0.0",
+  "description": "Mutation testing to validate test quality by introducing code changes and verifying tests catch them",
+  "author": {
+    "name": "Claude Code Plugins",
+    "email": "[email protected]"
+  },
+  "repository": "https://github.com/jeremylongshore/claude-code-plugins",
+  "license": "MIT",
+  "keywords": [
+    "testing",
+    "mutation-testing",
+    "test-quality",
+    "stryker",
+    "pitest",
+    "agent-skills"
+  ]
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Claude Code Plugins
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,36 @@
+# Mutation Test Runner Plugin
+
+Validate test suite effectiveness through mutation testing - introducing code changes and verifying tests catch them.
+
+## Features
+
+- **Mutation generation** - Arithmetic, logical, conditional mutations
+- **Test validation** - Verify tests catch introduced bugs
+- **Mutation score calculation** - Test quality metric
+- **Survivor analysis** - Identify weak test coverage
+- **Framework support** - Stryker, PITest, mutmut, Mutant
+
+## Installation
+
+```bash
+/plugin install mutation-test-runner@claude-code-plugins-plus
+```
+
+## Usage
+
+```
+Run mutation testing on the validator module
+Analyze mutation test results and suggest improvements
+```
+
+## Mutation Types
+
+- **Arithmetic** - `+` → `-`, `*` → `/`
+- **Comparison** - `>` → `>=`, `==` → `!=`
+- **Logical** - `&&` → `||`, `!` removal
+- **Boolean** - `true` → `false`
+- **Conditionals** - Remove if statements
+
+## License
+
+MIT

package/agents/mutation-tester.md

@@ -0,0 +1,86 @@
+---
+name: mutation-tester
+description: Validate test quality through mutation testing
+---
+# Mutation Test Runner Agent
+
+Validate test suite quality by introducing code mutations and verifying tests catch them.
+
+## Mutation Testing Concept
+
+Mutation testing modifies ("mutates") code to check if tests detect the changes:
+- **Mutant killed**  - Test failed (good, caught the bug)
+- **Mutant survived**  - Test passed (bad, missed the bug)
+
+## Common Mutations
+
+1. **Arithmetic Operators** - `+` to `-`, `*` to `/`
+2. **Comparison Operators** - `>` to `>=`, `==` to `!=`
+3. **Logical Operators** - `&&` to `||`, `!` removal
+4. **Boolean Literals** - `true` to `false`
+5. **Return Values** - Change return values
+6. **Conditionals** - Remove if statements
+7. **Increments** - `++` to `--`
+
+## Example
+
+```javascript
+// Original code
+function isPositive(num) {
+  return num > 0;
+}
+
+// Mutation 1: Change > to >=
+function isPositive(num) {
+  return num >= 0;  // Should fail test for isPositive(0)
+}
+
+// Mutation 2: Change > to <
+function isPositive(num) {
+  return num < 0;  // Should fail all tests
+}
+```
+
+## Mutation Testing Tools
+
+- **JavaScript**: Stryker Mutator
+- **Python**: mutmut, cosmic-ray
+- **Java**: PITest
+- **C#**: Stryker.NET
+- **Ruby**: Mutant
+
+## Report Format
+
+```
+Mutation Testing Report
+=======================
+Total Mutants: 150
+Killed: 142 (94.7%) 
+Survived: 8 (5.3%) 
+Timeout: 0
+No Coverage: 0
+
+Mutation Score: 94.7%
+
+Survived Mutants:
+  src/utils/validator.js:23
+    - Replaced > with >= 
+    - Suggests missing boundary test
+
+  src/api/users.js:45
+    - Replaced && with ||
+    - Suggests missing logic test
+
+Recommendations:
+  1. Add boundary test for validator edge case
+  2. Test logical conditions in user API
+  3. Overall test quality: Excellent (>90%)
+```
+
+## Best Practices
+
+- Run after achieving high code coverage
+- Focus on survived mutants
+- Add tests to kill survivors
+- Aim for 80%+ mutation score
+- Expensive operation - run periodically

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@intentsolutionsio/mutation-test-runner",
+  "version": "1.0.0",
+  "description": "Mutation testing to validate test quality by introducing code changes and verifying tests catch them",
+  "keywords": [
+    "testing",
+    "mutation-testing",
+    "test-quality",
+    "stryker",
+    "pitest",
+    "agent-skills",
+    "claude-code",
+    "claude-plugin",
+    "tonsofskills"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jeremylongshore/claude-code-plugins-plus-skills.git",
+    "directory": "plugins/testing/mutation-test-runner"
+  },
+  "homepage": "https://tonsofskills.com/plugins/mutation-test-runner",
+  "bugs": "https://github.com/jeremylongshore/claude-code-plugins-plus-skills/issues",
+  "license": "MIT",
+  "author": {
+    "name": "Claude Code Plugins",
+    "email": "[email protected]"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "README.md",
+    ".claude-plugin",
+    "skills",
+    "agents"
+  ],
+  "scripts": {
+    "postinstall": "node -e \"console.log(\\\"\\\\n→ This npm package is a tracking/proof artifact. Install the plugin via:\\\\n  ccpi install mutation-test-runner\\\\n  or /plugin install mutation-test-runner@claude-code-plugins-plus in Claude Code\\\\n\\\")\""
+  }
+}

package/skills/running-mutation-tests/SKILL.md

@@ -0,0 +1,125 @@
+---
+name: running-mutation-tests
+description: |
+  Execute mutation testing to evaluate test suite effectiveness.
+  Use when performing specialized testing.
+  Trigger with phrases like "run mutation tests", "test the tests", or "validate test effectiveness".
+
+allowed-tools: Read, Write, Edit, Grep, Glob, Bash(test:mutation-*)
+version: 1.0.0
+author: Jeremy Longshore <jeremy@intentsolutions.io>
+license: MIT
+compatible-with: claude-code, codex, openclaw
+tags: [testing, mutation-tests]
+---
+# Mutation Test Runner
+
+## Overview
+
+Execute mutation testing to evaluate the effectiveness of a test suite by systematically introducing small code changes (mutants) and checking whether existing tests detect them. A killed mutant means the tests caught the change; a surviving mutant reveals a testing gap.
+
+## Prerequisites
+
+- Mutation testing framework installed (Stryker, mutmut, PITest, or go-mutesting)
+- Existing test suite with reasonable pass rate (all tests must pass before mutation testing)
+- Source code with functions and logic suitable for mutation (conditionals, arithmetic, return values)
+- Sufficient CI resources (mutation testing runs the test suite once per mutant -- CPU-intensive)
+- Configuration file for the mutation tool specifying target files and test commands
+
+## Instructions
+
+1. Verify the existing test suite passes completely:
+   - Run the full test suite and confirm 100% pass rate.
+   - Fix any failing or skipped tests before proceeding.
+   - Mutation testing is meaningless if the baseline tests are broken.
+2. Configure the mutation testing tool:
+   - Stryker: Create `stryker.config.mjs` with `mutate` patterns, test runner, and thresholds.
+   - mutmut: Configure `setup.cfg` or `pyproject.toml` with `[mutmut]` section.
+   - PITest: Add Maven/Gradle plugin with target classes and test configurations.
+3. Select target files for mutation:
+   - Focus on business logic modules (not configuration, constants, or type definitions).
+   - Exclude auto-generated code, third-party wrappers, and test utilities.
+   - Start with a small scope (one module) to validate setup before expanding.
+4. Run the mutation testing suite:
+   - Execute `npx stryker run`, `mutmut run`, or `mvn pitest:mutationCoverage`.
+   - Monitor progress -- expect long execution times (10-100x normal test runtime).
+   - Use incremental mode if available to skip already-tested mutants.
+5. Analyze the mutation report:
+   - **Killed mutants**: Tests detected the change -- indicates strong test coverage.
+   - **Survived mutants**: Tests did not catch the change -- indicates a testing gap.
+   - **Timed out mutants**: Mutation caused an infinite loop -- generally acceptable.
+   - **No coverage mutants**: The mutated code is not exercised by any test.
+6. For each surviving mutant, determine the appropriate action:
+   - Write a new test that specifically catches the mutation.
+   - Or determine the mutation is equivalent (functionally identical to original) and mark as ignored.
+7. Set mutation score thresholds (recommended: 80% kill rate) and integrate into CI as a quality gate.
+
+## Output
+
+- Mutation testing report (HTML or JSON) with killed/survived/timed-out counts
+- Mutation score percentage (killed / total non-equivalent mutants)
+- Surviving mutant inventory with file, line, mutation type, and suggested test
+- New test cases written to kill surviving mutants
+- CI configuration with mutation score threshold enforcement
+
+## Error Handling
+
+| Error | Cause | Solution |
+|-------|-------|---------|
+| Mutation run takes hours | Too many files in scope or slow test suite | Narrow `mutate` scope to critical modules; use `--incremental` mode; parallelize with `--concurrency` |
+| All mutants survive | Tests only check for truthiness, not specific values | Strengthen assertions -- use `toBe(42)` instead of `toBeTruthy()`; add boundary checks |
+| Equivalent mutant false positive | Mutation produces functionally identical code (e.g., `x >= 0` vs `x > -1`) | Mark as equivalent in config; ignore in score calculation; document rationale |
+| Out of memory during run | Too many concurrent mutation workers | Reduce `--concurrency` setting; increase Node.js `--max-old-space-size`; reduce shard size |
+| Stryker "initial test run failed" | Test suite does not pass cleanly before mutations begin | Fix all failing tests first; ensure `npm test` exits 0; check test runner configuration |
+
+## Examples
+
+**Stryker configuration for TypeScript project:**
+```javascript
+// stryker.config.mjs
+export default {
+  mutate: ['src/**/*.ts', '!src/**/*.d.ts', '!src/**/index.ts'],
+  testRunner: 'jest',
+  jest: { configFile: 'jest.config.ts' },
+  reporters: ['html', 'clear-text', 'progress'],
+  thresholds: { high: 80, low: 60, break: 50 },
+  concurrency: 4,
+  timeoutMS: 10000,  # 10000: 10 seconds in ms
+};
+```
+
+**Example surviving mutant and fix:**
+```
+Mutant: src/utils/discount.ts:15 -- ConditionalExpression
+  Original:  if (total > 100)
+  Mutant:    if (total >= 100)
+  Status:    SURVIVED
+
+Fix -- add boundary test:
+it('does not apply discount at exactly 100', () => {
+  expect(calculateDiscount(100)).toBe(0);
+});
+it('applies discount above 100', () => {
+  expect(calculateDiscount(101)).toBe(10.1);
+});
+```
+
+**mutmut for Python:**
+```bash
+# Run mutation testing
+mutmut run --paths-to-mutate=src/ --tests-dir=tests/
+
+# View surviving mutants
+mutmut results
+
+# Inspect a specific mutant
+mutmut show 42
+```
+
+## Resources
+
+- Stryker Mutator: https://stryker-mutator.io/
+- mutmut (Python): https://github.com/boxed/mutmut
+- PITest (Java): https://pitest.org/
+- go-mutesting: https://github.com/zimmski/go-mutesting
+- Mutation testing theory: https://en.wikipedia.org/wiki/Mutation_testing

package/skills/running-mutation-tests/assets/README.md

@@ -0,0 +1,7 @@
+# Assets
+
+Bundled resources for mutation-test-runner skill
+
+- [ ] mutation_report_template.md: Template for generating a detailed mutation test report with key metrics and findings.
+- [ ] example_mutation_results.json: Example JSON output from a mutation testing framework for demonstration purposes.
+- [ ] config_template.yaml: Template for configuring the mutation testing framework.

package/skills/running-mutation-tests/assets/config_template.yaml

@@ -0,0 +1,76 @@
+# Configuration template for the mutation-test-runner plugin
+
+# General settings
+general:
+  # Name of the project
+  project_name: example-value # e.g., 'my-awesome-project'
+
+  # Path to the project's source code
+  source_path: src # Default source directory
+
+  # Path to the project's test suite
+  test_path: tests # Default test directory
+
+  # Number of CPU cores to use for mutation testing.  -1 means use all available cores.
+  workers: -1
+
+  # Time limit (in seconds) for each test execution during mutation testing.  Increase if your tests are slow.
+  timeout: 60
+
+# Mutation framework configuration
+framework:
+  # Name of the mutation testing framework to use.  Supported: stryker, pitest, mutmut, mutant
+  name: stryker # Default framework
+
+  # Version of the mutation testing framework.  Leave blank to use the latest.
+  version: "" # Optional: Specify a version e.g., "3.0.0"
+
+  # Framework-specific configuration options.  Consult the framework's documentation for available options.
+  # Example for Stryker:
+  options:
+    mutate: # files or globs to mutate
+      - 'src/**/*.js'
+      - '!src/**/*.test.js'
+    packageManager: 'npm' # npm, yarn, pnpm
+    reporters: # reporters to use
+      - 'html'
+      - 'clear-text'
+
+# Mutation operators to apply.  Leave empty to use the framework's defaults.
+# Consult the framework's documentation for supported mutation operators.
+mutators:
+  # List of mutators to apply.  Examples: 'ArithmeticOperator', 'LogicalOperator', 'ConditionalExpression'
+  # Example for PITest:
+  - org.pitest.mutationtest.engine.gregor.mutators.ReturnValsMutator
+  - org.pitest.mutationtest.engine.gregor.mutators.VoidMethodCallMutator
+
+# Reporting configuration
+reporting:
+  # Output format for the mutation testing results.  Supported: html, json, csv, console
+  format: html # Default output format
+
+  # Path to the output directory for the reports.
+  output_path: reports # Default output directory
+
+  # Whether to generate a detailed report for each mutation.  Can significantly increase the report size.
+  detailed_report: false
+
+# Advanced settings (optional)
+advanced:
+  # List of files or directories to exclude from mutation testing.
+  exclude:
+    - node_modules
+    - vendor
+
+  # Custom command to run the test suite.  Overrides the default test command.
+  test_command: npm test # Default test command
+
+  # Environment variables to set during test execution.
+  environment:
+    NODE_ENV: test # Example environment variable
+    YOUR_VARIABLE: YOUR_VALUE_HERE
+
+# Thresholds for mutation score
+thresholds:
+  high: 80 # Percentage - High quality score
+  low: 60 # Percentage - Low quality score, needs improvement

package/skills/running-mutation-tests/assets/example_mutation_results.json

@@ -0,0 +1,155 @@
+{
+  "_comment": "Example mutation testing results JSON. Use this as a template for your own results.",
+  "project": "example-project",
+  "version": "1.0.0",
+  "timestamp": "2024-01-26T10:00:00Z",
+  "mutationScore": 85.71,
+  "_comment": "Overall mutation score. Higher is better.",
+  "summary": {
+    "totalMutations": 21,
+    "killed": 18,
+    "survived": 3,
+    "timeout": 0,
+    "noCoverage": 0,
+    "runtimeErrors": 0,
+    "compileErrors": 0,
+    "ignored": 0
+  },
+  "files": [
+    {
+      "path": "src/calculator.js",
+      "_comment": "Relative path to the file.",
+      "mutations": [
+        {
+          "id": 1,
+          "location": {
+            "start": {
+              "line": 5,
+              "column": 9
+            },
+            "end": {
+              "line": 5,
+              "column": 10
+            }
+          },
+          "mutatorName": "ArithmeticOperator",
+          "_comment": "Type of mutation applied.",
+          "original": "+",
+          "replacement": "-",
+          "status": "Killed",
+          "_comment": "Killed: Test caught the mutation. Survived: Mutation went undetected.",
+          "killingTest": "test/calculator.test.js:test addition",
+          "_comment": "Test that killed the mutation.  Null if survived.",
+          "description": "Replaced + with -",
+           "static": false
+        },
+        {
+          "id": 2,
+          "location": {
+            "start": {
+              "line": 9,
+              "column": 9
+            },
+            "end": {
+              "line": 9,
+              "column": 10
+            }
+          },
+          "mutatorName": "ArithmeticOperator",
+          "original": "-",
+          "replacement": "+",
+          "status": "Killed",
+          "killingTest": "test/calculator.test.js:test subtraction",
+          "description": "Replaced - with +",
+          "static": false
+        },
+        {
+          "id": 3,
+          "location": {
+            "start": {
+              "line": 13,
+              "column": 9
+            },
+            "end": {
+              "line": 13,
+              "column": 10
+            }
+          },
+          "mutatorName": "ArithmeticOperator",
+          "original": "*",
+          "replacement": "/",
+          "status": "Survived",
+          "_comment": "This mutation survived, indicating a gap in the test suite.",
+          "killingTest": null,
+          "description": "Replaced * with /",
+          "static": false
+        }
+      ]
+    },
+    {
+      "path": "src/utils.js",
+      "mutations": [
+        {
+          "id": 4,
+          "location": {
+            "start": {
+              "line": 2,
+              "column": 5
+            },
+            "end": {
+              "line": 2,
+              "column": 7
+            }
+          },
+          "mutatorName": "ConditionalExpression",
+          "original": ">=",
+          "replacement": "<",
+          "status": "Killed",
+          "killingTest": "test/utils.test.js:test isPositive",
+          "description": "Replaced >= with <",
+          "static": false
+        },
+        {
+          "id": 5,
+          "location": {
+            "start": {
+              "line": 6,
+              "column": 12
+            },
+            "end": {
+              "line": 6,
+              "column": 14
+            }
+          },
+          "mutatorName": "LogicalOperator",
+          "original": "&&",
+          "replacement": "||",
+          "status": "Killed",
+          "killingTest": "test/utils.test.js:test isValid",
+          "description": "Replaced && with ||",
+          "static": false
+        },
+        {
+          "id": 6,
+          "location": {
+            "start": {
+              "line": 10,
+              "column": 4
+            },
+            "end": {
+              "line": 10,
+              "column": 5
+            }
+          },
+          "mutatorName": "BooleanLiteral",
+          "original": "true",
+          "replacement": "false",
+          "status": "Survived",
+          "killingTest": null,
+          "description": "Replaced true with false",
+          "static": false
+        }
+      ]
+    }
+  ]
+}

package/skills/running-mutation-tests/assets/mutation_report_template.md

@@ -0,0 +1,154 @@
+# Mutation Test Report
+
+**Plugin:** mutation-test-runner
+
+**Date:** `[Date of Report Generation]`
+
+**Project:** `[Project Name]`
+
+**Version:** `[Project Version or Commit Hash]`
+
+**Report Generated By:** `[Your Name/Team Name]`
+
+## Executive Summary
+
+`[Provide a brief overview of the mutation testing results. Highlight key findings, overall mutation score, and any immediate actions required. For example: "This report details the results of mutation testing conducted on the [Project Name] project. The overall mutation score is [Mutation Score], indicating [Level of Test Coverage - e.g., adequate, concerning, poor] test coverage.  [Number] mutants survived, requiring further investigation to improve test suite effectiveness."]`
+
+## Key Metrics
+
+| Metric              | Value        | Description                                                                                                                            |
+|----------------------|--------------|----------------------------------------------------------------------------------------------------------------------------------------|
+| **Mutation Score**   | `[Mutation Score - e.g., 85%]` | Percentage of mutants killed by the test suite.  A higher score indicates better test coverage.                          |
+| **Mutants Generated** | `[Number]`     | Total number of mutations injected into the codebase.                                                                                 |
+| **Mutants Killed**    | `[Number]`     | Number of mutants that were successfully detected by the test suite.                                                               |
+| **Mutants Survived**  | `[Number]`     | Number of mutants that were *not* detected by the test suite, indicating potential weaknesses in test coverage.                       |
+| **Timeout Mutants**   | `[Number]`     | Number of mutants that caused a timeout during test execution.  This may indicate performance issues or infinite loops introduced by the mutant. |
+| **No Coverage Mutants** | `[Number]`     | Number of mutants in code that is not covered by any tests.                                                                       |
+| **Runtime Errors**    | `[Number]`     | Number of mutants that caused runtime errors during test execution.  These errors may indicate issues with the codebase itself.          |
+| **Covered Code**      | `[Percentage]` | Percentage of code covered by tests.                                                                                             |
+
+## Detailed Results
+
+### Surviving Mutants
+
+`[This section provides a detailed breakdown of each surviving mutant.  For each mutant, include the following information.  Provide at least 2-3 examples.]`
+
+**Mutant ID:** `[Unique identifier for the mutant]`
+
+**File:** `[Path to the file containing the mutant]`
+
+**Line Number:** `[Line number where the mutation was injected]`
+
+**Mutation Type:** `[Type of mutation - e.g., Arithmetic Operator Replacement, Conditional Expression Negation]`
+
+**Original Code:**
+
+```
+[Original code snippet]
+```
+
+**Mutated Code:**
+
+```
+[Mutated code snippet]
+```
+
+**Description:** `[A brief explanation of the mutation and its potential impact.]`
+
+**Reason for Survival:** `[Hypothesized reason why the test suite failed to detect this mutant. For example: "Missing test case for this specific scenario," "Insufficient assertion to catch the changed behavior," "Test only checks for the happy path."]`
+
+**Recommendations:** `[Specific actions to take to address the surviving mutant. For example: "Add a new test case to cover the edge case," "Strengthen the existing assertion to verify the mutated behavior," "Review the logic in this section of code."]`
+
+**Example 1:**
+
+**Mutant ID:** 123
+
+**File:** `src/calculator.py`
+
+**Line Number:** 25
+
+**Mutation Type:** Arithmetic Operator Replacement
+
+**Original Code:**
+
+```python
+def add(x, y):
+  return x + y
+```
+
+**Mutated Code:**
+
+```python
+def add(x, y):
+  return x - y
+```
+
+**Description:**  Replaced the addition operator with subtraction.
+
+**Reason for Survival:** The existing test suite only tested positive numbers and didn't include a test case where the result of the addition would be negative.
+
+**Recommendations:** Add a test case to `test_calculator.py` that tests the `add` function with inputs that result in a negative sum.
+
+**Example 2:**
+
+**Mutant ID:** 456
+
+**File:** `src/string_utils.py`
+
+**Line Number:** 10
+
+**Mutation Type:** Conditional Expression Negation
+
+**Original Code:**
+
+```python
+def is_valid_email(email):
+  if "@" in email:
+    return True
+  else:
+    return False
+```
+
+**Mutated Code:**
+
+```python
+def is_valid_email(email):
+  if "@" not in email:
+    return True
+  else:
+    return False
+```
+
+**Description:** Negated the conditional expression, effectively inverting the logic of the function.
+
+**Reason for Survival:** The test suite only checked for valid email addresses but didn't explicitly test for invalid email addresses (those without the "@" symbol).
+
+**Recommendations:** Add test cases to `test_string_utils.py` that specifically test the `is_valid_email` function with invalid email address formats (e.g., missing "@" symbol, missing domain).
+
+### Timeout Mutants
+
+`[If any mutants timed out, provide details about them, including file, line number, and potential causes.]`
+
+### No Coverage Mutants
+
+`[List any mutants that were not covered by tests. This indicates dead code or areas where tests are completely missing.]`
+
+### Runtime Errors
+
+`[Detail any mutants that caused runtime errors. This might reveal underlying bugs in the code.]`
+
+## Analysis and Recommendations
+
+`[Provide a comprehensive analysis of the mutation testing results. Discuss the overall strengths and weaknesses of the test suite. Offer specific recommendations for improving test coverage and addressing the surviving mutants. Include actionable steps and prioritize areas for improvement.]`
+
+**Example Recommendations:**
+
+*   **Increase Test Coverage:** Focus on adding tests to cover the areas identified by the surviving mutants and no coverage mutants.
+*   **Strengthen Assertions:** Review existing test assertions to ensure they are robust enough to detect subtle changes in behavior.
+*   **Test Edge Cases:**  Pay particular attention to testing edge cases and boundary conditions.
+*   **Refactor Code:** In some cases, the surviving mutants may indicate areas of code that are overly complex or difficult to test. Consider refactoring these areas to improve testability.
+*   **Improve Test Data:**  Ensure the test data used is diverse and representative of real-world scenarios.
+
+## Conclusion
+
+`[Summarize the key findings and recommendations. Reiterate the importance of mutation testing as a tool for improving test suite effectiveness and ensuring code quality.  State the next steps for addressing the identified issues.]`

package/skills/running-mutation-tests/references/README.md

@@ -0,0 +1,4 @@
+# References
+
+Bundled resources for mutation-test-runner skill
+

package/skills/running-mutation-tests/scripts/README.md

@@ -0,0 +1,11 @@
+# Scripts
+
+Bundled resources for mutation-test-runner skill
+
+- [x] mutation_runner.py: Executes mutation tests using a specified framework (Stryker, PITest, mutmut, Mutant) and parses the results.
+- [x] mutation_analyzer.py: Analyzes the mutation test results to identify weak coverage areas and suggest improvements.
+- [x] test_selector.py: Selects the most relevant tests to run based on the mutations introduced, optimizing testing time.
+
+
+## Auto-Generated
+Scripts generated on 2025-12-10 03:48:17

package/skills/running-mutation-tests/scripts/mutation_analyzer.py

@@ -0,0 +1,134 @@
+#!/usr/bin/env python3
+"""
+mutation-test-runner - Analysis Script
+Analyzes the mutation test results to identify weak coverage areas and suggest improvements.
+Generated: 2025-12-10 03:48:17
+"""
+
+import os
+import json
+import argparse
+from pathlib import Path
+from typing import Dict, List
+from datetime import datetime
+
+class Analyzer:
+    def __init__(self, target_path: str):
+        self.target_path = Path(target_path)
+        self.stats = {
+            'total_files': 0,
+            'total_size': 0,
+            'file_types': {},
+            'issues': [],
+            'recommendations': []
+        }
+
+    def analyze_directory(self) -> Dict:
+        """Analyze directory structure and contents."""
+        if not self.target_path.exists():
+            self.stats['issues'].append(f"Path does not exist: {self.target_path}")
+            return self.stats
+
+        for file_path in self.target_path.rglob('*'):
+            if file_path.is_file():
+                self.analyze_file(file_path)
+
+        return self.stats
+
+    def analyze_file(self, file_path: Path):
+        """Analyze individual file."""
+        self.stats['total_files'] += 1
+        self.stats['total_size'] += file_path.stat().st_size
+
+        # Track file types
+        ext = file_path.suffix.lower()
+        if ext:
+            self.stats['file_types'][ext] = self.stats['file_types'].get(ext, 0) + 1
+
+        # Check for potential issues
+        if file_path.stat().st_size > 100 * 1024 * 1024:  # 100MB
+            self.stats['issues'].append(f"Large file: {file_path} ({file_path.stat().st_size // 1024 // 1024}MB)")
+
+        if file_path.stat().st_size == 0:
+            self.stats['issues'].append(f"Empty file: {file_path}")
+
+    def generate_recommendations(self):
+        """Generate recommendations based on analysis."""
+        if self.stats['total_files'] == 0:
+            self.stats['recommendations'].append("No files found - check target path")
+
+        if len(self.stats['file_types']) > 20:
+            self.stats['recommendations'].append("Many file types detected - consider organizing")
+
+        if self.stats['total_size'] > 1024 * 1024 * 1024:  # 1GB
+            self.stats['recommendations'].append("Large total size - consider archiving old data")
+
+    def generate_report(self) -> str:
+        """Generate analysis report."""
+        report = []
+        report.append("\n" + "="*60)
+        report.append(f"ANALYSIS REPORT - mutation-test-runner")
+        report.append("="*60)
+        report.append(f"Target: {self.target_path}")
+        report.append(f"Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+        report.append("")
+
+        # Statistics
+        report.append("📊 STATISTICS")
+        report.append(f"  Total Files: {self.stats['total_files']:,}")
+        report.append(f"  Total Size: {self.stats['total_size'] / 1024 / 1024:.2f} MB")
+        report.append(f"  File Types: {len(self.stats['file_types'])}")
+
+        # Top file types
+        if self.stats['file_types']:
+            report.append("\n📁 TOP FILE TYPES")
+            sorted_types = sorted(self.stats['file_types'].items(), key=lambda x: x[1], reverse=True)[:5]
+            for ext, count in sorted_types:
+                report.append(f"  {ext or 'no extension'}: {count} files")
+
+        # Issues
+        if self.stats['issues']:
+            report.append(f"\n⚠️  ISSUES ({len(self.stats['issues'])})")
+            for issue in self.stats['issues'][:10]:
+                report.append(f"  - {issue}")
+            if len(self.stats['issues']) > 10:
+                report.append(f"  ... and {len(self.stats['issues']) - 10} more")
+
+        # Recommendations
+        if self.stats['recommendations']:
+            report.append("\n💡 RECOMMENDATIONS")
+            for rec in self.stats['recommendations']:
+                report.append(f"  - {rec}")
+
+        report.append("")
+        return "\n".join(report)
+
+def main():
+    parser = argparse.ArgumentParser(description="Analyzes the mutation test results to identify weak coverage areas and suggest improvements.")
+    parser.add_argument('target', help='Target directory to analyze')
+    parser.add_argument('--output', '-o', help='Output report file')
+    parser.add_argument('--json', action='store_true', help='Output as JSON')
+
+    args = parser.parse_args()
+
+    print(f"🔍 Analyzing {args.target}...")
+    analyzer = Analyzer(args.target)
+    stats = analyzer.analyze_directory()
+    analyzer.generate_recommendations()
+
+    if args.json:
+        output = json.dumps(stats, indent=2)
+    else:
+        output = analyzer.generate_report()
+
+    if args.output:
+        Path(args.output).write_text(output)
+        print(f"✓ Report saved to {args.output}")
+    else:
+        print(output)
+
+    return 0 if len(stats['issues']) == 0 else 1
+
+if __name__ == "__main__":
+    import sys
+    sys.exit(main())