pi-dev-team 0.2.0

package/hooks/mutation_adapters/pitest.py

@@ -0,0 +1,266 @@
+"""pitest (Java/Kotlin) mutation-testing adapter — Python port of pitest.sh.
+
+Key features (mirroring bash):
+  - ADAPTER_TIMEOUT default 300s (Maven startup alone can eat 20-30s).
+  - Source class derived from the changed file → `-DtargetClasses`.
+  - `-DwithHistory` for incremental runs.
+  - `-DtimeoutConst` / `-DtimeoutFactor` cap per-mutant wall-clock time.
+  - Multi-module Maven: detect the module containing the changed file → `-pl`.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+from . import lib
+
+DEFAULT_REPORT = "target/pit-reports/mutations.xml"
+
+
+def _report_path() -> Path:
+    return Path(os.environ.get("PITEST_REPORT", DEFAULT_REPORT))
+
+
+def pitest_detect() -> bool:
+    """Return True when pitest is configured in this project."""
+    for name, needle in (
+        ("pom.xml", "pitest"),
+        ("build.gradle", "pitest"),
+        ("build.gradle.kts", "pitest"),
+    ):
+        p = Path(name)
+        if not p.is_file():
+            continue
+        try:
+            if needle in p.read_text():
+                return True
+        except OSError:
+            continue
+    print(
+        lib.emit_advisory(
+            "MUTATION GATE ADVISORY: pitest not found. Run /setup to "
+            "configure it, or add the pitest-maven plugin to pom.xml / pitest "
+            "plugin to build.gradle manually."
+        )
+    )
+    return False
+
+
+_SOURCE_ROOT_RE = re.compile(
+    r"^.*(?:src/main/java/|src/main/kotlin/|src/main/groovy/|src/)"
+)
+
+
+def _java_class_from_file(file: str) -> str:
+    """Convert a Java/Kotlin source path to a dotted class name.
+
+    src/main/java/com/example/Calculator.java → com.example.Calculator
+    """
+    if not file:
+        return ""
+    rel = _SOURCE_ROOT_RE.sub("", file, count=1)
+    rel = re.sub(r"\.(java|kt|groovy|scala)$", "", rel)
+    return rel.replace("/", ".")
+
+
+def _find_maven_module(file: str) -> str:
+    """Return the nearest sub-module dir containing `file`, or '' for root."""
+    if not file:
+        return ""
+    dir_ = os.path.dirname(file)
+    while dir_ and dir_ != ".":
+        if Path(dir_, "pom.xml").is_file() and Path("pom.xml").is_file():
+            return dir_
+        dir_ = os.path.dirname(dir_)
+    return ""
+
+
+def _is_gradle() -> bool:
+    return any(
+        Path(name).is_file()
+        for name in (
+            "build.gradle",
+            "build.gradle.kts",
+            "settings.gradle",
+            "settings.gradle.kts",
+        )
+    )
+
+
+def _is_pitest_source(line: str) -> bool:
+    """True for a non-test Java/Kotlin/Groovy/Scala source path."""
+    if not re.search(r"\.(java|kt|groovy|scala)$", line):
+        return False
+    return not ("Test" in line or "Spec" in line)
+
+
+def _changed_source_file() -> str:
+    """Return the first non-test Java/Kotlin/Groovy/Scala file from git diff."""
+    return lib.first_changed_file(_is_pitest_source)
+
+
+def _extract_test_class(command: str) -> str:
+    """Return the value of `-Dtest=<x>` in `command`, or ''."""
+    m = re.search(r"-Dtest=(\S+)", command)
+    return m.group(1) if m else ""
+
+
+_KILLING_TEST_RE = re.compile(r"<killingTest>([^<]+)</killingTest>")
+_FQ_METHOD_RE = re.compile(r"^[\w.]+\.\w+$")
+_SUREFIRE_RE = re.compile(r"^(\w+)\s+(Time elapsed|PASS|FAIL)")
+
+
+def pitest_parse(xml_file: Path, output_file: Path) -> None:
+    """Parse pitest XML + captured runner stdout; write zero-kills."""
+    xml_file = Path(xml_file)
+    output_file = Path(output_file)
+    runner_stdout = os.environ.get("ADAPTER_RUNNER_STDOUT", "")
+
+    if not xml_file.is_file():
+        print(
+            lib.emit_advisory(
+                f"MUTATION GATE ADVISORY: pitest report not found at {xml_file}. "
+                "Skipping mutation gate."
+            )
+        )
+        try:
+            output_file.write_text("[]")
+        except OSError:
+            pass
+        return
+
+    if not runner_stdout:
+        try:
+            content = xml_file.read_text()
+        except OSError:
+            content = ""
+        killed = content.count('status="KILLED"')
+        survived = content.count('status="SURVIVED"')
+        total = killed + survived
+        print(
+            lib.emit_advisory(
+                f"MUTATION GATE ADVISORY: pitest completed ({killed}/{total} "
+                "mutants killed) but per-test data unavailable — runner stdout "
+                "was not captured. Manual review recommended."
+            )
+        )
+        try:
+            output_file.write_text("[]")
+        except OSError:
+            pass
+        return
+
+    content = xml_file.read_text()
+    killing_set = {m.group(1).strip() for m in _KILLING_TEST_RE.finditer(content)}
+
+    test_methods = set()
+    for raw in runner_stdout.splitlines():
+        line = raw.strip()
+        if _FQ_METHOD_RE.match(line) and "." in line:
+            test_methods.add(line)
+        m = _SUREFIRE_RE.match(line)
+        if m:
+            test_methods.add(m.group(1))
+
+    zero_kills = []
+    for test in sorted(test_methods - killing_set):
+        zero_kills.append({"name": test, "file": None, "line": None, "covered": 0})
+    output_file.write_text(json.dumps(zero_kills))
+
+
+def pitest_run(output_file: Path) -> int:
+    """Run pitest via Maven or Gradle and write zero-kills."""
+    output_file = Path(output_file)
+    timeout_seconds = int(os.environ.get("ADAPTER_TIMEOUT", "300"))
+    command = os.environ.get("ADAPTER_COMMAND", "")
+
+    changed_file = _changed_source_file()
+    target_class = _java_class_from_file(changed_file) if changed_file else ""
+    target_tests = _extract_test_class(command)
+
+    pitest_args: list[str] = [
+        "-DtimeoutConst=60",
+        "-DtimeoutFactor=2.5",
+        "-DoutputFormats=XML",
+        "-DtimestampedReports=false",
+        "-DwithHistory",
+    ]
+    if target_class:
+        pitest_args.append(f"-DtargetClasses={target_class}*")
+    if target_tests:
+        pitest_args.append(f"-DtargetTests={target_tests}")
+
+    module_flag: list[str] = []
+    if changed_file:
+        module_dir = _find_maven_module(changed_file)
+        if module_dir:
+            module_flag = ["-pl", module_dir, "--also-make-dependents"]
+
+    report_path = _report_path()
+
+    if _is_gradle():
+        gradle_cmd = "./gradlew" if shutil.which("./gradlew") else "gradle"
+        gradle_args = ["pitest"]
+        if target_class:
+            gradle_args.append(f"-PtargetClasses={target_class}*")
+        argv = [gradle_cmd, *gradle_args]
+        report_path = Path(
+            os.environ.get("PITEST_REPORT", "build/reports/pitest/mutations.xml")
+        )
+    else:
+        mvn_cmd = "./mvnw" if Path("./mvnw").is_file() else "mvn"
+        argv = [mvn_cmd, "pitest:mutationCoverage", *module_flag, *pitest_args]
+
+    completed = lib.run_with_timeout(
+        timeout_seconds,
+        argv,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+    )
+    exit_code = completed.returncode
+
+    if exit_code == 124:
+        hint = (
+            " No source file detected for scoping — scope manually with git diff."
+            if not target_class
+            else ""
+        )
+        print(
+            lib.emit_advisory(
+                f"MUTATION GATE SKIPPED: pitest timed out after {timeout_seconds}s.{hint}"
+                " Or: MUTATION_GATE_TIMEOUT=<seconds> to extend the limit."
+            )
+        )
+        output_file.write_text("[]")
+        return 0
+
+    if exit_code != 0 and not report_path.is_file():
+        print(
+            lib.emit_advisory(
+                f"MUTATION GATE ADVISORY: pitest exited with code {exit_code} and "
+                "produced no report. Skipping mutation gate."
+            )
+        )
+        output_file.write_text("[]")
+        return 0
+
+    pitest_parse(report_path, output_file)
+    return 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = list(sys.argv[1:] if argv is None else argv)
+    if not args:
+        print("pitest.py: OUTPUT_FILE argument required", file=sys.stderr)
+        return 2
+    return pitest_run(Path(args[0]))
+
+
+if __name__ == "__main__":  # pragma: no cover
+    sys.exit(main())

package/hooks/mutation_adapters/stryker.py

@@ -0,0 +1,157 @@
+"""Stryker (JS/TS) mutation-testing adapter — Python port of stryker.sh.
+
+Contract mirrors the bash adapter:
+  ADAPTER_SOURCE_FILE   — source file to mutate (scopes `--mutate`)
+  ADAPTER_TIMEOUT       — outer wall-clock cap, seconds (default 300)
+Output: writes zero-kill JSON to the caller-supplied output path.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+from . import lib
+
+DEFAULT_REPORT = "reports/mutation/mutation.json"
+
+
+def _report_path() -> Path:
+    return Path(os.environ.get("STRYKER_REPORT", DEFAULT_REPORT))
+
+
+def stryker_detect() -> bool:
+    """Return True when Stryker is available in the current project."""
+    if Path("node_modules/.bin/stryker").is_file():
+        return True
+    pkg = Path("package.json")
+    if pkg.is_file():
+        try:
+            if "@stryker-mutator/core" in pkg.read_text():
+                return True
+        except OSError:
+            pass
+    print(
+        lib.emit_advisory(
+            "MUTATION GATE ADVISORY: Stryker not installed. Run /setup to "
+            "install it, or add @stryker-mutator/core manually."
+        )
+    )
+    return False
+
+
+def derive_source_file(test_file: str) -> str:
+    """Strip .test./.spec. from a test filename to yield the source filename.
+
+    e.g. calc.test.ts → calc.ts, calc.spec.js → calc.js.
+    """
+    return re.sub(r"\.(test|spec)\.(ts|tsx|js|jsx|mjs)$", r".\2", test_file)
+
+
+def _read_configured_timeout_ms() -> int | None:
+    """Return the project's `timeoutMS` from Stryker config, or None.
+
+    Checks `.strykerrc.json` first (pure JSON), then greps `stryker.config.*`.
+    """
+    rc = Path(".strykerrc.json")
+    if rc.is_file():
+        try:
+            cfg = json.loads(rc.read_text())
+            val = cfg.get("timeoutMS") or cfg.get("timeout")
+            if val:
+                return int(val)
+        except (OSError, ValueError):
+            pass
+        return None
+    for name in (
+        "stryker.config.js",
+        "stryker.config.mjs",
+        "stryker.config.cjs",
+        "stryker.config.ts",
+    ):
+        p = Path(name)
+        if not p.is_file():
+            continue
+        try:
+            content = p.read_text()
+        except OSError:
+            continue
+        m = re.search(r"timeoutMS[\s]*:[\s]*(\d+)", content)
+        if m:
+            return int(m.group(1))
+        return None
+    return None
+
+
+def stryker_run(output_file: Path) -> int:
+    """Run Stryker; write normalized zero-kills to `output_file`.
+
+    Advisory paths write `[]` and return 0 — the orchestrator treats those as
+    "gate skipped."
+    """
+    output_file = Path(output_file)
+    timeout_seconds = int(os.environ.get("ADAPTER_TIMEOUT", "300"))
+    src_file = os.environ.get("ADAPTER_SOURCE_FILE", "")
+
+    report = _report_path()
+    report.parent.mkdir(parents=True, exist_ok=True)
+
+    stryker_args: list[str] = ["--reporters", "json", "--coverageAnalysis", "perTest"]
+    if src_file:
+        stryker_args += ["--mutate", src_file]
+
+    argv = ["npx", "stryker", "run", *stryker_args]
+    completed = lib.run_with_timeout(
+        timeout_seconds,
+        argv,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+    )
+    exit_code = completed.returncode
+
+    if exit_code == 124:
+        configured = _read_configured_timeout_ms()
+        hint = (
+            ""
+            if configured is not None
+            else " Add 'timeoutMS: <ms>' to stryker.config.js to cap per-mutant runs."
+        )
+        print(
+            lib.emit_advisory(
+                f"MUTATION GATE SKIPPED: Stryker timed out after {timeout_seconds}s.{hint}"
+                " Or: MUTATION_GATE_TIMEOUT=<seconds> to extend the outer limit."
+            )
+        )
+        output_file.write_text("[]")
+        return 0
+
+    if exit_code != 0 and not report.is_file():
+        print(
+            lib.emit_advisory(
+                f"MUTATION GATE ADVISORY: Stryker exited with code {exit_code} and "
+                "produced no report. Skipping mutation gate."
+            )
+        )
+        output_file.write_text("[]")
+        return 0
+
+    advisory = lib.parse_stryker_kills(report, output_file)
+    if advisory is not None:
+        print(advisory)
+    return 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = list(sys.argv[1:] if argv is None else argv)
+    if not args:
+        print("stryker.py: OUTPUT_FILE argument required", file=sys.stderr)
+        return 2
+    return stryker_run(Path(args[0]))
+
+
+if __name__ == "__main__":  # pragma: no cover
+    sys.exit(main())

