shrinkray 25.12.27.2__py3-none-any.whl → 25.12.27.3__py3-none-any.whl

shrinkray/__main__.py

@@ -17,18 +17,19 @@ from shrinkray.cli import (
     validate_command,
     validate_ui,
 )
+from shrinkray.formatting import determine_formatter_command
 from shrinkray.passes.clangdelta import (
     C_FILE_EXTENSIONS,
     ClangDelta,
     find_clang_delta,
 )
-from shrinkray.problem import InvalidInitialExample
 from shrinkray.state import (
     ShrinkRayDirectoryState,
     ShrinkRayState,
     ShrinkRayStateSingleFile,
 )
 from shrinkray.ui import BasicUI, ShrinkRayUI
+from shrinkray.validation import run_validation
 from shrinkray.work import Volume
 
 
@@ -39,12 +40,9 @@ async def run_shrink_ray(
     """Run the shrink ray reduction process."""
     async with trio.open_nursery() as nursery:
         problem = state.problem
-        try:
-            await problem.setup()
-        except* InvalidInitialExample as excs:
-            assert len(excs.exceptions) == 1
-            (e,) = excs.exceptions
-            await state.report_error(e)
+        # Validation runs before run_shrink_ray is called, so setup() should
+        # always succeed. If it doesn't, there's a bug and we want it to propagate.
+        await problem.setup()
 
         reducer = state.reducer
 
@@ -273,6 +271,26 @@ def main(
     if not backup:
         backup = filename + os.extsep + "bak"
 
+    # Run initial validation before any state setup
+    # This validates the interestingness test and formatter with proper output streaming
+    formatter_command = None
+    if not os.path.isdir(filename) and formatter.lower() != "none":
+        formatter_command = determine_formatter_command(formatter, filename)
+
+    validation_result = run_validation(
+        file_path=filename,
+        test=test,
+        input_type=input_type,
+        in_place=in_place,
+        formatter_command=formatter_command,
+    )
+
+    if not validation_result.success:
+        print(f"\nError: {validation_result.error_message}", file=sys.stderr)
+        sys.exit(1)
+
+    print("\nStarting reduction...", file=sys.stderr, flush=True)
+
     state_kwargs: dict[str, Any] = {
         "input_type": input_type,
         "in_place": in_place,
@@ -307,8 +325,6 @@ def main(
 
         state = ShrinkRayDirectoryState(initial=initial, **state_kwargs)
 
-        trio.run(state.check_formatter)
-
     else:
         try:
             os.remove(backup)
@@ -323,8 +339,6 @@ def main(
 
         state = ShrinkRayStateSingleFile(initial=initial, **state_kwargs)
 
-        trio.run(state.check_formatter)
-
     if ui_type == UIType.textual:
         from shrinkray.tui import run_textual_ui
 

shrinkray/state.py

@@ -8,6 +8,7 @@ import subprocess
 import sys
 import time
 from abc import ABC, abstractmethod
+from collections import deque
 from datetime import timedelta
 from tempfile import TemporaryDirectory
 from typing import Any, TypeVar
@@ -58,6 +59,125 @@ def compute_dynamic_timeout(runtime: float) -> float:
     )
 
 
+@define
+class TestOutputManager:
+    """Manages temporary files for test output capture.
+
+    Allocates unique files for each test's stdout/stderr output,
+    tracks active and completed tests, and cleans up old files.
+    """
+
+    output_dir: str
+    max_files: int = 50
+    max_age_seconds: float = 60.0
+    min_display_seconds: float = 1.0  # Minimum time to show completed output
+    grace_period_seconds: float = (
+        0.5  # Extra time to wait for new test after min_display
+    )
+
+    _sequence: int = 0
+    _active_outputs: dict[int, str] = {}
+    _completed_outputs: deque[tuple[int, str, float]] = deque()
+
+    def __attrs_post_init__(self) -> None:
+        # Initialize mutable defaults
+        self._active_outputs = {}
+        self._completed_outputs = deque()
+
+    def allocate_output_file(self) -> tuple[int, str]:
+        """Allocate a new output file for a test. Returns (test_id, file_path)."""
+        test_id = self._sequence
+        self._sequence += 1
+        file_path = os.path.join(self.output_dir, f"test_{test_id}.log")
+        self._active_outputs[test_id] = file_path
+        return test_id, file_path
+
+    def mark_completed(self, test_id: int) -> None:
+        """Mark a test as completed and move to completed queue."""
+        if test_id in self._active_outputs:
+            file_path = self._active_outputs.pop(test_id)
+            self._completed_outputs.append((test_id, file_path, time.time()))
+            self._cleanup_old_files()
+
+    def _cleanup_old_files(self) -> None:
+        """Remove old output files based on count and age limits."""
+        now = time.time()
+        # Remove files older than max_age_seconds
+        while (
+            self._completed_outputs
+            and now - self._completed_outputs[0][2] > self.max_age_seconds
+        ):
+            _, file_path, _ = self._completed_outputs.popleft()
+            self._safe_delete(file_path)
+        # Remove excess files beyond max_files
+        while len(self._completed_outputs) > self.max_files:
+            _, file_path, _ = self._completed_outputs.popleft()
+            self._safe_delete(file_path)
+
+    def _should_show_completed(self) -> tuple[int, str] | None:
+        """Check if we should show a completed test's output.
+
+        Note: This method is only called when there are no active tests.
+        It returns the completed test info if within the display window
+        (min_display_seconds + grace_period).
+        """
+        if not self._completed_outputs:
+            return None
+        test_id, file_path, completion_time = self._completed_outputs[-1]
+        elapsed = time.time() - completion_time
+
+        # Show completed test during the full display window
+        if elapsed < self.min_display_seconds + self.grace_period_seconds:
+            return test_id, file_path
+
+        return None
+
+    def get_current_output_path(self) -> str | None:
+        """Get the most relevant output file path.
+
+        Active tests always take priority. If no active test, shows
+        recently completed test output for min_display_seconds, plus
+        an additional grace_period if no new test has started.
+        """
+        # Active tests always take priority
+        if self._active_outputs:
+            max_id = max(self._active_outputs.keys())
+            return self._active_outputs[max_id]
+        # Then check for recently completed test that should stay visible
+        recent = self._should_show_completed()
+        if recent is not None:
+            return recent[1]
+        # Fall back to most recent completed (even if past display window)
+        if self._completed_outputs:
+            return self._completed_outputs[-1][1]
+        return None
+
+    def get_active_test_id(self) -> int | None:
+        """Get the currently running test ID, if any.
+
+        Returns the active test ID if one is running, None otherwise.
+        """
+        if self._active_outputs:
+            return max(self._active_outputs.keys())
+        return None
+
+    def cleanup_all(self) -> None:
+        """Clean up all output files (called on shutdown)."""
+        for file_path in self._active_outputs.values():
+            self._safe_delete(file_path)
+        for _, file_path, _ in self._completed_outputs:
+            self._safe_delete(file_path)
+        self._active_outputs.clear()
+        self._completed_outputs.clear()
+
+    @staticmethod
+    def _safe_delete(path: str) -> None:
+        try:
+            os.unlink(path)
+        except OSError:
+            pass
+
+
 @define(slots=False)
 class ShrinkRayState[TestCase](ABC):
     input_type: Any  # InputType from __main__
@@ -91,6 +211,9 @@ class ShrinkRayState[TestCase](ABC):
     # Stores the output from the last debug run
     _last_debug_output: str = ""
 
+    # Optional output manager for capturing test output (TUI mode)
+    output_manager: TestOutputManager | None = None
+
     def __attrs_post_init__(self):
         self.is_interesting_limiter = trio.CapacityLimiter(max(self.parallelism, 1))
         self.setup_formatter()
@@ -175,8 +298,17 @@ class ShrinkRayState[TestCase](ABC):
 
             return completed.returncode
 
-        # Check if we should stream output to stderr (volume=debug)
-        if self.volume == Volume.debug:
+        # Determine output handling
+        test_id: int | None = None
+        output_file_handle = None
+
+        if self.output_manager is not None:
+            # Capture output to a file for TUI display
+            test_id, output_path = self.output_manager.allocate_output_file()
+            output_file_handle = open(output_path, "wb")
+            kwargs["stdout"] = output_file_handle.fileno()
+            kwargs["stderr"] = subprocess.STDOUT  # Combine stderr into stdout
+        elif self.volume == Volume.debug:
             # Inherit stderr from parent process to stream output in real-time
             kwargs["stderr"] = None  # None means inherit
             kwargs["stdout"] = subprocess.DEVNULL
@@ -185,59 +317,66 @@ class ShrinkRayState[TestCase](ABC):
             kwargs["stdout"] = subprocess.DEVNULL
             kwargs["stderr"] = subprocess.DEVNULL
 
-        async with trio.open_nursery() as nursery:
+        try:
+            async with trio.open_nursery() as nursery:
 
-            def call_with_kwargs(task_status=trio.TASK_STATUS_IGNORED):  # type: ignore
-                return trio.run_process(command, **kwargs, task_status=task_status)
+                def call_with_kwargs(task_status=trio.TASK_STATUS_IGNORED):  # type: ignore
+                    return trio.run_process(command, **kwargs, task_status=task_status)
 
-            start_time = time.time()
-            sp = await nursery.start(call_with_kwargs)
-
-            try:
-                # Determine effective timeout for this call
-                if self.first_call:
-                    # For first call: use calibration timeout if dynamic, otherwise 10x explicit timeout
-                    if self.timeout is None:
-                        effective_timeout = DYNAMIC_TIMEOUT_CALIBRATION_TIMEOUT
-                    else:
-                        effective_timeout = self.timeout * 10
-                else:
-                    # For subsequent calls, timeout must be set (either explicit or computed)
-                    assert self.timeout is not None
-                    effective_timeout = self.timeout
-
-                with trio.move_on_after(effective_timeout):
-                    await sp.wait()
-
-                runtime = time.time() - start_time
-
-                if sp.returncode is None:
-                    # Process didn't terminate before timeout - kill it
-                    await self._interrupt_wait_and_kill(sp)
-
-                # Check for timeout violation (only when timeout is explicitly set)
-                if (
-                    self.timeout is not None
-                    and runtime >= self.timeout
-                    and self.first_call
-                ):
-                    raise TimeoutExceededOnInitial(
-                        timeout=self.timeout,
-                        runtime=runtime,
-                    )
-            finally:
-                if self.first_call:
-                    self.initial_exit_code = sp.returncode
-                    # Set dynamic timeout if not explicitly specified
-                    if self.timeout is None:
-                        runtime = time.time() - start_time
-                        self.timeout = compute_dynamic_timeout(runtime)
-                self.first_call = False
+                start_time = time.time()
+                sp = await nursery.start(call_with_kwargs)
 
-            result: int | None = sp.returncode
-            assert result is not None
-
-            return result
+                try:
+                    # Determine effective timeout for this call
+                    if self.first_call:
+                        # For first call: use calibration timeout if dynamic, otherwise 10x explicit timeout
+                        if self.timeout is None:
+                            effective_timeout = DYNAMIC_TIMEOUT_CALIBRATION_TIMEOUT
+                        else:
+                            effective_timeout = self.timeout * 10
+                    else:
+                        # For subsequent calls, timeout must be set (either explicit or computed)
+                        assert self.timeout is not None
+                        effective_timeout = self.timeout
+
+                    with trio.move_on_after(effective_timeout):
+                        await sp.wait()
+
+                    runtime = time.time() - start_time
+
+                    if sp.returncode is None:
+                        # Process didn't terminate before timeout - kill it
+                        await self._interrupt_wait_and_kill(sp)
+
+                    # Check for timeout violation (only when timeout is explicitly set)
+                    if (
+                        self.timeout is not None
+                        and runtime >= self.timeout
+                        and self.first_call
+                    ):
+                        raise TimeoutExceededOnInitial(
+                            timeout=self.timeout,
+                            runtime=runtime,
+                        )
+                finally:
+                    if self.first_call:
+                        self.initial_exit_code = sp.returncode
+                        # Set dynamic timeout if not explicitly specified
+                        if self.timeout is None:
+                            runtime = time.time() - start_time
+                            self.timeout = compute_dynamic_timeout(runtime)
+                    self.first_call = False
+
+                result: int | None = sp.returncode
+                assert result is not None
+
+                return result
+        finally:
+            # Clean up output file handle and mark test as completed
+            if output_file_handle is not None:
+                output_file_handle.close()
+            if test_id is not None and self.output_manager is not None:
+                self.output_manager.mark_completed(test_id)
 
     async def run_for_exit_code(self, test_case: TestCase, debug: bool = False) -> int:
         # Lazy import

shrinkray/subprocess/client.py

@@ -136,6 +136,7 @@ class SubprocessClient:
         no_clang_delta: bool = False,
         clang_delta: str = "",
         trivial_is_error: bool = True,
+        skip_validation: bool = False,
     ) -> Response:
         """Start the reduction process."""
         params: dict[str, Any] = {
@@ -149,6 +150,7 @@ class SubprocessClient:
             "no_clang_delta": no_clang_delta,
             "clang_delta": clang_delta,
             "trivial_is_error": trivial_is_error,
+            "skip_validation": skip_validation,
         }
         if parallelism is not None:
             params["parallelism"] = parallelism

shrinkray/subprocess/protocol.py

@@ -56,6 +56,10 @@ class ProgressUpdate:
     current_pass_name: str = ""
     # List of disabled pass names
     disabled_passes: list[str] = field(default_factory=list)
+    # Test output preview (last 4KB of current/recent test output)
+    test_output_preview: str = ""
+    # Currently running test ID (None if no test running)
+    active_test_id: int | None = None
 
 
 @dataclass
@@ -115,6 +119,8 @@ def serialize(msg: Request | Response | ProgressUpdate) -> str:
                 ],
                 "current_pass_name": msg.current_pass_name,
                 "disabled_passes": msg.disabled_passes,
+                "test_output_preview": msg.test_output_preview,
+                "active_test_id": msg.active_test_id,
             },
         }
     else:
