codeplain 0.2.4__py3-none-any.whl → 0.2.5__py3-none-any.whl

tui/plain2code_tui.py

@@ -1,12 +1,12 @@
 import os
 import threading
 import time
-from typing import Callable
+from typing import Callable, Optional
 
 from textual.app import App, ComposeResult
 from textual.containers import Vertical, VerticalScroll
-from textual.widgets import ContentSwitcher, Footer, Header, Static
-from textual.worker import Worker, WorkerState
+from textual.widgets import ContentSwitcher, Static
+from textual.worker import Worker, WorkerFailed, WorkerState
 
 from event_bus import EventBus
 from plain2code_console import console
@@ -19,14 +19,19 @@ from plain2code_events import (
     RenderModuleStarted,
     RenderStateUpdated,
 )
+from plain2code_exceptions import InternalServerError
 from render_machine.states import States
+from tui.widget_helpers import log_to_widget
 
 from .components import (
+    CustomFooter,
     FRIDProgress,
     LogFilterChanged,
     LogLevelFilter,
+    RenderingInfoBox,
     ScriptOutputType,
     StructuredLogView,
+    TestScriptsContainer,
     TUIComponents,
 )
 from .state_handlers import (
@@ -37,6 +42,7 @@ from .state_handlers import (
     RenderErrorHandler,
     RenderSuccessHandler,
     ScriptOutputsHandler,
+    StateCompletionHandler,
     StateHandler,
     UnitTestsHandler,
 )
@@ -60,6 +66,7 @@ class Plain2CodeTUI(App):
         unittests_script: str,
         conformance_tests_script: str,
         prepare_environment_script: str,
+        state_machine_version: str,
         **kwargs,
     ):
         super().__init__(**kwargs)
@@ -67,21 +74,35 @@ class Plain2CodeTUI(App):
         self.event_bus = event_bus
         self.worker_fun = worker_fun
         self.render_id = render_id
-        self.unittests_script = unittests_script
-        self.conformance_tests_script = conformance_tests_script
-        self.prepare_environment_script = prepare_environment_script
+        self.unittests_script: Optional[str] = unittests_script
+        self.conformance_tests_script: Optional[str] = conformance_tests_script
+        self.prepare_environment_script: Optional[str] = prepare_environment_script
+        self.state_machine_version = state_machine_version
 
         # Initialize state handlers
         self._state_handlers: dict[str, StateHandler] = {
-            States.READY_FOR_FRID_IMPLEMENTATION.value: FridReadyHandler(self),
-            States.PROCESSING_UNIT_TESTS.value: UnitTestsHandler(self),
-            States.REFACTORING_CODE.value: RefactoringHandler(self),
-            States.PROCESSING_CONFORMANCE_TESTS.value: ConformanceTestsHandler(self),
-            States.FRID_FULLY_IMPLEMENTED.value: FridFullyImplementedHandler(self),
+            States.READY_FOR_FRID_IMPLEMENTATION.value: FridReadyHandler(
+                self, self.unittests_script, self.conformance_tests_script
+            ),
+            States.PROCESSING_UNIT_TESTS.value: UnitTestsHandler(
+                self, self.unittests_script, self.conformance_tests_script
+            ),
+            States.REFACTORING_CODE.value: RefactoringHandler(
+                self, self.unittests_script, self.conformance_tests_script
+            ),
+            States.PROCESSING_CONFORMANCE_TESTS.value: ConformanceTestsHandler(
+                self, self.unittests_script, self.conformance_tests_script
+            ),
+            States.FRID_FULLY_IMPLEMENTED.value: FridFullyImplementedHandler(
+                self, self.unittests_script, self.conformance_tests_script
+            ),
         }
         self._script_outputs_handler = ScriptOutputsHandler(self)
         self._render_error_handler = RenderErrorHandler(self)
         self._render_success_handler = RenderSuccessHandler(self)