package/hooks/mutation_adapters/stryker_net.py

@@ -0,0 +1,264 @@
+"""Stryker.NET (C#) mutation-testing adapter — Python port of stryker-net.sh.
+
+Uses the same JSON schema as Stryker JS, so `lib.parse_stryker_kills` is
+shared. `stryker_net_run` intentionally stays separate from `stryker_run`:
+the CLI surfaces diverge, only the JSON parser is the stable contract.
+"""
+
+from __future__ import annotations
+
+import functools
+import json
+import os
+import re
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+from . import lib
+
+DEFAULT_REPORT = "StrykerOutput/mutation-report.json"
+
+#: Manual/test override for `stryker_net_version()` — an exact "X.Y.Z" (or
+#: any string containing one) value. Takes precedence over the real `dotnet
+#: stryker --version` probe. Exists so `stryker_xunit_shim_guard.py` (which
+#: runs in a real subprocess in its own tests, so it can't monkeypatch this
+#: module's internals) can pin a version, and as a manual escape hatch when
+#: the installed CLI's own `--version` output can't be trusted (#2184).
+_VERSION_OVERRIDE_ENV = "DEV_TEAM_STRYKER_NET_VERSION"
+
+_VERSION_RE = re.compile(r"(\d+)\.(\d+)\.(\d+)")
+
+
+def _default_report_path() -> Path:
+    return Path(os.environ.get("STRYKER_NET_REPORT", DEFAULT_REPORT))
+
+
+@functools.lru_cache(maxsize=1)
+def _stryker_net_version_probe() -> str | None:
+    """Cached raw stdout of `dotnet stryker --version`, or `None` when the
+    CLI can't be run at all (no `dotnet` on PATH, the subprocess failed to
+    start, or it exited non-zero).
+
+    Extracted as the single shared probe (#2184) — `stryker_net_detect()`
+    and `stryker_net_version()` both read through this rather than each
+    shelling out to `dotnet stryker --version` independently. Cached for
+    the lifetime of the process: this hook's own process only ever runs one
+    Stryker invocation, so a second call within it (e.g. detect-then-version
+    in the same run) should not pay for a second subprocess.
+
+    Test-only reset: `_stryker_net_version_probe.cache_clear()` (a plain
+    `functools.lru_cache` method) — required before any in-process test that
+    monkeypatches `subprocess.run`/`shutil.which`, since this cache is
+    otherwise shared across the whole pytest process.
+    """
+    if shutil.which("dotnet") is None:
+        return None
+    try:
+        proc = subprocess.run(
+            ["dotnet", "stryker", "--version"],
+            capture_output=True,
+            text=True,
+            check=False,
+            timeout=30,
+        )
+    except (OSError, subprocess.SubprocessError):
+        return None
+    if proc.returncode != 0:
+        return None
+    return proc.stdout or ""
+
+
+def _parse_version(text: str) -> tuple[int, int, int] | None:
+    """First `MAJOR.MINOR.PATCH` substring in `text`, or `None` when none is
+    found. Deliberately permissive about surrounding text (a `v` prefix, a
+    package name, a `+`-separated build/prerelease suffix like
+    `5.0.0-preview+abcdef`) — only the leading three dot-separated integers
+    are meaningful for the `>= 5.0.0` comparison this exists for."""
+    match = _VERSION_RE.search(text)
+    if match is None:
+        return None
+    return (int(match.group(1)), int(match.group(2)), int(match.group(3)))
+
+
+def stryker_net_version() -> tuple[int, int, int] | None:
+    """Parsed `(major, minor, patch)` of the installed Stryker.NET CLI, or
+    `None` when it can't be determined (not installed, `dotnet` missing, or
+    unparseable `--version` output) — callers must fail closed on `None`,
+    never assume a version (#2184).
+
+    Honors `DEV_TEAM_STRYKER_NET_VERSION` first (see that constant's
+    docstring); otherwise reads the shared, cached `dotnet stryker
+    --version` probe.
+    """
+    override = os.environ.get(_VERSION_OVERRIDE_ENV)
+    text = override if override is not None else _stryker_net_version_probe()
+    if text is None:
+        return None
+    return _parse_version(text)
+
+
+def stryker_net_detect() -> bool:
+    """Return True when Stryker.NET is available."""
+    tools = Path(".config/dotnet-tools.json")
+    if tools.is_file():
+        try:
+            if "dotnet-stryker" in tools.read_text():
+                return True
+        except OSError:
+            pass
+    if _stryker_net_version_probe() is not None:
+        return True
+    print(
+        lib.emit_advisory(
+            "MUTATION GATE ADVISORY: Stryker.NET not installed. Run /setup "
+            "to install it, or run: dotnet tool install dotnet-stryker"
+        )
+    )
+    return False
+
+
+def _shard_for_file(changed_file: str) -> Path | None:
+    """Return the stryker-config.shard-*.json whose `mutate` pattern covers
+    `changed_file`, or None when no shard matches.
+    """
+    if not changed_file:
+        return None
+    for shard_cfg in sorted(Path(".").glob("stryker-config.shard-*.json")):
+        try:
+            cfg = json.loads(shard_cfg.read_text())
+            stryker_cfg = cfg.get("stryker-config") or {}
+            patterns = stryker_cfg.get("mutate") or []
+            if not patterns:
+                continue
+            pattern = patterns[0]
+            # pattern is like 'src/Foo.Bar/**/*.cs' — extract prefix before '/**'
+            src_prefix = pattern.split("/**")[0]
+        except (OSError, ValueError):
+            continue
+        if not src_prefix:
+            continue
+        if changed_file.startswith((src_prefix + "/", src_prefix)):
+            return shard_cfg
+    return None
+
+
+def _is_cs_source(line: str) -> bool:
+    """True for a non-test C# source path."""
+    if not line.endswith(".cs"):
+        return False
+    return not ("Test" in line or "Spec" in line)
+
+
+def _changed_cs_file() -> str:
+    """Return the newest non-test C# file changed in HEAD (or cached), or ''."""
+    return lib.first_changed_file(_is_cs_source)
+
+
+def stryker_net_run(output_file: Path) -> int:
+    """Run dotnet-stryker; write normalized zero-kills to `output_file`."""
+    output_file = Path(output_file)
+    timeout_seconds = int(os.environ.get("ADAPTER_TIMEOUT", "600"))
+
+    report_path = _default_report_path()
+    report_path.parent.mkdir(parents=True, exist_ok=True)
+
+    stryker_args: list[str] = [
+        "--reporter",
+        "json",
+        "--coverage-analysis",
+        "perTest",
+        "--mutation-level",
+        "Standard",
+    ]
+
+    changed_file = _changed_cs_file()
+    config_flag: list[str] = []
+    if changed_file:
+        shard_cfg = _shard_for_file(changed_file)
+        if shard_cfg is not None:
+            config_flag = ["--config-file", str(shard_cfg)]
+            report_path = Path("StrykerOutput/gate-shard/reports/mutation-report.json")
+            report_path.parent.mkdir(parents=True, exist_ok=True)
+
+    if not config_flag and Path("stryker-config.json").is_file():
+        config_flag = ["--config-file", "stryker-config.json"]
+
+    if changed_file and config_flag:
+        stryker_args += ["--mutate", f"**/{Path(changed_file).name}"]
+        report_path = Path("StrykerOutput/gate-shard/reports/mutation-report.json")
+
+    stryker_args += ["--output", "StrykerOutput/gate-shard"]
+
+    if os.environ.get("CI") != "true":
+        since = os.environ.get("STRYKER_SINCE_TARGET", "")
+        if since:
+            # bash used `--since:<ref>`; keep the same wire form
+            stryker_args.append(f"--since:{since}")
+
+    argv = ["dotnet", "stryker", *config_flag, *stryker_args]
+
+    completed = lib.run_with_timeout(
+        timeout_seconds,
+        argv,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+    )
+    exit_code = completed.returncode
+    run_output = (completed.stdout or b"").decode("utf-8", "replace")
+
+    # Surface the coverage-capture failure (#1156): Stryker disabled per-test
+    # optimisation and fell back to whole-suite-per-mutant. The mutant-kill loop
+    # is infeasible on this suite (xunit.v3); a single-pass advisory with
+    # coverage-analysis off is the way forward. detect_coverage_capture_failure
+    # is the branchable predicate later slices (#1158) consume.
+    if lib.detect_coverage_capture_failure(run_output):
+        print(
+            lib.emit_advisory(
+                "MUTATION GATE ADVISORY: Stryker.NET coverage capture failed — "
+                "per-test optimisation disabled, falling back to "
+                "whole-suite-per-mutant. The mutant-kill loop is infeasible on "
+                "this suite (xunit.v3); prefer a single-pass advisory run with "
+                "coverage-analysis off, or waive. See #1156."
+            )
+        )
+
+    if exit_code == 124:
+        print(
+            lib.emit_advisory(
+                f"MUTATION GATE SKIPPED: Stryker.NET timed out after {timeout_seconds}s. "
+                "For large repos, run stryker-setup.py to generate shard configs "
+                "(reduces scope to one project). Or: ADAPTER_TIMEOUT=<seconds> to "
+                "extend the limit."
+            )
+        )
+        output_file.write_text("[]")
+        return 0
+
+    if exit_code != 0 and not report_path.is_file():
+        print(
+            lib.emit_advisory(
+                f"MUTATION GATE ADVISORY: Stryker.NET exited with code {exit_code} "
+                "and produced no report. Skipping mutation gate."
+            )
+        )
+        output_file.write_text("[]")
+        return 0
+
+    advisory = lib.parse_stryker_kills(report_path, output_file)
+    if advisory is not None:
+        print(advisory)
+    return 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = list(sys.argv[1:] if argv is None else argv)
+    if not args:
+        print("stryker_net.py: OUTPUT_FILE argument required", file=sys.stderr)
+        return 2
+    return stryker_net_run(Path(args[0]))
+
+
+if __name__ == "__main__":  # pragma: no cover
+    sys.exit(main())