codetool-shell 0.1.1__py3-none-win_amd64.whl

codetool_shell/filters/test_runner/summary.py

@@ -0,0 +1,449 @@
+"""Line classification for test-runner summaries and diagnostics."""
+
+from __future__ import annotations
+
+import re
+
+
+def is_summary_line(line: str) -> bool:
+    """Return true for compact test-runner summary/timing lines."""
+
+    stripped = line.strip()
+    return (
+        _is_pytest_terminal_summary(stripped)
+        or _is_pytest_quiet_summary(stripped)
+        or stripped.startswith("collected ")
+        or _is_cargo_running_line(stripped)
+        or _is_go_summary_line(stripped)
+        or _is_unittest_ran_line(stripped)
+        or _is_unittest_terminal_outcome_line(stripped)
+        or is_playwright_run_line(stripped)
+        or is_playwright_summary_line(stripped)
+        or _is_jest_summary_line(stripped)
+        or _is_maven_surefire_summary_line(stripped)
+        or _is_gradle_test_summary_line(stripped)
+        or _is_dotnet_test_summary_line(stripped)
+        or _is_rspec_summary_line(stripped)
+        or _is_minitest_summary_line(stripped)
+        or stripped.startswith(("Test Files", "Tests", "Duration", "Start at"))
+        or stripped.startswith("test result:")
+    )
+
+
+def is_run_marker_line(line: str) -> bool:
+    """Return true for a concise framework run marker."""
+
+    stripped = line.lstrip()
+    return stripped.startswith("RUN ") or stripped.startswith("=== RUN ")
+
+
+def is_failure_detail_line(line: str) -> bool:
+    """Return true for failure identifiers, assertions, and source locations."""
+
+    stripped = line.strip()
+    pytest_heading = stripped.strip("_").strip()
+    location = stripped.removeprefix("❯").strip()
+    if _is_playwright_progress_line(stripped):
+        return False
+    return (
+        stripped.startswith(
+            (
+                "FAILED ",
+                "FAIL ",
+                "FAIL:",
+                "FAIL",
+                "ERROR ",
+                "ERROR:",
+                "AssertionError",
+                "Error:",
+                "ImportError",
+                "Traceback",
+                "thread '",
+                "failures:",
+                "--- FAIL:",
+                "--- SKIP:",
+                "Failed!",
+                "Failed tests:",
+                "Failures:",
+                "Pending:",
+                "Test Failed.",
+                "Expected:",
+                "Received:",
+                "Actual:",
+                "Failure/Error:",
+                "Message:",
+                "Messages:",
+                "Stacktrace:",
+                "[ERROR]",
+            )
+        )
+        or " FAILED" in stripped
+        or pytest_heading.startswith("ERROR ")
+        or _is_unittest_verbose_failure_line(stripped)
+        or _is_python_frame_line(stripped)
+        or _is_python_exception_line(stripped)
+        or _is_java_exception_line(stripped)
+        or _is_dotnet_failure_line(stripped)
+        or _is_rspec_failure_line(stripped)
+        or _is_minitest_failure_line(stripped)
+        or "test report" in stripped.lower()
+        or "report at:" in stripped.lower()
+        or _is_assert_or_raise_source_line(stripped)
+        or _is_playwright_failure_detail_line(stripped)
+        or _looks_like_path_location(location)
+        or line.startswith(("E       ", "E   ", ">       ", "  left:", " right:"))
+        or stripped.startswith(("left:", "right:"))
+        or (stripped.startswith("test ") and " ... FAILED" in stripped)
+    )
+
+
+def normalize_selected_line(line: str) -> str:
+    """Normalize selected lines for compact output."""
+
+    stripped = line.strip()
+    if _is_playwright_decorated_line(stripped):
+        return stripped.rstrip("─").rstrip()
+    return stripped
+
+
+def is_unittest_progress_line(line: str) -> bool:
+    """Return true for compact unittest progress-marker lines."""
+
+    stripped = line.strip()
+    return len(stripped) >= 20 and all(
+        char in _UNITTEST_PROGRESS_CHARS for char in stripped
+    )
+
+
+def collapse_unittest_progress_line(line: str) -> str:
+    """Summarize a long unittest progress-marker line."""
+
+    stripped = line.strip()
+    counts = [
+        _count_part(stripped.count("."), "passed"),
+        _count_part(stripped.count("s") + stripped.count("S"), "skipped"),
+        _count_part(
+            stripped.count("x") + stripped.count("X"),
+            "expected failures",
+        ),
+        _count_part(stripped.count("u") + stripped.count("U"), "unexpected successes"),
+        _count_part(stripped.count("F"), "failed"),
+        _count_part(stripped.count("E"), "errors"),
+    ]
+    details = ", ".join(part for part in counts if part)
+    if not details:
+        details = "markers only"
+    return f"progress: {len(stripped)} unittest markers ({details})"
+
+
+def is_playwright_run_line(line: str) -> bool:
+    """Return true for the Playwright run-count marker."""
+
+    return _PLAYWRIGHT_RUN_RE.match(line.strip()) is not None
+
+
+def is_playwright_summary_line(line: str) -> bool:
+    """Return true for strict Playwright final total lines."""
+
+    return _PLAYWRIGHT_SUMMARY_RE.match(line.strip()) is not None
+
+
+def extract_playwright_project(line: str) -> str | None:
+    """Return a visible Playwright project name from a spec line."""
+
+    match = _PLAYWRIGHT_PROJECT_RE.search(line)
+    if match is None:
+        return None
+    project = match.group(1).strip()
+    return project or None
+
+
+def is_playwright_attention_line(line: str) -> bool:
+    """Return true for non-failing Playwright retry/flaky identifiers."""
+
+    stripped = line.strip()
+    return "retry #" in stripped.lower() or _is_playwright_final_spec_line(stripped)
+
+
+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_cargo_running_line(line: str) -> bool:
+    return re.match(r"^running \d+ tests?$", line) is not None
+
+
+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_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"))
+    )
+
+
+def _is_python_frame_line(line: str) -> bool:
+    return line.startswith('File "') and '", line ' in line
+
+
+def _is_python_exception_line(line: str) -> bool:
+    match = _PYTHON_EXCEPTION_RE.match(line)
+    if match is None:
+        return False
+    exception_name = match.group(1)
+    return exception_name.endswith(("Error", "Exception", "Warning"))
+
+
+def _is_java_exception_line(line: str) -> bool:
+    return bool(_JAVA_EXCEPTION_RE.match(line) or line.startswith("Caused by: "))
+
+
+def _is_dotnet_failure_line(line: str) -> bool:
+    return (
+        line.startswith(("Failed ", "Error Message:", "Stack Trace:", "at "))
+        or _DOTNET_FAILED_TEST_RE.match(line) is not None
+    )
+
+
+def _is_rspec_failure_line(line: str) -> bool:
+    return (
+        _RSPEC_FAILURE_NUMBER_RE.match(line) is not None
+        or line.startswith(("# ./", "# /", "rspec "))
+        or line.startswith(("Failure/Error:", "expected", "got:"))
+    )
+
+
+def is_jest_source_context_line(line: str) -> bool:
+    return _JEST_SOURCE_CONTEXT_RE.match(line.strip()) is not None
+
+
+def _is_minitest_failure_line(line: str) -> bool:
+    return (
+        _MINITEST_FAILURE_HEADER_RE.match(line) is not None
+        or ("[" in line and ".rb:" in line and line.endswith("]:"))
+        or line.startswith(("Expected", "Actual", "Failure:", "Error:"))
+    )
+
+
+def _is_assert_or_raise_source_line(line: str) -> bool:
+    return line.startswith(("assert ", "self.assert", "raise "))
+
+
+def _is_playwright_failure_detail_line(line: str) -> bool:
+    return (
+        _PLAYWRIGHT_NUMBERED_FAILURE_RE.match(line) is not None
+        or _is_playwright_final_spec_line(line)
+        or line.startswith(
+            (
+                "Test timeout",
+                "TimeoutError:",
+                "Locator:",
+                "Expected:",
+                "Received:",
+                "Timeout:",
+                "Call log:",
+                "attachment #",
+                "Error Context:",
+                "Usage:",
+                "npx playwright show-trace",
+                "locator.",
+                "page.",
+                "expect.",
+            )
+        )
+        or _is_playwright_action_line(line)
+        or _is_playwright_source_focus_line(line)
+        or _looks_like_artifact_path(line)
+    )
+
+
+def _is_playwright_decorated_line(line: str) -> bool:
+    return "─" in line and (
+        _PLAYWRIGHT_NUMBERED_FAILURE_RE.match(line) is not None
+        or line.startswith("attachment #")
+    )
+
+
+def _is_playwright_final_spec_line(line: str) -> bool:
+    return line.startswith("[") and "] ›" in line
+
+
+def _is_playwright_progress_line(line: str) -> bool:
+    return line.startswith(("✓", "✘", "×", "-")) and "] ›" in line
+
+
+def _is_playwright_action_line(line: str) -> bool:
+    return line.startswith("- ") and any(
+        token in line
+        for token in (
+            "expect",
+            "waiting for",
+            "locator",
+            "page.",
+            "click",
+            "fill",
+            "press",
+            "goto",
+        )
+    )
+
+
+def _is_playwright_source_focus_line(line: str) -> bool:
+    return line.startswith(">") and "|" in line
+
+
+def _looks_like_artifact_path(line: str) -> bool:
+    return (
+        "/" in line
+        and not line.startswith("- ")
+        and not line.startswith(("http://", "https://"))
+        and line.endswith((".png", ".jpg", ".jpeg", ".webm", ".zip", ".html"))
+        and (
+            "test-results/" in line
+            or "playwright-report/" in line
+            or "blob-report/" in line
+            or "trace" in line
+            or "screenshot" in line
+            or "video" in line
+        )
+    )
+
+
+def _count_part(count: int, label: str) -> str:
+    if count == 0:
+        return ""
+    return f"{count} {label}"
+
+
+def _looks_like_path_location(line: str) -> bool:
+    parts = line.split(":")
+    if len(parts) < 2:
+        return False
+    for index in range(1, len(parts)):
+        if parts[index].isdigit():
+            path = ":".join(parts[:index])
+            return bool(path) and _looks_like_path(path)
+    return False
+
+
+def _looks_like_path(path: str) -> bool:
+    if not path or path[0].isspace() or "://" in path:
+        return False
+    return "/" in path or "\\" in path or "." in path
+
+
+def _is_go_summary_line(line: str) -> bool:
+    return (
+        _GO_TEST_RESULT_RE.match(line) is not None
+        or _GO_PACKAGE_RESULT_RE.match(line) is not None
+        or line in {"PASS", "FAIL"}
+    )
+
+
+def _is_jest_summary_line(line: str) -> bool:
+    return (
+        line.startswith(("PASS ", "FAIL ", "Test Suites:", "Tests:", "Snapshots:", "Time:"))
+        or _JEST_FAILED_TEST_RE.match(line) is not None
+    )
+
+
+def _is_maven_surefire_summary_line(line: str) -> bool:
+    return (
+        _MAVEN_SUREFIRE_SUMMARY_RE.match(line) is not None
+        or line.startswith("Results:")
+        or "surefire-reports" in line
+    )
+
+
+def _is_gradle_test_summary_line(line: str) -> bool:
+    return (
+        _GRADLE_TEST_SUMMARY_RE.match(line) is not None
+        or (line.startswith("> Task ") and "FAILED" in line)
+        or "test report" in line.lower()
+    )
+
+
+def _is_dotnet_test_summary_line(line: str) -> bool:
+    return (
+        line.startswith(("Passed!", "Failed!", "Total tests:", "Test Run "))
+        or _DOTNET_TEST_COUNT_RE.match(line) is not None
+    )
+
+
+def _is_rspec_summary_line(line: str) -> bool:
+    return (
+        _RSPEC_SUMMARY_RE.match(line) is not None
+        or line.startswith(("Finished in ", "Failures:", "Pending:"))
+    )
+
+
+def _is_minitest_summary_line(line: str) -> bool:
+    return _MINITEST_SUMMARY_RE.match(line) is not None
+
+
+_UNITTEST_RAN_RE = re.compile(r"^Ran \d+ tests? in [0-9.]+s$")
+_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_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")
+_PYTHON_EXCEPTION_RE = re.compile(r"^((?:[A-Za-z_]\w*\.)*[A-Za-z_]\w*):")
+_JAVA_EXCEPTION_RE = re.compile(r"^(?:[A-Za-z_$][\w$]*\.)+[A-Za-z_$][\w$]*(?:Exception|Error):")
+_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_PROJECT_RE = re.compile(r"\[([^\]]+)\]\s+›")
+_PLAYWRIGHT_NUMBERED_FAILURE_RE = re.compile(r"^\d+\) .+›")
+_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\])$"
+)
+_JEST_FAILED_TEST_RE = re.compile(r"^[✕●]\s+")
+_JEST_SOURCE_CONTEXT_RE = re.compile(r"^(?:>?\s*)?\d+\s+\|.*|^\|\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,
+)
+_GRADLE_TEST_SUMMARY_RE = re.compile(
+    r"^\d+\s+tests? completed(?:,\s+\d+\s+failed)?(?:,\s+\d+\s+skipped)?$",
+    re.IGNORECASE,
+)
+_DOTNET_TEST_COUNT_RE = re.compile(
+    r"^(?:Passed|Failed|Skipped):\s+\d+",
+    re.IGNORECASE,
+)
+_DOTNET_FAILED_TEST_RE = re.compile(r"^Failed\s+\S")
+_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+")
+_MINITEST_SUMMARY_RE = re.compile(
+    r"^\d+\s+runs?,\s+\d+\s+assertions?,\s+\d+\s+failures?,\s+\d+\s+errors?",
+    re.IGNORECASE,
+)
+_MINITEST_FAILURE_HEADER_RE = re.compile(r"^\d+\)\s+(?:Failure|Error):")

