Enable error codes and TUI render in Context Panel (#445)

* Enable error codes and TUI render in Context Panel

* Optimize error code for less repeat logic

Author: lukehinds

deepfabric/error_codes.py

@@ -21,6 +21,7 @@
     INTERRUPTED_DATASET_FILENAME,
 )
 from .dataset import Dataset
+from .error_codes import classify_error
 from .exceptions import DataSetGeneratorError
 from .llm import LLMClient
 from .metrics import trace
@@ -422,7 +423,7 @@ async def _generate(
             tasks.append(asyncio.create_task(_generate(prompt, start_sample_idx + idx, path_info)))
         results = await asyncio.gather(*tasks)
 
-        for success, payload in results:
+        for idx, (success, payload) in enumerate(results):
             if success:
                 samples.append(payload)
             else:
@@ -434,6 +435,18 @@ async def _generate(
                 )
                 self.failure_analysis[failure_type].append(error_msg)
 
+                # Classify and emit error to progress reporter
+                classified = classify_error(
+                    error if isinstance(error, Exception) else str(error),
+                    provider=self.provider,
+                    context={"error_type": failure_type},
+                )
+                if self.progress_reporter:
+                    self.progress_reporter.emit_error(
+                        classified,
+                        sample_idx=start_sample_idx + idx,
+                    )
+
         return samples, failed_responses
 
     def analyze_failure(self, response_content: str, error: Exception | None = None) -> str:

deepfabric/generator.py

@@ -8,7 +8,10 @@
 metrics, etc.) to react to progress events.
 """
 
-from typing import Any, Protocol
+from typing import TYPE_CHECKING, Any, Protocol
+
+if TYPE_CHECKING:
+    from .error_codes import ClassifiedError
 
 
 class StreamObserver(Protocol):
@@ -50,6 +53,15 @@ def on_step_complete(self, step_name: str, metadata: dict[str, Any]) -> None:
         """
         ...
 
+    def on_error(self, error: "ClassifiedError", metadata: dict[str, Any]) -> None:
+        """Called when an error occurs during generation.
+
+        Args:
+            error: ClassifiedError with error code and details
+            metadata: Additional context (sample_idx, step, etc.)
+        """
+        ...
+
 
 class ProgressReporter:
     """Central progress reporter that notifies observers of generation events.
@@ -118,6 +130,17 @@ def emit_step_complete(self, step_name: str, **metadata) -> None:
         for observer in self._observers:
             observer.on_step_complete(step_name, metadata)
 
+    def emit_error(self, error: "ClassifiedError", **metadata) -> None:
+        """Emit an error event to all observers.
+
+        Args:
+            error: ClassifiedError with error code and details
+            **metadata: Additional context as keyword arguments
+        """
+        for observer in self._observers:
+            if hasattr(observer, "on_error"):
+                observer.on_error(error, metadata)
+
 
 # Convenience context manager for tracking steps
 class ProgressStep:

deepfabric/progress.py

@@ -5,7 +5,7 @@
 from collections import deque
 from dataclasses import dataclass
 from time import monotonic
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 from rich.console import Console, RenderableType
 from rich.layout import Layout
@@ -24,6 +24,67 @@
 
 from .progress import StreamObserver
 
+if TYPE_CHECKING:
+    from .error_codes import ClassifiedError
+
+
+class TopicBuildingMixin:
+    """Mixin providing shared functionality for Tree and Graph building TUIs.
+
+    Provides common implementations for:
+    - _refresh_left(): Update events panel in left column
+    - on_error(): Handle error events from progress reporter
+    - on_step_start()/on_step_complete(): No-op handlers for step events
+    - update_status_panel(): Update status panel (requires _status_panel() in subclass)
+
+    Subclasses must have these attributes:
+    - tui: DeepFabricTUI instance
+    - live_layout: Layout | None
+    - events_log: deque
+    """
+
+    tui: "DeepFabricTUI"
+    live_layout: "Layout | None"
+    events_log: "deque"
+
+    def _refresh_left(self) -> None:
+        """Update events panel in left column."""
+        if self.live_layout is not None:
+            try:
+                self.live_layout["main"]["left"]["events"].update(
+                    self.tui.build_events_panel(list(self.events_log))
+                )
+            except Exception:
+                return
+
+    def on_error(self, error: "ClassifiedError", metadata: dict[str, Any]) -> None:  # noqa: ARG002
+        """Handle error events - log to events panel."""
+        error_event = error.to_event()
+        self.events_log.append(f"X {error_event}")
+        self._refresh_left()
+
+    def on_step_start(self, step_name: str, metadata: dict[str, Any]) -> None:  # noqa: ARG002
+        """Handle step start - topic building doesn't need specific handling."""
+        pass
+
+    def on_step_complete(self, step_name: str, metadata: dict[str, Any]) -> None:  # noqa: ARG002
+        """Handle step complete - topic building doesn't need specific handling."""
+        pass
+
+    def update_status_panel(self) -> None:
+        """Update the status panel in the right column."""
+        if self.live_layout is None:
+            return
+        try:
+            self.live_layout["main"]["right"]["status"].update(self._status_panel())
+        except Exception:
+            return
+
+    def _status_panel(self) -> Panel:
+        """Create status panel - must be implemented by subclass."""
+        raise NotImplementedError
+
+
 # Constants
 STREAM_BUFFER_DISPLAY_THRESHOLD = 1000  # Show ellipsis if accumulated text exceeds this
 STREAM_TEXT_MAX_LENGTH = 8000  # Max characters to display in streaming text