@@ -162,6 +168,8 @@ def deserialize(line: str) -> Request | Response | ProgressUpdate:
             pass_stats=pass_stats_data,
             current_pass_name=d.get("current_pass_name", ""),
             disabled_passes=d.get("disabled_passes", []),
+            test_output_preview=d.get("test_output_preview", ""),
+            active_test_id=d.get("active_test_id"),
         )
 
     # Check for response (has "result" or "error" field)

shrinkray/subprocess/worker.py

@@ -1,7 +1,9 @@
 """Worker subprocess that runs the reducer with trio and communicates via JSON protocol."""
 
 import os
+import shutil
 import sys
+import tempfile
 import time
 import traceback
 from contextlib import aclosing
@@ -62,6 +64,8 @@ class ReducerWorker:
         # I/O streams - None means use stdin/stdout
         self._input_stream = input_stream
         self._output_stream = output_stream
+        # Output directory for test output capture (cleaned up on shutdown)
+        self._output_dir: str | None = None
 
     async def emit(self, msg: Response | ProgressUpdate) -> None:
         """Write a message to the output stream."""
@@ -163,6 +167,7 @@ class ReducerWorker:
         from shrinkray.state import (
             ShrinkRayDirectoryState,
             ShrinkRayStateSingleFile,
+            TestOutputManager,
         )
         from shrinkray.work import Volume
 