+        self._state_completion_handler = StateCompletionHandler(
+            self, self.unittests_script, self.conformance_tests_script
+        )
 
     def get_active_script_types(self) -> list[ScriptOutputType]:
         """Get the list of active script output types based on which scripts exist.
@@ -114,52 +135,74 @@ class Plain2CodeTUI(App):
     def on_worker_state_changed(self, event: Worker.StateChanged) -> None:
         """Handle worker state changes."""
         if event.worker.state == WorkerState.ERROR:
-            # Exit the TUI and return the exception so the caller can handle it
-            self.exit(result=event.worker.error)
+            # Extract the original exception from WorkerFailed wrapper
+            error = event.worker.error
+            original_error = error.__cause__ if isinstance(error, WorkerFailed) and error.__cause__ else error
+
+            # Every error in worker thread gets converted to InternalServerError so it's handled by the common call to
+            # action in plain2code.py
+            internal_error = InternalServerError(str(original_error))
+            internal_error.__cause__ = original_error
+
+            # Exit the TUI and return the wrapped exception
+            self.exit(result=internal_error)
+
+    def _handle_exception(self, error: Exception) -> None:
+        """Override Textual's exception handler to suppress console tracebacks for worker errors.
+
+        Worker exceptions are logged to file via the logging system (configured in file handler in plain2code.py),
+        but the verbose Textual/Rich traceback is suppressed from the terminal. The clean error message
+        is displayed via the exception handlers in main().
+        """
+        # Because TUI is running in main thread and code renderer is running in a worker thread, textual models this
+        # by raising a WorkerFailed exception in this case
+        if isinstance(error, WorkerFailed):
+            # Here, we still print the error to get some additional information to the file, but it's probably
+            # not necessary because we either way print the entire traceback to the console. Here, we could in the future
+            # print more information if we would want to.
+            original_error = error.__cause__ if error.__cause__ else error
+            console.error(
+                f"Worker failed with exception: {type(original_error).__name__}: {original_error}",
+                exc_info=(type(original_error), original_error, original_error.__traceback__),
+                stack_info=False,
+            )
+            return
+
+        # For non-worker exceptions, use the default Textual behavior
+        super()._handle_exception(error)
 
     def compose(self) -> ComposeResult:
         """Create child widgets for the app."""
-        yield Header()
         with ContentSwitcher(id=TUIComponents.CONTENT_SWITCHER.value, initial=TUIComponents.DASHBOARD_VIEW.value):
             with Vertical(id=TUIComponents.DASHBOARD_VIEW.value):
                 with VerticalScroll():
                     yield Static(
-                        f"Render ID: {self.render_id}",
-                        id=TUIComponents.RENDER_ID_WIDGET.value,
+                        f"[#FFFFFF]*codeplain[/#FFFFFF] [#888888](v{self.state_machine_version})[/#888888]\n",
+                        id="codeplain-header",
+                        classes="codeplain-header",
                     )
                     yield Static(
-                        "Rendering in progress...",
+                        "[#FFFFFF]Rendering in progress...[/#FFFFFF]",
                         id=TUIComponents.RENDER_STATUS_WIDGET.value,
                     )
-                    yield FRIDProgress(id=TUIComponents.FRID_PROGRESS.value)
-
-                    # Get active script types for proper label alignment
-                    active_script_types = self.get_active_script_types()
-
-                    # Conditionally display unit test output widget
-                    if self.unittests_script is not None:
-                        yield Static(
-                            ScriptOutputType.UNIT_TEST_OUTPUT_TEXT.get_padded_label(active_script_types),
-                            id=TUIComponents.UNIT_TEST_SCRIPT_OUTPUT_WIDGET.value,
-                        )
-
-                    # Conditionally display conformance test output widget
-                    if self.conformance_tests_script is not None:
-                        yield Static(
-                            ScriptOutputType.CONFORMANCE_TEST_OUTPUT_TEXT.get_padded_label(active_script_types),
-                            id=TUIComponents.CONFORMANCE_TESTS_SCRIPT_OUTPUT_WIDGET.value,
-                        )
-
-                    # Conditionally display testing environment preparation output widget
-                    if self.prepare_environment_script is not None:
-                        yield Static(
-                            ScriptOutputType.TESTING_ENVIRONMENT_OUTPUT_TEXT.get_padded_label(active_script_types),
-                            id=TUIComponents.TESTING_ENVIRONMENT_SCRIPT_OUTPUT_WIDGET.value,
-                        )
+                    yield FRIDProgress(
+                        id=TUIComponents.FRID_PROGRESS.value,
+                        unittests_script=self.unittests_script,
+                        conformance_tests_script=self.conformance_tests_script,
+                    )
+
+                    # Test scripts container with border
+                    yield TestScriptsContainer(
+                        id=TUIComponents.TEST_SCRIPTS_CONTAINER.value,
+                        show_unit_test=self.unittests_script is not None,
+                        show_conformance_test=self.conformance_tests_script is not None,
+                        show_testing_env=self.prepare_environment_script is not None,
+                    )
             with Vertical(id=TUIComponents.LOG_VIEW.value):
                 yield LogLevelFilter(id=TUIComponents.LOG_FILTER.value)
+                yield Static("", classes="filter-spacer")
                 yield StructuredLogView(id=TUIComponents.LOG_WIDGET.value)
-        yield Footer()
+        yield CustomFooter(render_id=self.render_id)
 
     def action_toggle_logs(self) -> None:
         """Toggle between dashboard and log view."""
@@ -172,18 +215,20 @@ class Plain2CodeTUI(App):
     def on_render_module_started(self, event: RenderModuleStarted):
         """Update TUI based on the current state machine state."""
         try:
-            widget = self.query_one(f"#{TUIComponents.RENDER_MODULE_NAME_WIDGET.value}", Static)
-            widget.update(f"{FRIDProgress.RENDERING_MODULE_TEXT}{event.module_name}")
+            frid_progress = self.query_one(f"#{TUIComponents.FRID_PROGRESS.value}", FRIDProgress)
+            info_box = frid_progress.query_one(RenderingInfoBox)
+            info_box.update_module(f"{FRIDProgress.RENDERING_MODULE_TEXT}{event.module_name}")
         except Exception as e:
-            console.debug(f"Error updating render module name: {type(e).__name__}: {e}")
+            log_to_widget(self, "WARNING", f"Error updating render module name: {type(e).__name__}: {e}")
 
     def on_render_module_completed(self, _event: RenderModuleCompleted):
         """Update TUI based on the current state machine state."""
         try:
-            widget = self.query_one(f"#{TUIComponents.RENDER_MODULE_NAME_WIDGET.value}", Static)
-            widget.update(FRIDProgress.RENDERING_MODULE_TEXT)
+            frid_progress = self.query_one(f"#{TUIComponents.FRID_PROGRESS.value}", FRIDProgress)
+            info_box = frid_progress.query_one(RenderingInfoBox)
+            info_box.update_module(FRIDProgress.RENDERING_MODULE_TEXT)
         except Exception as e:
-            console.debug(f"Error resetting render module name: {type(e).__name__}: {e}")
+            log_to_widget(self, "WARNING", f"Error resetting render module name: {type(e).__name__}: {e}")
 
     def on_log_message_emitted(self, event: LogMessageEmitted):
         try:
@@ -196,7 +241,9 @@ class Plain2CodeTUI(App):
                 event.timestamp,
             )
         except Exception as e:
-            console.debug(f"Error adding log message from {event.logger_name}: {type(e).__name__}: {e}")
+            log_to_widget(
+                self, "WARNING", f"Error adding log message from {event.logger_name}: {type(e).__name__}: {e}"
+            )
 
     def on_log_filter_changed(self, event: LogFilterChanged):
         """Handle log filter changes from LogLevelFilter widget."""
@@ -204,7 +251,7 @@ class Plain2CodeTUI(App):
             log_widget = self.query_one(f"#{TUIComponents.LOG_WIDGET.value}", StructuredLogView)
             log_widget.filter_logs(event.min_level)
         except Exception as e:
-            console.debug(f"Error filtering logs to level {event.min_level}: {type(e).__name__}: {e}")
+            log_to_widget(self, "WARNING", f"Error filtering logs to level {event.min_level}: {type(e).__name__}: {e}")
 
     def on_render_state_updated(self, event: RenderStateUpdated):
         """Update TUI based on the current state machine state."""
@@ -231,6 +278,8 @@ class Plain2CodeTUI(App):
         if snapshot.script_execution_history.should_update_script_outputs:
             self._script_outputs_handler.handle(segments, snapshot, previous_state_segments)
 
+        self._state_completion_handler.handle(segments, snapshot, previous_state_segments)
+
     def on_render_completed(self, _event: RenderCompleted):
         """Handle successful render completion."""
         self._render_success_handler.handle()
@@ -250,7 +299,7 @@ class Plain2CodeTUI(App):
                     # It ensures terminal reset sequences are flushed before exiting.
                     self._driver.suspend_application_mode()
             except Exception as e:
-                console.debug(f"Error suspending application mode: {type(e).__name__}: {e}")
+                log_to_widget(self, "WARNING", f"Error suspending application mode: {type(e).__name__}: {e}")
             finally:
                 os._exit(0)  # Kill process immediately, no cleanup - terminates all threads
 

tui/state_handlers.py

@@ -1,12 +1,13 @@
 """State handlers for Plain2Code TUI state machine transitions."""
 
 from abc import ABC, abstractmethod
+from typing import Optional
 
 from plain2code_events import RenderContextSnapshot
 from render_machine.states import States
 
 from . import components as tui_components
-from .components import ProgressItem, ScriptOutputType, TUIComponents
+from .components import ProgressItem, ScriptOutputType, TestScriptsContainer, TUIComponents
 from .models import Substate
 from .widget_helpers import (
     display_error_message,
@@ -15,7 +16,6 @@ from .widget_helpers import (
     set_frid_progress_to_stopped,
     update_progress_item_status,
     update_progress_item_substates,
-    update_widget_text,
 )
 
 
@@ -53,13 +53,15 @@ class StateHandler(ABC):
 class FridReadyHandler(StateHandler):
     """Handler for READY_FOR_FRID_IMPLEMENTATION state."""
 
-    def __init__(self, tui):
+    def __init__(self, tui, unittests_script: Optional[str], conformance_tests_script: Optional[str]):
         """Initialize handler with TUI instance.
 
         Args:
             tui: The Plain2CodeTUI instance
         """
         self.tui = tui
+        self.unittests_script = unittests_script
+        self.conformance_tests_script = conformance_tests_script
 
     def handle(self, _: list[str], snapshot: RenderContextSnapshot, _previous_state_segments: list[str]) -> None:
         """Handle READY_FOR_FRID_IMPLEMENTATION state."""
@@ -69,9 +71,13 @@ class FridReadyHandler(StateHandler):
 
         # Set progress states
         update_progress_item_status(self.tui, TUIComponents.FRID_PROGRESS_RENDER_FR.value, ProgressItem.PROCESSING)
-        update_progress_item_status(self.tui, TUIComponents.FRID_PROGRESS_CONFORMANCE_TEST.value, ProgressItem.PENDING)
+        if self.conformance_tests_script is not None:
+            update_progress_item_status(
+                self.tui, TUIComponents.FRID_PROGRESS_CONFORMANCE_TEST.value, ProgressItem.PENDING
+            )
         # Reset others to PENDING if this is a restart/loop
-        update_progress_item_status(self.tui, TUIComponents.FRID_PROGRESS_UNIT_TEST.value, ProgressItem.PENDING)
+        if self.unittests_script is not None:
+            update_progress_item_status(self.tui, TUIComponents.FRID_PROGRESS_UNIT_TEST.value, ProgressItem.PENDING)
         update_progress_item_status(self.tui, TUIComponents.FRID_PROGRESS_REFACTORING.value, ProgressItem.PENDING)
 
         # Set substate for initial implementation
@@ -85,51 +91,59 @@ class FridReadyHandler(StateHandler):
 class UnitTestsHandler(StateHandler):
     """Handler for PROCESSING_UNIT_TESTS state."""
 
-    def __init__(self, tui):
+    def __init__(self, tui, unittests_script: Optional[str], conformance_tests_script: Optional[str]):
         """Initialize handler with TUI instance.
 
         Args:
             tui: The Plain2CodeTUI instance
         """
         self.tui = tui
+        self.unittests_script = unittests_script
+        self.conformance_tests_script = conformance_tests_script
 
     def handle(
         self, segments: list[str], _snapshot: RenderContextSnapshot, _previous_state_segments: list[str]
     ) -> None:
         """Handle PROCESSING_UNIT_TESTS state."""
         if segments[2] == States.UNIT_TESTS_READY.value:
-            update_progress_item_status(self.tui, TUIComponents.FRID_PROGRESS_RENDER_FR.value, ProgressItem.COMPLETED)
-            update_progress_item_status(self.tui, TUIComponents.FRID_PROGRESS_UNIT_TEST.value, ProgressItem.PROCESSING)
+            if self.unittests_script is not None:
+                update_progress_item_status(
+                    self.tui, TUIComponents.FRID_PROGRESS_UNIT_TEST.value, ProgressItem.PROCESSING
+                )
 
             # Clear substates from completed implementation phase
-            update_progress_item_substates(
-                self.tui,
-                TUIComponents.FRID_PROGRESS_UNIT_TEST.value,
-                [Substate("Running unit tests")],
-            )
+            if self.unittests_script is not None:
+                update_progress_item_substates(
+                    self.tui,
+                    TUIComponents.FRID_PROGRESS_UNIT_TEST.value,
+                    [Substate("Running unit tests")],
+                )
+
         if segments[2] == States.UNIT_TESTS_FAILED.value:
-            update_progress_item_substates(
-                self.tui,
-                TUIComponents.FRID_PROGRESS_UNIT_TEST.value,
-                [Substate("Fixing unit tests")],
-            )
+            if self.unittests_script is not None:
+                update_progress_item_substates(
+                    self.tui,
+                    TUIComponents.FRID_PROGRESS_UNIT_TEST.value,
+                    [Substate("Fixing unit tests")],
+                )
 
 
 class RefactoringHandler(StateHandler):
     """Handler for REFACTORING_CODE state."""
 
-    def __init__(self, tui):
+    def __init__(self, tui, unittests_script: Optional[str], conformance_tests_script: Optional[str]):
         """Initialize handler with TUI instance.
 
         Args:
             tui: The Plain2CodeTUI instance
         """
         self.tui = tui
+        self.unittests_script = unittests_script
+        self.conformance_tests_script = conformance_tests_script
 
     def handle(self, segments: list[str], _snapshot: RenderContextSnapshot, previous_state_segments: list[str]) -> None:
         """Handle REFACTORING_CODE state."""
         if len(previous_state_segments) == 2 and previous_state_segments[1] == States.STEP_COMPLETED.value:
-            update_progress_item_status(self.tui, TUIComponents.FRID_PROGRESS_UNIT_TEST.value, ProgressItem.COMPLETED)
             update_progress_item_status(
                 self.tui, TUIComponents.FRID_PROGRESS_REFACTORING.value, ProgressItem.PROCESSING
             )
@@ -151,7 +165,7 @@ class RefactoringHandler(StateHandler):
             elif segments[3] == States.UNIT_TESTS_FAILED.value:
                 update_progress_item_substates(
                     self.tui,
-                    TUIComponents.FRID_PROGRESS_UNIT_TEST.value,
+                    TUIComponents.FRID_PROGRESS_REFACTORING.value,
                     [Substate("Refactoring code", children=[Substate("Fixing unit tests")])],
                 )
 
@@ -159,21 +173,23 @@ class RefactoringHandler(StateHandler):
 class ConformanceTestsHandler(StateHandler):
     """Handler for PROCESSING_CONFORMANCE_TESTS state."""
 
-    def __init__(self, tui):
+    def __init__(self, tui, unittests_script: Optional[str], conformance_tests_script: Optional[str]):
         """Initialize handler with TUI instance.
 
         Args:
             tui: The Plain2CodeTUI instance
         """
         self.tui = tui
+        self.unittests_script = unittests_script
+        self.conformance_tests_script = conformance_tests_script
 
     def handle(self, segments: list[str], snapshot: RenderContextSnapshot, previous_state_segments: list[str]) -> None:
         """Handle PROCESSING_CONFORMANCE_TESTS state."""
         if previous_state_segments[1] == States.REFACTORING_CODE.value:
-            update_progress_item_status(self.tui, TUIComponents.FRID_PROGRESS_REFACTORING.value, ProgressItem.COMPLETED)
-            update_progress_item_status(
-                self.tui, TUIComponents.FRID_PROGRESS_CONFORMANCE_TEST.value, ProgressItem.PROCESSING
-            )
+            if self.conformance_tests_script is not None:
+                update_progress_item_status(
+                    self.tui, TUIComponents.FRID_PROGRESS_CONFORMANCE_TEST.value, ProgressItem.PROCESSING
+                )
 
         if segments[2] != States.POSTPROCESSING_CONFORMANCE_TESTS.value:
             if segments[2] == States.CONFORMANCE_TESTING_INITIALISED.value:
@@ -229,50 +245,47 @@ class ScriptOutputsHandler(StateHandler):
         self.tui = tui
 
     def handle(self, _segments: list[str], snapshot: RenderContextSnapshot, previous_state_segments: list[str]) -> None:
-        # Get active script types for proper label alignment
-        active_script_types = self.tui.get_active_script_types()
+        # Update test scripts container
+        container = self.tui.query_one(f"#{TUIComponents.TEST_SCRIPTS_CONTAINER.value}", TestScriptsContainer)
 
         if any(segment == States.UNIT_TESTS_READY.value for segment in previous_state_segments):
-            update_widget_text(
-                self.tui,
-                TUIComponents.UNIT_TEST_SCRIPT_OUTPUT_WIDGET.value,
-                f"{ScriptOutputType.UNIT_TEST_OUTPUT_TEXT.get_padded_label(active_script_types)}{snapshot.script_execution_history.latest_unit_test_output_path}",  # type: ignore
-            )
+            if snapshot.script_execution_history.latest_unit_test_output_path:
+                container.update_unit_test(
+                    f"{ScriptOutputType.UNIT_TEST_OUTPUT_TEXT.value}{snapshot.script_execution_history.latest_unit_test_output_path}"
+                )
 
         if len(previous_state_segments) > 2 and previous_state_segments[2] == States.CONFORMANCE_TEST_GENERATED.value:
-            update_widget_text(
-                self.tui,
-                TUIComponents.TESTING_ENVIRONMENT_SCRIPT_OUTPUT_WIDGET.value,
-                f"{ScriptOutputType.TESTING_ENVIRONMENT_OUTPUT_TEXT.get_padded_label(active_script_types)}{snapshot.script_execution_history.latest_testing_environment_output_path}",  # type: ignore
-            )
+            if snapshot.script_execution_history.latest_testing_environment_output_path:
+                container.update_testing_env(
+                    f"{ScriptOutputType.TESTING_ENVIRONMENT_OUTPUT_TEXT.value}{snapshot.script_execution_history.latest_testing_environment_output_path}"
+                )
 
         if (
             len(previous_state_segments) > 2
             and previous_state_segments[2] == States.CONFORMANCE_TEST_ENV_PREPARED.value
         ):
-            update_widget_text(
-                self.tui,
-                TUIComponents.CONFORMANCE_TESTS_SCRIPT_OUTPUT_WIDGET.value,
-                f"{ScriptOutputType.CONFORMANCE_TEST_OUTPUT_TEXT.get_padded_label(active_script_types)}{snapshot.script_execution_history.latest_conformance_test_output_path}",  # type: ignore
-            )
+            if snapshot.script_execution_history.latest_conformance_test_output_path:
+                container.update_conformance_test(
+                    f"{ScriptOutputType.CONFORMANCE_TEST_OUTPUT_TEXT.value}{snapshot.script_execution_history.latest_conformance_test_output_path}"
+                )
 
 
 class FridFullyImplementedHandler(StateHandler):
     """Handler for FRID_FULLY_IMPLEMENTED state."""
 
-    def __init__(self, tui):
+    def __init__(self, tui, unittests_script: Optional[str], conformance_tests_script: Optional[str]):
         """Initialize handler with TUI instance.
 
         Args:
             tui: The Plain2CodeTUI instance
         """
         self.tui = tui
+        self.unittests_script = unittests_script
+        self.conformance_tests_script = conformance_tests_script
 
     def handle(self, _: list[str], _snapshot: RenderContextSnapshot, _previous_state_segments: list[str]) -> None:
         """Handle FRID_FULLY_IMPLEMENTED state."""
-        update_progress_item_status(
-            self.tui, TUIComponents.FRID_PROGRESS_CONFORMANCE_TEST.value, ProgressItem.COMPLETED
-        )
+        pass
 
 
 class RenderSuccessHandler:
@@ -305,3 +318,37 @@ class RenderErrorHandler:
     def handle(self, error_message: str) -> None:
         set_frid_progress_to_stopped(self.tui)
         display_error_message(self.tui, error_message)
+
+
+class StateCompletionHandler(StateHandler):
+    """Handler for state completion."""
+
+    def __init__(self, tui, unittests_script: Optional[str], conformance_tests_script: Optional[str]):
+        """Initialize handler with TUI instance.
+
+        Args:
+            tui: The Plain2CodeTUI instance
+        """
+        self.tui = tui
+        self.unittests_script = unittests_script
+        self.conformance_tests_script = conformance_tests_script
+
+    def handle(self, segments: list[str], _snapshot: RenderContextSnapshot, previous_state_segments: list[str]) -> None:
+        if len(previous_state_segments) < 2 or len(segments) < 2:
+            return
+        current_segment = segments[1]
+        previous_segment = previous_state_segments[1]
+        should_update_state = current_segment != previous_segment
+        if not should_update_state:
+            return
+
+        if previous_segment == States.READY_FOR_FRID_IMPLEMENTATION.value:
+            update_progress_item_status(self.tui, TUIComponents.FRID_PROGRESS_RENDER_FR.value, ProgressItem.COMPLETED)
+        if previous_segment == States.PROCESSING_UNIT_TESTS.value:
+            update_progress_item_status(self.tui, TUIComponents.FRID_PROGRESS_UNIT_TEST.value, ProgressItem.COMPLETED)
+        if previous_segment == States.REFACTORING_CODE.value:
+            update_progress_item_status(self.tui, TUIComponents.FRID_PROGRESS_REFACTORING.value, ProgressItem.COMPLETED)
+        if previous_segment == States.PROCESSING_CONFORMANCE_TESTS.value:
+            update_progress_item_status(
+                self.tui, TUIComponents.FRID_PROGRESS_CONFORMANCE_TEST.value, ProgressItem.COMPLETED
+            )