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

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)