@@ -178,6 +183,7 @@ class ReducerWorker:
         no_clang_delta = params.get("no_clang_delta", False)
         clang_delta_path = params.get("clang_delta", "")
         trivial_is_error = params.get("trivial_is_error", True)
+        skip_validation = params.get("skip_validation", False)
 
         clang_delta_executable = None
         if os.path.splitext(filename)[1] in C_FILE_EXTENSIONS and not no_clang_delta:
@@ -213,12 +219,18 @@ class ReducerWorker:
                 initial = reader.read()
             self.state = ShrinkRayStateSingleFile(initial=initial, **state_kwargs)
 
+        # Create output manager for test output capture (always enabled for TUI)
+        self._output_dir = tempfile.mkdtemp(prefix="shrinkray-output-")
+        self.state.output_manager = TestOutputManager(output_dir=self._output_dir)
+
         self.problem = self.state.problem
         self.reducer = self.state.reducer
 
         # Validate initial example before starting - this will raise
-        # InvalidInitialExample if the initial test case fails
-        await self.problem.setup()
+        # InvalidInitialExample if the initial test case fails.
+        # Skip if validation was already done by the caller (e.g., main()).
+        if not skip_validation:
+            await self.problem.setup()
 
         self.running = True
 
@@ -300,6 +312,32 @@ class ReducerWorker:
             return Response(id=request_id, result={"status": "skipped"})
         return Response(id=request_id, error="Reducer does not support pass control")
 
+    def _get_test_output_preview(self) -> tuple[str, int | None]:
+        """Get preview of current test output and active test ID."""
+        if self.state is None or self.state.output_manager is None:
+            return "", None
+
+        manager = self.state.output_manager
+        active_test_id = manager.get_active_test_id()
+        output_path = manager.get_current_output_path()
+
+        if output_path is None:
+            return "", active_test_id
+
+        # Read last 4KB of file
+        try:
+            with open(output_path, "rb") as f:
+                f.seek(0, 2)  # Seek to end
+                size = f.tell()
+                if size > 4096:
+                    f.seek(-4096, 2)
+                else:
+                    f.seek(0)
+                data = f.read()
+            return data.decode("utf-8", errors="replace"), active_test_id
+        except OSError:
+            return "", active_test_id
+
     def _get_content_preview(self) -> tuple[str, bool]:
         """Get a preview of the current test case content."""
         if self.problem is None:
@@ -402,6 +440,9 @@ class ReducerWorker:
         else:
             disabled_passes = []
 