codetool_shell/filters/text.py

@@ -0,0 +1,38 @@
+"""Small text helpers shared by output filters."""
+
+from __future__ import annotations
+
+
+def score(text: str) -> tuple[int, int]:
+    """Return a cheap size proxy used to keep only smaller filter output."""
+
+    return (len(text.encode("utf-8")), len(text))
+
+
+def split_preserving_final_newline(text: str) -> tuple[list[str], bool]:
+    final_newline = text.endswith("\n")
+    body = text[:-1] if final_newline else text
+    if body == "":
+        return [], final_newline
+    return body.split("\n"), final_newline
+
+
+def join_preserving_final_newline(lines: list[str], final_newline: bool) -> str:
+    output = "\n".join(lines)
+    if final_newline:
+        output += "\n"
+    return output
+
+
+def choose_smaller_lines(original: list[str], candidate: list[str]) -> list[str]:
+    original_text = "\n".join(original)
+    candidate_text = "\n".join(candidate)
+    if score(candidate_text) < score(original_text):
+        return candidate
+    return original
+
+
+def indent_lines(text: str) -> list[str]:
+    if not text:
+        return []
+    return [f" {line}" if line else "" for line in text.splitlines()]

codetool_shell/filters/traceback/__init__.py

@@ -0,0 +1,7 @@
+"""Standalone Python traceback shellion."""
+
+from __future__ import annotations
+
+from .reducer import compress_traceback_output
+
+__all__ = ["compress_traceback_output"]