@@ -104,7 +165,19 @@ def build_events_panel(self, events: list[str], title: str = "Events") -> Panel:
             text = Text("Waiting...", style="dim")
         else:
             # Keep events short; show newest at bottom
-            text = Text("\n".join(events[-EVENT_LOG_MAX_LINES:]))
+            # Colorize based on prefix: X = red (error), checkmark = green (success)
+            text = Text()
+            for i, event in enumerate(events[-EVENT_LOG_MAX_LINES:]):
+                if i > 0:
+                    text.append("\n")
+                if event.startswith("X "):
+                    text.append("X ", style="bold red")
+                    text.append(event[2:])
+                elif event.startswith("✓ ") or event.startswith("✔ "):
+                    text.append(event[0] + " ", style="bold green")
+                    text.append(event[2:])
+                else:
+                    text.append(event)
         return Panel(text, title=title, border_style="dim", padding=(0, 1))
 
     def create_footer(self, layout: Layout, title: str = "Run Status") -> Progress:
@@ -183,7 +256,7 @@ def info(self, message: str) -> None:
         self.console.print(f" {message}", style="blue")
 
 
-class TreeBuildingTUI(StreamObserver):
+class TreeBuildingTUI(TopicBuildingMixin, StreamObserver):
     """TUI for tree building operations with simplified progress and streaming."""
 
     def __init__(self, tui: DeepFabricTUI):
@@ -355,24 +428,6 @@ def _refresh_context(self) -> None:
             except Exception:
                 return
 
-    def _refresh_left(self) -> None:
-        if self.live_layout is not None:
-            try:
-                # Update events panel in left column
-                self.live_layout["main"]["left"]["events"].update(
-                    self.tui.build_events_panel(list(self.events_log))
-                )
-            except Exception:
-                return
-
-    def on_step_start(self, step_name: str, metadata: dict[str, Any]) -> None:
-        """Handle step start - tree building doesn't need specific handling."""
-        pass
-
-    def on_step_complete(self, step_name: str, metadata: dict[str, Any]) -> None:
-        """Handle step complete - tree building doesn't need specific handling."""
-        pass
-
     def finish_building(self, total_paths: int, failed_generations: int) -> None:
         """Finish the tree building process."""
         if self.live_display:
@@ -400,16 +455,8 @@ def _status_panel(self) -> Panel:
             table.add_row("Failed:", str(self.failed_attempts))
         return Panel(table, title="Status", border_style="dim", padding=(0, 1))
 
-    def update_status_panel(self) -> None:
-        if self.live_layout is None:
-            return
-        try:
-            self.live_layout["main"]["right"]["status"].update(self._status_panel())
-        except Exception:
-            return
 
-
-class GraphBuildingTUI(StreamObserver):
+class GraphBuildingTUI(TopicBuildingMixin, StreamObserver):
     """TUI for graph building operations with simplified progress and streaming."""
 
     def __init__(self, tui: DeepFabricTUI):
@@ -576,23 +623,6 @@ def _refresh_context(self) -> None:
             except Exception:
                 return
 
-    def _refresh_left(self) -> None:
-        if self.live_layout is not None:
-            try:
-                self.live_layout["main"]["left"]["events"].update(
-                    self.tui.build_events_panel(list(self.events_log))
-                )
-            except Exception:
-                return
-
-    def on_step_start(self, step_name: str, metadata: dict[str, Any]) -> None:
-        """Handle step start - graph building doesn't need specific handling."""
-        pass
-
-    def on_step_complete(self, step_name: str, metadata: dict[str, Any]) -> None:
-        """Handle step complete - graph building doesn't need specific handling."""
-        pass
-
     def finish_building(self, failed_generations: int) -> None:
         """Finish the graph building process."""
         if self.live_display:
@@ -629,14 +659,6 @@ def _status_panel(self) -> Panel:
             table.add_row("Failed:", str(self.failed_attempts))
         return Panel(table, title="Status", border_style="dim", padding=(0, 1))
 
-    def update_status_panel(self) -> None:
-        if self.live_layout is None:
-            return
-        try:
-            self.live_layout["main"]["right"]["status"].update(self._status_panel())
-        except Exception:
-            return
-
 
 class DatasetGenerationTUI(StreamObserver):
     """Enhanced TUI for dataset generation with rich integration and streaming display."""
@@ -945,6 +967,27 @@ def log_event(self, message: str) -> None:
                 self.tui.build_events_panel(list(self.events_log))
             )
 
+    def on_error(self, error: "ClassifiedError", metadata: dict[str, Any]) -> None:
+        """Handle error events from the progress reporter.
+
+        Displays concise error information in the Events panel using
+        standardized DeepFabric error codes.
+
+        Args:
+            error: ClassifiedError with error code and details
+            metadata: Additional context (sample_idx, etc.)
+        """
+        # Format concise error message for Events panel
+        error_event = error.to_event()
+
+        # Add sample context if available
+        sample_idx = metadata.get("sample_idx")
+        if sample_idx is not None:
+            error_event = f"[{sample_idx}] {error_event}"
+
+        # Log to events panel with error indicator
+        self.log_event(f"X {error_event}")
+
 
 # Global TUI instances
 _tui_instance = None