+        # Get test output preview
+        test_output_preview, active_test_id = self._get_test_output_preview()
+
         return ProgressUpdate(
             status=self.reducer.status if self.reducer else "",
             size=stats.current_test_case_size,
@@ -420,6 +461,8 @@ class ReducerWorker:
             pass_stats=pass_stats_list,
             current_pass_name=current_pass_name,
             disabled_passes=disabled_passes,
+            test_output_preview=test_output_preview,
+            active_test_id=active_test_id,
         )
 
     async def emit_progress_updates(self) -> None:
@@ -469,25 +512,32 @@ class ReducerWorker:
 
     async def run(self) -> None:
         """Main entry point for the worker."""
-        async with trio.open_nursery() as nursery:
-            await nursery.start(self.read_commands)
+        try:
+            async with trio.open_nursery() as nursery:
+                await nursery.start(self.read_commands)
 
-            # Wait for start command
-            while not self.running:
-                await trio.sleep(0.01)
+                # Wait for start command
+                while not self.running:
+                    await trio.sleep(0.01)
 
-            # Start progress updates and reducer
-            nursery.start_soon(self.emit_progress_updates)
-            await self.run_reducer()
+                # Start progress updates and reducer
+                nursery.start_soon(self.emit_progress_updates)
+                await self.run_reducer()
 
-            # Emit final progress update before completion
-            final_update = await self._build_progress_update()
-            if final_update is not None:
-                await self.emit(final_update)
+                # Emit final progress update before completion
+                final_update = await self._build_progress_update()
+                if final_update is not None:
+                    await self.emit(final_update)
 
-            # Signal completion
-            await self.emit(Response(id="", result={"status": "completed"}))
-            nursery.cancel_scope.cancel()
+                # Signal completion
+                await self.emit(Response(id="", result={"status": "completed"}))
+                nursery.cancel_scope.cancel()
+        finally:
+            # Clean up test output files and temp directory
+            if self.state is not None and self.state.output_manager is not None:
+                self.state.output_manager.cleanup_all()
+            if self._output_dir is not None and os.path.isdir(self._output_dir):
+                shutil.rmtree(self._output_dir, ignore_errors=True)
 
 
 def main() -> None:

shrinkray/tui.py

@@ -1,6 +1,7 @@
 """Textual-based TUI for Shrink Ray."""
 
 import os
+import time
 import traceback
 from collections.abc import AsyncGenerator
 from contextlib import aclosing
@@ -11,14 +12,18 @@ import humanize
 from rich.text import Text
 from textual import work
 from textual.app import App, ComposeResult
-from textual.containers import Vertical, VerticalScroll
+from textual.containers import Horizontal, Vertical, VerticalScroll
 from textual.reactive import reactive
 from textual.screen import ModalScreen
 from textual.theme import Theme
 from textual.widgets import DataTable, Footer, Header, Label, Static
 
 from shrinkray.subprocess.client import SubprocessClient
-from shrinkray.subprocess.protocol import PassStatsData, ProgressUpdate, Response
+from shrinkray.subprocess.protocol import (
+    PassStatsData,
+    ProgressUpdate,
+    Response,
+)
 
 
 ThemeMode = Literal["auto", "dark", "light"]
@@ -229,8 +234,6 @@ class ContentPreview(Static):
     _pending_hex_mode: bool = False
 
     def update_content(self, content: str, hex_mode: bool) -> None:
-        import time
-
         # Store the pending content
         self._pending_content = content
         self._pending_hex_mode = hex_mode
@@ -305,6 +308,67 @@ class ContentPreview(Static):
         )
 
 
+class OutputPreview(Static):
+    """Widget to display test output preview."""
+
+    output_content = reactive("")
+    active_test_id: reactive[int | None] = reactive(None)
+    _last_update_time: float = 0.0
+    _last_seen_test_id: int | None = None  # Track last test ID for "completed" message
+
+    def update_output(self, content: str, test_id: int | None) -> None:
+        # Throttle updates to every 200ms
+        now = time.time()
+        if now - self._last_update_time < 0.2:
+            return
+
+        self._last_update_time = now
+        self.output_content = content
+        # Track the last test ID we've seen (for showing in "completed" message)
+        if test_id is not None:
+            self._last_seen_test_id = test_id
+        self.active_test_id = test_id
+        self.refresh(layout=True)
+
+    def _get_available_lines(self) -> int:
+        """Get the number of lines available for display based on container size."""
+        try:
+            parent = self.parent
+            if parent and hasattr(parent, "size"):
+                parent_size = parent.size  # type: ignore[union-attr]
+                if parent_size.height > 0:
+                    return max(10, parent_size.height - 3)
+            if self.app and self.app.size.height > 0:
+                return max(10, self.app.size.height - 15)
+        except Exception:
+            pass
+        return 30
+
+    def render(self) -> str:
+        # Header line
+        if self.active_test_id is not None:
+            header = f"[green]Test #{self.active_test_id} running...[/green]"
+        elif self.output_content and self._last_seen_test_id is not None:
+            header = f"[dim]Test #{self._last_seen_test_id} completed[/dim]"
+        else:
+            header = "[dim]No test output yet...[/dim]"
+
+        if not self.output_content:
+            return header
+
+        available_lines = self._get_available_lines()
+        lines = self.output_content.split("\n")
+
+        # Show tail of output (most recent lines)
+        if len(lines) <= available_lines:
+            return f"{header}\n{self.output_content}"
+
+        # Truncate from the beginning
+        truncated_lines = lines[-(available_lines):]
+        skipped = len(lines) - available_lines
+        return f"{header}\n... ({skipped} earlier lines)\n" + "\n".join(truncated_lines)
+
+
 class HelpScreen(ModalScreen[None]):
     """Modal screen showing keyboard shortcuts help."""
 
@@ -595,10 +659,32 @@ class ShrinkRayApp(App[None]):
         margin: 0 1;
     }
 
+    #content-area {
+        height: 1fr;
+    }
+
     #content-container {
         border: solid blue;
         margin: 1;