codetool_shell/filters/traceback/detector.py

@@ -0,0 +1,209 @@
+"""Conservative parser for standalone Python tracebacks."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+from .summary import (
+    is_chain_separator,
+    is_context_line,
+    is_traceback_header,
+    is_unindented_exception_summary,
+    normalize_context_line,
+    normalize_selected_line,
+    parse_frame_line,
+)
+
+
+@dataclass(frozen=True)
+class TracebackFrame:
+    """A parsed traceback frame with optional source/caret context."""
+
+    line: str
+    path: str
+    context: tuple[str, ...] = ()
+
+
+@dataclass(frozen=True)
+class TracebackBlock:
+    """One Python traceback block ending in an exception summary."""
+
+    start: int
+    end: int
+    frames: tuple[TracebackFrame, ...]
+    exception: str
+
+
+@dataclass(frozen=True)
+class TracebackSeparator:
+    """A chained-exception separator line."""
+
+    start: int
+    end: int
+    line: str
+
+
+TracebackEvent = TracebackBlock | TracebackSeparator
+
+
+@dataclass(frozen=True)
+class TracebackParse:
+    """Parsed traceback events in source order."""
+
+    events: tuple[TracebackEvent, ...]
+
+
+def parse_python_traceback(lines: list[str]) -> TracebackParse | None:
+    """Return parsed standalone traceback events, or ``None`` if uncertain."""
+
+    if _has_other_filter_ownership(lines):
+        return None
+
+    events: list[TracebackEvent] = []
+    invalid_header = False
+    index = 0
+    while index < len(lines):
+        stripped = lines[index].strip()
+        if is_traceback_header(stripped):
+            parsed = _parse_block(lines, index)
+            if parsed is None:
+                invalid_header = True
+                break
+            events.append(parsed)
+            index = parsed.end
+            continue
+        if is_chain_separator(stripped):
+            events.append(
+                TracebackSeparator(
+                    start=index,
+                    end=index + 1,
+                    line=normalize_selected_line(lines[index]),
+                )
+            )
+        index += 1
+
+    blocks = [event for event in events if isinstance(event, TracebackBlock)]
+    if invalid_header or not blocks:
+        return None
+    return TracebackParse(tuple(_drop_unanchored_separators(events)))
+
+
+def _parse_block(lines: list[str], start: int) -> TracebackBlock | None:
+    frames: list[TracebackFrame] = []
+    index = start + 1
+
+    while index < len(lines):
+        stripped = lines[index].strip()
+        if not stripped:
+            index += 1
+            continue
+        if is_traceback_header(stripped) or is_chain_separator(stripped):
+            break
+
+        parsed_frame = parse_frame_line(lines[index])
+        if parsed_frame is None:
+            if frames and is_unindented_exception_summary(lines[index]):
+                return TracebackBlock(
+                    start=start,
+                    end=index + 1,
+                    frames=tuple(frames),
+                    exception=normalize_selected_line(lines[index]),
+                )
+            return None
+
+        index += 1
+        context: list[str] = []
+        while index < len(lines):
+            inner = lines[index].strip()
+            if not inner:
+                index += 1
+                continue
+            if (
+                is_traceback_header(inner)
+                or is_chain_separator(inner)
+                or parse_frame_line(lines[index]) is not None
+            ):
+                break
+            if is_unindented_exception_summary(lines[index]):
+                frames.append(
+                    TracebackFrame(
+                        line=parsed_frame.line,
+                        path=parsed_frame.path,
+                        context=tuple(context),
+                    )
+                )
+                return TracebackBlock(
+                    start=start,
+                    end=index + 1,
+                    frames=tuple(frames),
+                    exception=normalize_selected_line(lines[index]),
+                )
+            if is_context_line(lines[index]):
+                context.append(normalize_context_line(lines[index]))
+                index += 1
+                continue
+            return None
+
+        frames.append(
+            TracebackFrame(
+                line=parsed_frame.line,
+                path=parsed_frame.path,
+                context=tuple(context),
+            )
+        )
+
+    return None
+
+
+def _drop_unanchored_separators(events: list[TracebackEvent]) -> list[TracebackEvent]:
+    output: list[TracebackEvent] = []
+    for position, event in enumerate(events):
+        if isinstance(event, TracebackBlock):
+            output.append(event)
+            continue
+        has_block_before = any(isinstance(item, TracebackBlock) for item in events[:position])
+        has_block_after = any(isinstance(item, TracebackBlock) for item in events[position + 1 :])
+        if has_block_before and has_block_after:
+            output.append(event)
+    return output
+
+
+def _has_other_filter_ownership(lines: list[str]) -> bool:
+    stripped = [line.strip() for line in lines]
+    lowered_text = "\n".join(stripped).lower()
+
+    if any(line.startswith(("test output:", "ci log:")) for line in stripped):
+        return True
+    if "test session starts" in lowered_text or "short test summary info" in lowered_text:
+        return True
+    if _has_unittest_shape(stripped):
+        return True
+    if any(_has_ci_marker(line) for line in lines):
+        return True
+    return False
+
+
+def _has_unittest_shape(lines: list[str]) -> bool:
+    return (
+        any(_UNITTEST_RAN_RE.match(line) is not None for line in lines)
+        and any(line == "OK" or line.startswith(("OK (", "FAILED (")) for line in lines)
+        and any(
+            line.startswith(("FAIL:", "ERROR:"))
+            or (len(line) >= 5 and set(line) == {"-"})
+            for line in lines
+        )
+    )
+
+
+def _has_ci_marker(line: str) -> bool:
+    stripped = line.strip()
+    return (
+        "##[" in stripped
+        or stripped.startswith(("::error", "::warning", "::group::", "::endgroup::"))
+        or bool(_GHA_TIMESTAMP_PREFIX_RE.match(line))
+    )
+
+
+_UNITTEST_RAN_RE = re.compile(r"^Ran \d+ tests? in [0-9.]+s$")
+_GHA_TIMESTAMP_PREFIX_RE = re.compile(r"^(?:[^\t]+\t[^\t]+\t)?\d{4}-\d{2}-\d{2}T.*Z ")