codetool-shell 0.1.1__py3-none-win_amd64.whl

codetool_shell/filters/test_runner/detector.py

@@ -0,0 +1,409 @@
+"""Detect supported test-runner output shapes."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from enum import Enum
+
+
+class TestFramework(str, Enum):
+    """Supported test-runner families."""
+
+    PYTEST = "pytest"
+    UNITTEST = "unittest"
+    VITEST = "vitest"
+    PLAYWRIGHT = "playwright"
+    CARGO = "cargo"
+    GO = "go"
+    JEST = "jest"
+    MAVEN_SUREFIRE = "maven-surefire"
+    GRADLE_TEST = "gradle-test"
+    DOTNET_TEST = "dotnet-test"
+    RSPEC = "rspec"
+    MINITEST = "minitest"
+
+
+@dataclass(frozen=True)
+class TestRunSignal:
+    """Detected test-runner family and outcome."""
+
+    framework: TestFramework
+    failed: bool
+
+
+def detect_test_run(lines: list[str]) -> TestRunSignal | None:
+    """Return a strong test-runner signal, or ``None`` for uncertain text."""
+
+    framework = _detect_framework(lines)
+    if framework is None:
+        return None
+    return TestRunSignal(framework=framework, failed=_has_failure(lines, framework))
+
+
+def _detect_framework(lines: list[str]) -> TestFramework | None:
+    text = "\n".join(lines)
+    stripped = [line.strip() for line in lines]
+
+    if _has_pytest_shape(text, stripped):
+        return TestFramework.PYTEST
+
+    if _has_unittest_shape(stripped):
+        return TestFramework.UNITTEST
+
+    if any(line.lstrip().startswith("RUN ") for line in lines) and any(
+        line.startswith(("Test Files", "Tests", "FAIL ")) for line in stripped
+    ):
+        return TestFramework.VITEST
+
+    if _has_playwright_shape(stripped):
+        return TestFramework.PLAYWRIGHT
+
+    if any(_is_cargo_running_line(line) for line in stripped) and any(
+        line.startswith("test result:") for line in stripped
+    ):
+        return TestFramework.CARGO
+
+    if _has_go_test_shape(stripped):
+        return TestFramework.GO
+
+    if _has_jest_shape(stripped):
+        return TestFramework.JEST
+
+    if _has_maven_surefire_shape(stripped):
+        return TestFramework.MAVEN_SUREFIRE
+
+    if _has_gradle_test_shape(stripped):
+        return TestFramework.GRADLE_TEST
+
+    if _has_dotnet_test_shape(stripped):
+        return TestFramework.DOTNET_TEST
+
+    if _has_rspec_shape(stripped):
+        return TestFramework.RSPEC
+
+    if _has_minitest_shape(stripped):
+        return TestFramework.MINITEST
+
+    return None
+
+
+def _has_failure(lines: list[str], framework: TestFramework) -> bool:
+    if any(_line_has_failure(line) for line in lines):
+        return True
+    if framework is TestFramework.PYTEST:
+        return _has_pytest_error(lines)
+    if framework is TestFramework.PLAYWRIGHT:
+        return _has_playwright_failure(lines)
+    if framework in {
+        TestFramework.GO,
+        TestFramework.JEST,
+        TestFramework.MAVEN_SUREFIRE,
+        TestFramework.GRADLE_TEST,
+        TestFramework.DOTNET_TEST,
+        TestFramework.RSPEC,
+        TestFramework.MINITEST,
+    }:
+        return _has_extended_failure(lines)
+    return False
+
+
+def _has_pytest_error(lines: list[str]) -> bool:
+    return any(_NONZERO_PYTEST_ERROR_RE.search(line.strip()) is not None for line in lines)
+
+
+def _has_pytest_shape(text: str, lines: list[str]) -> bool:
+    if "test session starts" in text and any(
+        line.startswith("collected ") or _is_pytest_terminal_summary(line)
+        for line in lines
+    ):
+        return True
+    return _has_pytest_quiet_shape(lines)
+
+
+def _has_pytest_quiet_shape(lines: list[str]) -> bool:
+    return any(_is_pytest_progress_line(line) for line in lines) and any(
+        _is_pytest_quiet_summary(line)
+        or line.startswith(("FAILED ", "ERROR "))
+        or "short test summary info" in line.lower()
+        for line in lines
+    )
+
+
+def _line_has_failure(line: str) -> bool:
+    stripped = line.strip()
+    return (
+        stripped.startswith(("FAILED ", "FAILED (", "FAIL ", "FAIL:", "ERROR:", "failures:"))
+        or stripped.startswith("test result: FAILED")
+        or " FAILURES " in stripped
+        or _is_unittest_verbose_failure_line(stripped)
+        or _NONZERO_FAILED_RE.search(stripped) is not None
+    )
+
+
+def _is_pytest_terminal_summary(line: str) -> bool:
+    return bool(
+        line.startswith("=")
+        and " in " in line
+        and any(
+            token in line
+            for token in (" passed", " failed", " error", " skipped", " xfailed", " xpassed")
+        )
+    )
+
+
+def _is_pytest_quiet_summary(line: str) -> bool:
+    return _PYTEST_QUIET_SUMMARY_RE.match(line) is not None
+
+
+def _is_pytest_progress_line(line: str) -> bool:
+    return _PYTEST_PROGRESS_RE.match(line) is not None
+
+
+def _is_cargo_running_line(line: str) -> bool:
+    match = re.match(r"^running (\d+) tests?$", line)
+    return match is not None
+
+
+def _has_unittest_shape(lines: list[str]) -> bool:
+    return (
+        any(_is_unittest_ran_line(line) for line in lines)
+        and any(_is_unittest_terminal_outcome_line(line) for line in lines)
+        and any(_is_unittest_shape_marker(line) for line in lines)
+    )
+
+
+def _has_playwright_shape(lines: list[str]) -> bool:
+    return any(_is_playwright_run_line(line) for line in lines) and any(
+        _is_playwright_summary_line(line) for line in lines
+    )
+
+
+def _has_playwright_failure(lines: list[str]) -> bool:
+    return any(_is_playwright_failure_line(line.strip()) for line in lines)
+
+
+def _has_extended_failure(lines: list[str]) -> bool:
+    return any(_is_extended_failure_line(line.strip()) for line in lines)
+
+
+def _is_playwright_run_line(line: str) -> bool:
+    return _PLAYWRIGHT_RUN_RE.match(line) is not None
+
+
+def _is_playwright_summary_line(line: str) -> bool:
+    return _PLAYWRIGHT_SUMMARY_RE.match(line) is not None
+
+
+def _is_playwright_failure_line(line: str) -> bool:
+    return bool(
+        _PLAYWRIGHT_NONZERO_FAILURE_RE.match(line)
+        or _PLAYWRIGHT_NUMBERED_FAILURE_RE.match(line)
+        or ((line.startswith("✘") or line.startswith("×")) and "›" in line)
+        or line.startswith(("Test timeout", "TimeoutError:"))
+    )
+
+
+def _has_go_test_shape(lines: list[str]) -> bool:
+    has_run = any(_GO_RUN_RE.match(line) is not None for line in lines)
+    has_test_result = any(_GO_TEST_RESULT_RE.match(line) is not None for line in lines)
+    has_package_result = any(_looks_like_go_package_result(line) for line in lines)
+    return (has_run and has_test_result) or has_package_result
+
+
+def _looks_like_go_package_result(line: str) -> bool:
+    match = _GO_PACKAGE_RESULT_RE.match(line)
+    if match is None:
+        return False
+    parts = line.split()
+    if len(parts) < 2:
+        return False
+    package = parts[1]
+    return "/" in package or "." in package or package.startswith(("./", "../"))
+
+
+def _has_jest_shape(lines: list[str]) -> bool:
+    has_suite = any(line.startswith(("PASS ", "FAIL ")) for line in lines)
+    has_summary = any(
+        line.startswith(("Test Suites:", "Tests:", "Snapshots:", "Time:"))
+        for line in lines
+    )
+    return has_suite and has_summary
+
+
+def _has_maven_surefire_shape(lines: list[str]) -> bool:
+    has_surefire = any(
+        "surefire" in line.lower()
+        or "maven-surefire-plugin" in line.lower()
+        or line.startswith("Tests run:")
+        or _MAVEN_SUREFIRE_SUMMARY_RE.match(line) is not None
+        for line in lines
+    )
+    has_summary = any(_MAVEN_SUREFIRE_SUMMARY_RE.match(line) is not None for line in lines)
+    return has_surefire and has_summary
+
+
+def _has_gradle_test_shape(lines: list[str]) -> bool:
+    has_gradle = any(
+        line.startswith(("> Task ", "Gradle Test Executor", "Test worker"))
+        or "test report" in line.lower()
+        for line in lines
+    )
+    has_summary = any(_GRADLE_TEST_SUMMARY_RE.match(line) is not None for line in lines)
+    return has_gradle and has_summary
+
+
+def _has_dotnet_test_shape(lines: list[str]) -> bool:
+    has_vstest = any(
+        line.startswith(("Test run for ", "Starting test execution"))
+        or "vstest" in line.lower()
+        for line in lines
+    )
+    has_summary = any(
+        line.startswith(("Passed!", "Failed!", "Total tests:"))
+        or _DOTNET_TEST_SUMMARY_RE.match(line) is not None
+        for line in lines
+    )
+    return has_vstest and has_summary
+
+
+def _has_rspec_shape(lines: list[str]) -> bool:
+    has_summary = any(_RSPEC_SUMMARY_RE.match(line) is not None for line in lines)
+    has_marker = any(
+        line.startswith(("Failures:", "Pending:", "Finished in "))
+        or _RSPEC_FAILURE_NUMBER_RE.match(line) is not None
+        for line in lines
+    )
+    return has_summary and has_marker
+
+
+def _has_minitest_shape(lines: list[str]) -> bool:
+    has_run_marker = any(line.startswith("Run options:") for line in lines)
+    has_summary = any(_MINITEST_SUMMARY_RE.match(line) is not None for line in lines)
+    has_progress = any(_MINITEST_PROGRESS_RE.match(line) is not None for line in lines)
+    return has_summary and (has_run_marker or has_progress)
+
+
+def _is_extended_failure_line(line: str) -> bool:
+    return (
+        line.startswith(
+            (
+                "--- FAIL:",
+                "FAIL",
+                "FAIL ",
+                "Failed!",
+                "Failed tests:",
+                "Failures:",
+                "Test Failed.",
+                "[ERROR]",
+            )
+        )
+        or " FAILED" in line
+        or " failed" in line
+        or "Failures: " in line
+        or "Errors: " in line
+        or _GO_PACKAGE_FAIL_RE.match(line) is not None
+        or _MAVEN_SUREFIRE_NONZERO_RE.search(line) is not None
+        or _DOTNET_FAILED_SUMMARY_RE.search(line) is not None
+        or _RSPEC_NONZERO_FAILURE_RE.match(line) is not None
+        or _MINITEST_NONZERO_FAILURE_RE.search(line) is not None
+    )
+
+
+def _is_unittest_shape_marker(line: str) -> bool:
+    return (
+        _is_unittest_separator(line)
+        or _is_unittest_progress_line(line)
+        or _is_unittest_verbose_result_line(line)
+        or line.startswith(("FAIL:", "ERROR:"))
+    )
+
+
+def _is_unittest_ran_line(line: str) -> bool:
+    return _UNITTEST_RAN_RE.match(line) is not None
+
+
+def _is_unittest_terminal_outcome_line(line: str) -> bool:
+    return line == "OK" or line.startswith(("OK (", "FAILED ("))
+
+
+def _is_unittest_separator(line: str) -> bool:
+    return len(line) >= 5 and set(line) == {"-"}
+
+
+def _is_unittest_progress_line(line: str) -> bool:
+    return len(line) >= 3 and all(char in _UNITTEST_PROGRESS_CHARS for char in line)
+
+
+def _is_unittest_verbose_result_line(line: str) -> bool:
+    return _UNITTEST_VERBOSE_RESULT_RE.match(line) is not None
+
+
+def _is_unittest_verbose_failure_line(line: str) -> bool:
+    return bool(
+        _UNITTEST_VERBOSE_RESULT_RE.match(line)
+        and any(line.endswith(f" ... {result}") for result in ("FAIL", "ERROR"))
+    )
+
+
+_NONZERO_FAILED_RE = re.compile(r"\b[1-9]\d* failed\b")
+_NONZERO_PYTEST_ERROR_RE = re.compile(r"\b[1-9]\d* errors?\b")
+_PYTEST_PROGRESS_RE = re.compile(r"^[.FEfsxX]+(?:\s+\[\s*\d+%\])?$")
+_PYTEST_QUIET_SUMMARY_RE = re.compile(
+    r"^(?:\d+ (?:passed|failed|errors?|skipped|xfailed|xpassed|warnings?)"
+    r"(?:, \d+ (?:passed|failed|errors?|skipped|xfailed|xpassed|warnings?))*"
+    r"|no tests ran) in [0-9.]+s$"
+)
+_UNITTEST_RAN_RE = re.compile(r"^Ran \d+ tests? in [0-9.]+s$")
+_UNITTEST_VERBOSE_RESULT_RE = re.compile(
+    r"^[A-Za-z_][\w.<>-]*\s+\(.+\)\s+\.\.\.\s+"
+    r"(?:ok|FAIL|ERROR|skipped|expected failure|unexpected success)(?:\s+.*)?$"
+)
+_UNITTEST_PROGRESS_CHARS = frozenset(".FEsxXuUS")
+_PLAYWRIGHT_RUN_RE = re.compile(r"^Running \d+ tests? using \d+ workers?$")
+_PLAYWRIGHT_SUMMARY_RE = re.compile(
+    r"^\d+ (?:passed|failed|flaky|skipped|timed out|did not run|interrupted)"
+    r"(?: \([^)]*\))?$"
+)
+_PLAYWRIGHT_NONZERO_FAILURE_RE = re.compile(
+    r"^[1-9]\d* (?:failed|timed out|interrupted)(?: \([^)]*\))?$"
+)
+_PLAYWRIGHT_NUMBERED_FAILURE_RE = re.compile(r"^\d+\) .+›")
+_GO_RUN_RE = re.compile(r"^=== RUN\s+\S+")
+_GO_TEST_RESULT_RE = re.compile(r"^--- (?:PASS|FAIL|SKIP):\s+\S+\s+\([0-9.]+s\)$")
+_GO_PACKAGE_RESULT_RE = re.compile(
+    r"^(?:ok|FAIL|\?)\s+\S+(?:\s+[0-9.]+s|\s+\[no test files\])$"
+)
+_GO_PACKAGE_FAIL_RE = re.compile(r"^FAIL\s+\S+(?:\s+[0-9.]+s)?$")
+_MAVEN_SUREFIRE_SUMMARY_RE = re.compile(
+    r"^(?:\[ERROR\]\s+)?Tests run:\s+\d+,\s+Failures:\s+\d+,\s+Errors:\s+\d+,\s+Skipped:\s+\d+",
+    re.IGNORECASE,
+)
+_MAVEN_SUREFIRE_NONZERO_RE = re.compile(
+    r"(?:Failures|Errors):\s*[1-9]\d*",
+    re.IGNORECASE,
+)
+_GRADLE_TEST_SUMMARY_RE = re.compile(
+    r"^\d+\s+tests? completed(?:,\s+\d+\s+failed)?(?:,\s+\d+\s+skipped)?$",
+    re.IGNORECASE,
+)
+_DOTNET_TEST_SUMMARY_RE = re.compile(
+    r"^(?:Passed|Failed|Skipped):\s+\d+",
+    re.IGNORECASE,
+)
+_DOTNET_FAILED_SUMMARY_RE = re.compile(r"Failed:\s*[1-9]\d*", re.IGNORECASE)
+_RSPEC_SUMMARY_RE = re.compile(
+    r"^\d+\s+examples?,\s+\d+\s+failures?(?:,\s+\d+\s+pending)?$",
+    re.IGNORECASE,
+)
+_RSPEC_FAILURE_NUMBER_RE = re.compile(r"^\d+\)\s+")
+_RSPEC_NONZERO_FAILURE_RE = re.compile(r"^\d+\s+examples?,\s+[1-9]\d*\s+failures?", re.I)
+_MINITEST_SUMMARY_RE = re.compile(
+    r"^\d+\s+runs?,\s+\d+\s+assertions?,\s+\d+\s+failures?,\s+\d+\s+errors?",
+    re.IGNORECASE,
+)
+_MINITEST_PROGRESS_RE = re.compile(r"^[.FESE]+$")
+_MINITEST_NONZERO_FAILURE_RE = re.compile(
+    r"[1-9]\d*\s+(?:failures?|errors?)",
+    re.IGNORECASE,
+)

codetool_shell/filters/test_runner/reducer.py

@@ -0,0 +1,288 @@
+"""Conservative reducers for supported test-runner output."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from ..text import join_preserving_final_newline, score, split_preserving_final_newline
+from .ansi import strip_ansi_control_sequences
+from .detector import TestFramework, TestRunSignal, detect_test_run
+from .summary import (
+    collapse_unittest_progress_line,
+    extract_playwright_project,
+    is_failure_detail_line,
+    is_jest_source_context_line,
+    is_playwright_attention_line,
+    is_playwright_run_line,
+    is_run_marker_line,
+    is_summary_line,
+    is_unittest_progress_line,
+    normalize_selected_line,
+)
+
+
+def compress_test_runner_output(text: str) -> str:
+    """Compress clear test-runner output while preserving diagnostics."""
+
+    sanitized = strip_ansi_control_sequences(text)
+    lines, final_newline = split_preserving_final_newline(sanitized)
+    go_jsonl_candidate = _reduce_go_jsonl_lines(lines)
+    if go_jsonl_candidate is not None:
+        candidate = join_preserving_final_newline(go_jsonl_candidate, final_newline)
+        if score(candidate) < score(text):
+            return candidate
+
+    signal = detect_test_run(lines)
+    if signal is None:
+        return text
+
+    candidate_lines = _reduce_lines(lines, signal)
+    if len(candidate_lines) < 2:
+        return text
+
+    candidate = join_preserving_final_newline(candidate_lines, final_newline)
+    if score(candidate) < score(text):
+        return candidate
+    return text
+
+
+def _reduce_lines(lines: list[str], signal: TestRunSignal) -> list[str]:
+    if signal.framework is TestFramework.PLAYWRIGHT:
+        return _reduce_playwright_lines(lines, signal)
+
+    outcome = "failure" if signal.failed else "success"
+    selected = [f"test output: {signal.framework.value} {outcome}"]
+
+    for line in lines:
+        if (
+            signal.framework is TestFramework.UNITTEST
+            and not signal.failed
+            and is_unittest_progress_line(line)
+        ):
+            selected.append(collapse_unittest_progress_line(line))
+            continue
+
+        if signal.failed:
+            keep = is_summary_line(line) or is_failure_detail_line(line)
+            if signal.framework is TestFramework.JEST and is_jest_source_context_line(line):
+                keep = True
+        else:
+            keep = is_summary_line(line) or is_run_marker_line(line)
+        if keep:
+            selected.append(normalize_selected_line(line))
+
+    return _drop_blank_and_adjacent_duplicates(selected)
+
+
+def _reduce_playwright_lines(lines: list[str], signal: TestRunSignal) -> list[str]:
+    outcome = "failure" if signal.failed else "success"
+    selected = [f"test output: {signal.framework.value} {outcome}"]
+    projects = _playwright_projects(lines)
+    projects_added = False
+
+    for line in lines:
+        keep = False
+        if is_summary_line(line):
+            keep = True
+        elif signal.failed:
+            keep = is_failure_detail_line(line)
+        else:
+            keep = is_playwright_attention_line(line)
+
+        if not keep:
+            continue
+
+        selected.append(normalize_selected_line(line))
+        if (
+            not projects_added
+            and projects
+            and is_playwright_run_line(line)
+        ):
+            selected.append(f"projects: {', '.join(projects)}")
+            projects_added = True
+
+    return _drop_blank_and_adjacent_duplicates(selected)
+
+
+def _reduce_go_jsonl_lines(lines: list[str]) -> list[str] | None:
+    records = _parse_go_jsonl_records(lines)
+    if records is None:
+        return None
+
+    failed = any(record.get("Action") == "fail" for record in records)
+    failed_tests = _go_jsonl_tests_by_action(records, "fail")
+    skipped_tests = _go_jsonl_tests_by_action(records, "skip")
+    selected = [f"test output: go {'failure' if failed else 'success'}"]
+
+    for record in records:
+        action = record.get("Action")
+        package = _string_field(record, "Package")
+        test = _string_field(record, "Test")
+
+        if action == "output":
+            output = _string_field(record, "Output")
+            if output is None:
+                continue
+            detail = output.rstrip("\n").strip()
+            if not detail:
+                continue
+            key = (package or "", test or "")
+            if (
+                key in failed_tests
+                and _is_go_jsonl_relevant_output(detail, failed=True)
+            ) or (
+                key in skipped_tests
+                and _is_go_jsonl_relevant_output(detail, failed=False)
+            ) or _is_go_jsonl_global_output(detail):
+                selected.append(detail)
+            continue
+
+        if action in {"fail", "skip"} and test is not None:
+            selected.append(_format_go_jsonl_test_event(action, package, test, record))
+            continue
+
+        if action in {"pass", "fail", "skip"} and package is not None and test is None:
+            selected.append(_format_go_jsonl_package_event(action, package, record))
+
+    return _drop_blank_and_adjacent_duplicates(selected)
+
+
+def _parse_go_jsonl_records(lines: list[str]) -> list[dict[str, Any]] | None:
+    records: list[dict[str, Any]] = []
+    for line in lines:
+        stripped = line.strip()
+        if not stripped:
+            continue
+        try:
+            parsed = json.loads(stripped)
+        except json.JSONDecodeError:
+            return None
+        if not isinstance(parsed, dict):
+            return None
+        action = parsed.get("Action")
+        if action not in _GO_JSONL_ACTIONS:
+            return None
+        if not isinstance(parsed.get("Package"), str) and not isinstance(
+            parsed.get("Test"), str
+        ):
+            return None
+        records.append(parsed)
+
+    if len(records) < 3 or not _has_go_jsonl_test_signal(records):
+        return None
+    return records
+
+
+def _has_go_jsonl_test_signal(records: list[dict[str, Any]]) -> bool:
+    has_terminal = any(record.get("Action") in {"pass", "fail", "skip"} for record in records)
+    has_output_marker = any(
+        record.get("Action") == "output"
+        and isinstance(record.get("Output"), str)
+        and record["Output"].strip().startswith(("=== RUN", "--- PASS:", "--- FAIL:", "--- SKIP:"))
+        for record in records
+    )
+    has_go_test_name = any(
+        isinstance(record.get("Test"), str)
+        and record["Test"].startswith(("Test", "Benchmark", "Example"))
+        for record in records
+    )
+    has_go_package = any(
+        isinstance(record.get("Package"), str)
+        and ("/" in record["Package"] or "." in record["Package"])
+        for record in records
+    )
+    return has_terminal and has_output_marker and (has_go_test_name or has_go_package)
+
+
+def _go_jsonl_tests_by_action(
+    records: list[dict[str, Any]], action: str
+) -> set[tuple[str, str]]:
+    tests: set[tuple[str, str]] = set()
+    for record in records:
+        package = _string_field(record, "Package")
+        test = _string_field(record, "Test")
+        if record.get("Action") == action and test is not None:
+            tests.add((package or "", test))
+    return tests
+
+
+def _format_go_jsonl_test_event(
+    action: Any, package: str | None, test: str, record: dict[str, Any]
+) -> str:
+    label = "FAIL" if action == "fail" else "SKIP"
+    package_prefix = f"{package} " if package else ""
+    elapsed = _format_go_jsonl_elapsed(record)
+    return f"{label} {package_prefix}{test}{elapsed}"
+
+
+def _format_go_jsonl_package_event(
+    action: Any, package: str, record: dict[str, Any]
+) -> str:
+    label = {"pass": "ok", "fail": "FAIL", "skip": "SKIP"}[action]
+    return f"{label} {package}{_format_go_jsonl_elapsed(record)}"
+
+
+def _format_go_jsonl_elapsed(record: dict[str, Any]) -> str:
+    elapsed = record.get("Elapsed")
+    if isinstance(elapsed, (int, float)):
+        return f" ({elapsed:g}s)"
+    return ""
+
+
+def _is_go_jsonl_relevant_output(detail: str, *, failed: bool) -> bool:
+    if detail.startswith(("=== RUN", "=== PAUSE", "=== CONT", "--- PASS:")):
+        return False
+    if detail.startswith(("--- FAIL:", "--- SKIP:", "FAIL", "panic:", "fatal error:")):
+        return True
+    if detail.startswith(
+        (
+            "Error Trace:",
+            "Error:",
+            "Messages:",
+            "Expected:",
+            "Actual:",
+            "Received:",
+            "Not equal:",
+        )
+    ):
+        return True
+    if ".go:" in detail:
+        return True
+    if not failed:
+        return "skip" in detail.lower()
+    return len(detail) <= 240
+
+
+def _is_go_jsonl_global_output(detail: str) -> bool:
+    return detail == "FAIL" or detail.startswith(("FAIL\t", "ok  \t", "?   \t"))
+
+
+def _string_field(record: dict[str, Any], field: str) -> str | None:
+    value = record.get(field)
+    return value if isinstance(value, str) else None
+
+
+def _playwright_projects(lines: list[str]) -> list[str]:
+    projects: list[str] = []
+    for line in lines:
+        project = extract_playwright_project(line)
+        if project is not None and project not in projects:
+            projects.append(project)
+    return projects
+
+
+def _drop_blank_and_adjacent_duplicates(lines: list[str]) -> list[str]:
+    output: list[str] = []
+    for line in lines:
+        if not line:
+            continue
+        if output and output[-1] == line:
+            continue
+        output.append(line)
+    return output
+
+
+_GO_JSONL_ACTIONS = frozenset(
+    {"start", "run", "pause", "cont", "pass", "bench", "fail", "output", "skip"}
+)