-        height: 1fr;
+        padding: 1;
+        width: 1fr;
+        height: 100%;
+    }
+
+    #content-container:dark {
+        border: solid lightskyblue;
+    }
+
+    #output-container {
+        border: solid blue;
+        margin: 1;
+        padding: 1;
+        width: 1fr;
+        height: 100%;
+    }
+
+    #output-container:dark {
+        border: solid lightskyblue;
     }
     """
 
@@ -661,8 +747,13 @@ class ShrinkRayApp(App[None]):
             )
             with Vertical(id="stats-container"):
                 yield StatsDisplay(id="stats-display")
-            with VerticalScroll(id="content-container"):
-                yield ContentPreview(id="content-preview")
+            with Horizontal(id="content-area"):
+                with VerticalScroll(id="content-container") as content_scroll:
+                    content_scroll.border_title = "Recent Reductions"
+                    yield ContentPreview(id="content-preview")
+                with VerticalScroll(id="output-container") as output_scroll:
+                    output_scroll.border_title = "Test Output"
+                    yield OutputPreview(id="output-preview")
         yield Footer()
 
     async def on_mount(self) -> None:
@@ -695,7 +786,7 @@ class ShrinkRayApp(App[None]):
 
                 await self._client.start()
 
-                # Start the reduction
+                # Start the reduction - validation was already done by main()
                 response = await self._client.start_reduction(
                     file_path=self._file_path,
                     test=self._test,
@@ -709,6 +800,7 @@ class ShrinkRayApp(App[None]):
                     no_clang_delta=self._no_clang_delta,
                     clang_delta=self._clang_delta,
                     trivial_is_error=self._trivial_is_error,
+                    skip_validation=True,
                 )
 
                 if response.error:
@@ -719,6 +811,7 @@ class ShrinkRayApp(App[None]):
             # Monitor progress (client is already started and reduction is running)
             stats_display = self.query_one("#stats-display", StatsDisplay)
             content_preview = self.query_one("#content-preview", ContentPreview)
+            output_preview = self.query_one("#output-preview", OutputPreview)
 
             async with aclosing(self._client.get_progress_updates()) as updates:
                 async for update in updates:
@@ -726,6 +819,9 @@ class ShrinkRayApp(App[None]):
                     content_preview.update_content(
                         update.content_preview, update.hex_mode
                     )
+                    output_preview.update_output(
+                        update.test_output_preview, update.active_test_id
+                    )
                     self._latest_pass_stats = update.pass_stats
                     self._current_pass_name = update.current_pass_name
                     self._disabled_passes = update.disabled_passes
@@ -741,7 +837,10 @@ class ShrinkRayApp(App[None]):
             # Check if there was an error from the worker
             if self._client.error_message:
                 # Exit immediately on error, printing the error message
-                self.exit(return_code=1, message=f"Error: {self._client.error_message}")
+                self.exit(
+                    return_code=1,
+                    message=f"Error: {self._client.error_message}",
+                )
                 return
             elif self._exit_on_completion:
                 self.exit()
@@ -804,54 +903,6 @@ class ShrinkRayApp(App[None]):
         return self._completed
 
 
-async def _validate_initial_example(
-    file_path: str,
-    test: list[str],
-    parallelism: int | None,
-    timeout: float | None,
-    seed: int,
-    input_type: str,
-    in_place: bool,
-    formatter: str,
-    volume: str,
-    no_clang_delta: bool,
-    clang_delta: str,
-    trivial_is_error: bool,
-) -> str | None:
-    """Validate initial example before showing TUI.
-
-    Returns error_message if validation failed, None if it passed.
-    """
-    debug_mode = volume == "debug"
-    client = SubprocessClient(debug_mode=debug_mode)
-    try:
-        await client.start()
-
-        response = await client.start_reduction(
-            file_path=file_path,
-            test=test,
-            parallelism=parallelism,
-            timeout=timeout,
-            seed=seed,
-            input_type=input_type,
-            in_place=in_place,
-            formatter=formatter,
-            volume=volume,
-            no_clang_delta=no_clang_delta,
-            clang_delta=clang_delta,
-            trivial_is_error=trivial_is_error,
-        )
-
-        if response.error:
-            return response.error
-
-        # Validation passed - cancel this reduction since TUI will start fresh
-        await client.cancel()
-        return None
-    finally:
-        await client.close()
-
-
 def run_textual_ui(
     file_path: str,
     test: list[str],
@@ -868,43 +919,14 @@ def run_textual_ui(
     exit_on_completion: bool = True,
     theme: ThemeMode = "auto",
 ) -> None:
-    """Run the textual TUI."""
-    import asyncio
-    import sys
-
-    print("Validating initial example...", flush=True)
-
-    # Validate initial example before showing TUI
-    async def validate():
-        return await _validate_initial_example(
-            file_path=file_path,
-            test=test,
-            parallelism=parallelism,
-            timeout=timeout,
-            seed=seed,
-            input_type=input_type,
-            in_place=in_place,
-            formatter=formatter,
-            volume=volume,
-            no_clang_delta=no_clang_delta,
-            clang_delta=clang_delta,
-            trivial_is_error=trivial_is_error,
-        )
+    """Run the textual TUI.
 
-    try:
-        error = asyncio.run(validate())
-    except Exception as e:
-        import traceback
-
-        traceback.print_exc()
-        print(f"Error: {e}", file=sys.stderr)
-        sys.exit(1)
-
-    if error:
-        print(f"Error: {error}", file=sys.stderr)
-        sys.exit(1)
+    Note: Validation must be done before calling this function.
+    The caller (main()) is responsible for running run_validation() first.
+    """
+    import sys
 
-    # Validation passed - now show the TUI which will start a fresh client
+    # Start the TUI app - validation has already been done by main()
     app = ShrinkRayApp(
         file_path=file_path,
         test=test,

shrinkray/validation.py

@@ -0,0 +1,403 @@
+"""Initial validation of interestingness tests before reduction.
+
+This module provides validation that runs in the main process using trio,
+before the TUI is launched. It prints commands and temporary directories
+to stderr so users can understand what's happening with slow tests, and
+preserves temporary directories on failure for debugging.
+"""
+
+import io
+import os
+import shlex
+import shutil
+import subprocess
+import sys
+import tempfile
+import traceback
+from dataclasses import dataclass
+
+import trio
+
+from shrinkray.cli import InputType
+
+
+@dataclass
+class ValidationResult:
+    """Result of initial validation."""
+
+    success: bool
+    error_message: str | None = None
+    exit_code: int | None = None
+    # Temp directories to clean up only on success
+    temp_dirs: list[str] | None = None
+    # Whether formatter is usable (None if no formatter specified)
+    formatter_works: bool | None = None
+
+
+def _build_command(
+    test: list[str],
+    working_file: str,
+    input_type: InputType,
+) -> list[str]:
+    """Build the command to run, adding test file path if needed."""
+    if input_type.enabled(InputType.arg):
+        return test + [working_file]
+    return list(test)
+
+
+def _format_command_for_display(command: list[str], cwd: str) -> str:
+    """Format a command for display, with cd on its own line and relative paths.
+
+    Returns a multi-line string with:
+    - cd <directory>
+    - <command with relative paths for files in cwd>
+    """
+    # Convert absolute paths within cwd to relative paths for readability
+    display_parts = []
+    for part in command:
+        if part.startswith(cwd + os.sep):
+            # Convert to relative path
+            display_parts.append(os.path.relpath(part, cwd))
+        else:
+            display_parts.append(part)
+
+    quoted = " ".join(shlex.quote(part) for part in display_parts)
+    return f"cd {shlex.quote(cwd)}\n{quoted}"
+
+
+async def _run_validation_test(
+    test: list[str],
+    initial_content: bytes,
+    base: str,
+    input_type: InputType,
+    in_place: bool,
+    filename: str,
+) -> ValidationResult:
+    """Run the interestingness test once and check if it passes.
+
+    Returns ValidationResult with success=True if the test passed (exit code 0),
+    or success=False with error details if it failed.
+    """
+    temp_dirs: list[str] = []
+
+    try:
+        # Determine working directory and file path
+        if in_place:
+            if input_type == InputType.basename:
+                working = filename
+                cwd = os.getcwd()
+                # Write directly to original file
+                async with await trio.open_file(working, "wb") as f:
+                    await f.write(initial_content)
+            else:
+                # Create a temp file in same directory with random suffix
+                base_name, ext = os.path.splitext(filename)
+                working = base_name + "-" + os.urandom(16).hex() + ext
+                cwd = os.getcwd()
+                async with await trio.open_file(working, "wb") as f:
+                    await f.write(initial_content)
+                temp_dirs.append(working)  # Track for cleanup
+        else:
+            # Create a temporary directory
+            temp_dir = tempfile.mkdtemp(prefix="shrinkray-validate-")
+            temp_dirs.append(temp_dir)
+            working = os.path.join(temp_dir, base)
+            cwd = temp_dir
+            async with await trio.open_file(working, "wb") as f:
+                await f.write(initial_content)
+
+        # Build command
+        command = _build_command(test, working, input_type)
+
+        # Print what we're doing to stderr
+        print(
+            "\nRunning interestingness test:",
+            file=sys.stderr,
+            flush=True,
+        )
+        print(
+            _format_command_for_display(command, cwd),
+            file=sys.stderr,
+            flush=True,
+        )
+        print(file=sys.stderr, flush=True)
+
+        # Handle stdin if needed
+        stdin_data: bytes | None = None
+        if input_type.enabled(InputType.stdin) and not os.path.isdir(working):
+            with open(working, "rb") as f:
+                stdin_data = f.read()
+
+        # Run subprocess with real-time output streaming
+        # We use subprocess.run in a thread because trio.run_process doesn't
+        # properly support file descriptor inheritance for streaming output.
+        def run_subprocess() -> subprocess.CompletedProcess[bytes]:
+            # Try to stream output directly to stderr if possible
+            # This allows real-time output visibility for slow tests
+            try:
+                stderr_fd = sys.stderr.fileno()
+                return subprocess.run(
+                    command,
+                    cwd=cwd,
+                    stdin=subprocess.DEVNULL if stdin_data is None else None,
+                    stdout=stderr_fd,
+                    stderr=stderr_fd,
+                    input=stdin_data,
+                    check=False,
+                )
+            except (io.UnsupportedOperation, OSError):
+                # Falls back to capturing if stderr doesn't have a real file
+                # descriptor (e.g., when running under pytest with capture)
+                return subprocess.run(
+                    command,
+                    cwd=cwd,
+                    stdin=subprocess.DEVNULL if stdin_data is None else None,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    input=stdin_data,
+                    check=False,
+                )
+
+        result = await trio.to_thread.run_sync(run_subprocess)
+
+        # If we captured output (fallback mode), print it now
+        if result.stdout:
+            sys.stderr.buffer.write(result.stdout)
+            sys.stderr.flush()
+        if result.stderr:
+            sys.stderr.buffer.write(result.stderr)
+            sys.stderr.flush()
+
+        print(file=sys.stderr, flush=True)
+        print(
+            f"Exit code: {result.returncode}",
+            file=sys.stderr,
+            flush=True,
+        )
+
+        if result.returncode != 0:
+            return ValidationResult(
+                success=False,
+                error_message=(
+                    f"Interestingness test exited with code {result.returncode}, "
+                    f"but should return 0 for interesting test cases.\n\n"
+                    f"To reproduce:\n{_format_command_for_display(command, cwd)}"
+                ),
+                exit_code=result.returncode,
+                temp_dirs=temp_dirs,
+            )
+
+        return ValidationResult(
+            success=True,
+            exit_code=0,
+            temp_dirs=temp_dirs,
+        )
+
+    except Exception as e:
+        traceback.print_exc()
+        return ValidationResult(
+            success=False,
+            error_message=f"Error running interestingness test: {e}",
+            temp_dirs=temp_dirs,
+        )
+
+
+async def _run_formatter(
+    formatter_command: list[str],
+    content: bytes,
+) -> subprocess.CompletedProcess[bytes]:
+    """Run the formatter command on content, streaming output to stderr."""
+
+    print("\nRunning formatter:", file=sys.stderr, flush=True)
+    print(
+        " ".join(shlex.quote(part) for part in formatter_command),
+        file=sys.stderr,
+        flush=True,
+    )
+
+    def run_subprocess() -> subprocess.CompletedProcess[bytes]:
+        return subprocess.run(
+            formatter_command,
+            input=content,
+            capture_output=True,
+            check=False,
+        )
+
+    result = await trio.to_thread.run_sync(run_subprocess)
+
+    # Show stderr from formatter if any
+    if result.stderr:
+        sys.stderr.buffer.write(result.stderr)
+        sys.stderr.flush()
+
+    print(
+        f"Formatter exit code: {result.returncode}",
+        file=sys.stderr,
+        flush=True,
+    )
+
+    return result
+
+
+async def validate_initial_example(
+    file_path: str,
+    test: list[str],
+    input_type: InputType,
+    in_place: bool,
+    formatter_command: list[str] | None = None,
+) -> ValidationResult:
+    """Validate that the initial example passes the interestingness test.
+
+    This runs directly in the main process using trio, streaming output
+    to stderr so users can see progress for slow tests. Also checks the
+    formatter if one is specified.
+
+    Args:
+        file_path: Path to the file to reduce
+        test: The interestingness test command
+        input_type: How to pass input to the test
+        in_place: Whether to run in the current directory
+        formatter_command: Optional formatter command to validate
+
+    Returns:
+        ValidationResult indicating success or failure with details.
+        On failure, temp_dirs are preserved for debugging.
+    """
+    # Read the initial content
+    if os.path.isdir(file_path):
+        # For directories, we need different handling
+        # For now, just validate that it's a valid directory
+        return ValidationResult(success=True)
+
+    with open(file_path, "rb") as f:
+        initial_content = f.read()
+
+    base = os.path.basename(file_path)
+
+    print("Validating interestingness test...", file=sys.stderr, flush=True)
+
+    result = await _run_validation_test(
+        test=test,
+        initial_content=initial_content,
+        base=base,
+        input_type=input_type,
+        in_place=in_place,
+        filename=file_path,
+    )
+
+    if not result.success:
+        # On failure, keep temp directories and tell user
+        if result.temp_dirs:
+            print(
+                "\nTemporary files preserved for debugging:",
+                file=sys.stderr,
+                flush=True,
+            )
+            for path in result.temp_dirs:
+                print(f"  {path}", file=sys.stderr, flush=True)
+        return result
+
+    # Clean up temp directories from initial test
+    if result.temp_dirs:
+        for path in result.temp_dirs:
+            try:
+                if os.path.isdir(path):
+                    shutil.rmtree(path)
+                elif os.path.exists(path):
+                    os.unlink(path)
+            except Exception:
+                pass  # Best effort cleanup
+
+    print("Initial validation passed.", file=sys.stderr, flush=True)
+
+    # Now check formatter if specified
+    formatter_works: bool | None = None
+    if formatter_command is not None:
+        formatter_result = await _run_formatter(formatter_command, initial_content)
+
+        if formatter_result.returncode != 0:
+            return ValidationResult(
+                success=False,
+                error_message=(
+                    "Formatter exited unexpectedly on initial test case. "
+                    "If this is expected, please run with --formatter=none.\n\n"
+                    f"Formatter stderr:\n{formatter_result.stderr.decode('utf-8', errors='replace').strip()}"
+                ),
+                exit_code=formatter_result.returncode,
+            )
+
+        reformatted = formatter_result.stdout
+
+        # If formatter changed the content, verify it's still interesting
+        if reformatted != initial_content:
+            print(
+                "\nChecking if formatted version is still interesting...",
+                file=sys.stderr,
+                flush=True,
+            )
+            formatted_result = await _run_validation_test(
+                test=test,
+                initial_content=reformatted,
+                base=base,
+                input_type=input_type,
+                in_place=in_place,
+                filename=file_path,
+            )
+
+            # Clean up temp dirs from formatted test
+            if formatted_result.temp_dirs:
+                for path in formatted_result.temp_dirs:
+                    try:
+                        if os.path.isdir(path):
+                            shutil.rmtree(path)
+                        elif os.path.exists(path):
+                            os.unlink(path)
+                    except Exception:
+                        pass
+
+            if not formatted_result.success:
+                return ValidationResult(
+                    success=False,
+                    error_message=(
+                        "Formatting initial test case made it uninteresting. "
+                        "If this is expected, please run with --formatter=none.\n\n"
+                        f"Formatter stderr:\n{formatter_result.stderr.decode('utf-8', errors='replace').strip()}"
+                    ),
+                    exit_code=formatted_result.exit_code,
+                )
+
+            print("Formatted version is also interesting.", file=sys.stderr, flush=True)
+
+        formatter_works = True
+
+    return ValidationResult(
+        success=True,
+        exit_code=0,
+        formatter_works=formatter_works,
+    )
+
+
+def run_validation(
+    file_path: str,
+    test: list[str],
+    input_type: InputType,
+    in_place: bool,
+    formatter_command: list[str] | None = None,
+) -> ValidationResult:
+    """Run initial validation synchronously using trio.run().
+
+    This is the main entry point for validation from the CLI/TUI.
+    It runs validation directly in the main process before any asyncio
+    event loop is started.
+    """
+
+    async def _run() -> ValidationResult:
+        return await validate_initial_example(
+            file_path,
+            test,
+            input_type,
+            in_place,
+            formatter_command,
+        )
+
+    return trio.run(_run)

{shrinkray-25.12.27.2.dist-info → shrinkray-25.12.27.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shrinkray
-Version: 25.12.27.2
+Version: 25.12.27.3
 Summary: Shrink Ray
 Author-email: "David R. MacIver" <david@drmaciver.com>
 License: MIT

{shrinkray-25.12.27.2.dist-info → shrinkray-25.12.27.3.dist-info}/RECORD

@@ -1,5 +1,5 @@
 shrinkray/__init__.py,sha256=b5MvcvhsEGYya3GRXNbCJAlAL5IZHSsETLK_vtfmXRY,18
-shrinkray/__main__.py,sha256=K3_s96Tyoi7SxNOyoZXkfiEoSxVBL__TJ3o2Cefadmg,11093
+shrinkray/__main__.py,sha256=HuDZFXgD9LH3XPBK2QBvP4YkyTFJvduK9-PVtz9fKpk,11762
 shrinkray/cli.py,sha256=1-qjaIchyCDd-YCdGWtK7q9j9qr6uX6AqtwW8m5QCQg,1697
 shrinkray/display.py,sha256=WYN05uqmUVpZhwi2pxr1U-wLHWZ9KiL0RUlTCBJ1N3E,2430
 shrinkray/formatting.py,sha256=tXCGnhJn-WJGpHMaLHRCAXK8aKJBbrOdiW9QGERrQEk,3121
@@ -7,9 +7,10 @@ shrinkray/problem.py,sha256=_edENYk8OC5o_2ng0WZrhIfilhlY5IuOrqt0qWBZAuM,25979
 shrinkray/process.py,sha256=-eP8h5X0ESbkcTic8FFEzkd4-vwaZ0YI5tLxUR25L8U,1599
 shrinkray/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 shrinkray/reducer.py,sha256=t2BBjq-EZ0qBbsez4ep0tFYCkDT8RwKYnjJ2fRsXubg,20096
-shrinkray/state.py,sha256=owyDNiSeHKnCsgOQczSz796KEANem-4YWTmbmZBRE0w,24040
-shrinkray/tui.py,sha256=3RskLo6JvKdUQIHi40R5ka-F_1GkBXyA_d_SkYbLlCw,31601
+shrinkray/state.py,sha256=a8Xq7IQwLz7CyZ58zU0Z91uoglgPJmhQUvbcdgsIoKk,29593
+shrinkray/tui.py,sha256=Ovd6Kbk_cmOYJlwnjEyl6ka_2g1qJAtwxojh5CWEzNA,33001
 shrinkray/ui.py,sha256=xuDUwU-MM3AetvwUB7bfzav0P_drUsBrKFPhON_Nr-k,2251
+shrinkray/validation.py,sha256=piBCO-k9he_id6TWC4EHMK3GfuyPqRcNfkNJPVjxEaU,13366
 shrinkray/work.py,sha256=GEZ14Kk3bvwUxAnACvY-wom2lVWaGrELMNxrDjv03dk,8110
 shrinkray/passes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 shrinkray/passes/bytes.py,sha256=U1sNAuqUlsaLpRSJuS9X4H7S2jOiilTUIIE9-WjSd4k,23967
@@ -22,12 +23,12 @@ shrinkray/passes/python.py,sha256=3WN1lZTf5oVL8FCTGomhrCuE04wIX9ocKcmFV86NMZA,68
 shrinkray/passes/sat.py,sha256=OboY6jsKf6lph3pAFh535plvhNOVzEF8HJ66WEqsNm4,19483
 shrinkray/passes/sequences.py,sha256=jCK1fWBxCz79u7JWSps9wf7Yru7W_FAsJwdgg--CLxU,3040
 shrinkray/subprocess/__init__.py,sha256=FyV2y05uwQ1RTZGwREI0aAVaLX1jiwRcWsdsksFmdbM,451
-shrinkray/subprocess/client.py,sha256=erqnPglPO0YNdwEKlmhB3yDo6Mfc00Lxh4T85lZhsDo,9341
-shrinkray/subprocess/protocol.py,sha256=LuHl0IkKpDzYhAGZz_EiTHNqDNq_v1ozg5aUSl7UzE4,6203
-shrinkray/subprocess/worker.py,sha256=ke-9DYFH117EpJEntkucTrn7ep7pygzmV-VXkRe1o-E,19294
-shrinkray-25.12.27.2.dist-info/licenses/LICENSE,sha256=iMKX79AuokJfIZUnGUARdUp30vVAoIPOJ7ek8TY63kk,1072
-shrinkray-25.12.27.2.dist-info/METADATA,sha256=-rrEVZeXrERITn0adTTOOi6Ui7fK6Dz-GvyFEQcHvtw,7600
-shrinkray-25.12.27.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-shrinkray-25.12.27.2.dist-info/entry_points.txt,sha256=wIZvnGyOdVeaLTiv2klnSyTe-EKkkwn4SwHh9bmJ7qk,104
-shrinkray-25.12.27.2.dist-info/top_level.txt,sha256=fLif8-rFoFOnf5h8-vs3ECkKNWQopTQh3xvl1s7pchQ,10
-shrinkray-25.12.27.2.dist-info/RECORD,,
+shrinkray/subprocess/client.py,sha256=abBkrXaJcA6cd3l_avPuteO_kYnjU5IRG7VtlmiAJgE,9428
+shrinkray/subprocess/protocol.py,sha256=fbY29q-j98KnAuZJ1Y_ARoi7BskkUu37SoybwVWb-pA,6636
+shrinkray/subprocess/worker.py,sha256=IBAXZq3E27bTuN9kHGgU5xhU6E8m_5-Ioz1dubVTuN8,21449
+shrinkray-25.12.27.3.dist-info/licenses/LICENSE,sha256=iMKX79AuokJfIZUnGUARdUp30vVAoIPOJ7ek8TY63kk,1072
+shrinkray-25.12.27.3.dist-info/METADATA,sha256=BUSNccYFT8TdtojoQHdt-YR9DEVtjsG8fNvlybnRsB0,7600
+shrinkray-25.12.27.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+shrinkray-25.12.27.3.dist-info/entry_points.txt,sha256=wIZvnGyOdVeaLTiv2klnSyTe-EKkkwn4SwHh9bmJ7qk,104
+shrinkray-25.12.27.3.dist-info/top_level.txt,sha256=fLif8-rFoFOnf5h8-vs3ECkKNWQopTQh3xvl1s7pchQ,10
+shrinkray-25.12.27.3.dist-info/RECORD,,